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

moai_adk/statusline/version_reader.py

@@ -1,6 +1,5 @@
-# type: ignore
 """
-Enhanced Version reader for MoAI-ADK from config.json with performance optimizations
+Enhanced Version reader for MoAI-ADK from config.yaml with performance optimizations
 
 Refactored for improved performance, error handling, configurability, and caching strategies
 """
@@ -8,6 +7,7 @@ Refactored for improved performance, error handling, configurability, and cachin
 import asyncio
 import json
 import logging
+import os
 import re
 import time
 from dataclasses import dataclass, field
@@ -16,6 +16,8 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+import yaml
+
 logger = logging.getLogger(__name__)
 
 
@@ -70,12 +72,13 @@ class VersionConfig:
     track_performance_metrics: bool = True
 
     # Version field priority configuration
+    # Order: 1) MoAI package version, 2) Project version, 3) Fallbacks
     version_fields: List[str] = field(
         default_factory=lambda: [
-            "project.version",
-            "moai.version",
-            "version",
-            "moai.template_version",
+            "moai.version",  # ← 1st priority: MoAI-ADK version
+            "project.version",  # ← 2nd priority: Project version
+            "version",  # ← 3rd priority: General version
+            "project.template_version",  # ← 4th priority: Template version
             "template_version",
         ]
     )
@@ -101,27 +104,41 @@ class VersionReader:
     DEFAULT_CONFIG = VersionConfig()
 
     # Supported version fields in order of priority
+    # Order: 1) MoAI package version, 2) Project version, 3) Fallbacks
     DEFAULT_VERSION_FIELDS = [
-        "project.version",
-        "moai.version",
-        "version",
-        "moai.template_version",
+        "moai.version",  # ← 1st priority: MoAI-ADK version
+        "project.version",  # ← 2nd priority: Project version
+        "version",  # ← 3rd priority: General version
+        "project.template_version",  # ← 4th priority: Template version
         "template_version",
     ]
 
-    def __init__(self, config: Optional[VersionConfig] = None):
+    def __init__(self, config: Optional[VersionConfig] = None, working_dir: Optional[Path] = None):
         """
         Initialize version reader with enhanced configuration.
 
         Args:
             config: Version configuration object. If None, uses defaults.
+            working_dir: Working directory to search for config. If None, uses environment detection.
         """
         self.config = config or self.DEFAULT_CONFIG
-        self._config_path = Path.cwd() / ".moai" / "config" / "config.json"
+
+        # Determine working directory with priority:
+        # 1. Explicit working_dir parameter
+        # 2. CLAUDE_PROJECT_DIR environment variable (set by Claude Code)
+        # 3. Current working directory
+        if working_dir:
+            base_dir = Path(working_dir)
+        elif "CLAUDE_PROJECT_DIR" in os.environ:
+            base_dir = Path(os.environ["CLAUDE_PROJECT_DIR"])
+        else:
+            base_dir = Path.cwd()
+
+        self._config_path = base_dir / ".moai" / "config" / "config.yaml"
 
         # Enhanced caching with LRU support
         self._cache: Dict[str, CacheEntry] = {}
-        self._cache_stats = {
+        self._cache_stats: Dict[str, Any] = {
             "hits": 0,
             "misses": 0,
             "errors": 0,
@@ -133,7 +150,7 @@ class VersionReader:
         }
 
         # Performance tracking
-        self._performance_metrics = {
+        self._performance_metrics: Dict[str, List[float]] = {
             "read_times": [],
             "validation_times": [],
             "cache_operation_times": [],
@@ -160,16 +177,23 @@ class VersionReader:
         if self.config.debug_mode:
             self._logger.info(f"VersionReader initialized with config: {self.config}")
 
-    def get_version(self) -> str:
+    def get_version(self, force_refresh: bool = False) -> str:
         """
         Get MoAI-ADK version from config with enhanced caching.
 
+        Args:
+            force_refresh: If True, bypass cache and force fresh read
+
         Returns:
             Version string (e.g., "0.20.1" or "v0.20.1")
 
         Raises:
             VersionReadError: If version cannot be determined after fallbacks
         """
+        # Check if we need to force refresh
+        if force_refresh:
+            self.clear_cache()
+
         if self.config.enable_async:
             return asyncio.run(self.get_version_async())
         else:
@@ -179,6 +203,8 @@ class VersionReader:
         """
         Synchronous version getter for performance-critical paths.
 
+        Priority: installed package version > config file version > fallback
+
         Returns:
             Version string
         """
@@ -189,12 +215,17 @@ class VersionReader:
             version = self._check_cache()
             if version is not None:
                 self._cache_stats["hits"] += 1
-                self._cache_stats["cache_hits_by_source"][
-                    VersionSource.CACHE.value
-                ] += 1
+                self._cache_stats["cache_hits_by_source"][VersionSource.CACHE.value] += 1
+                return version
+
+            # Priority 1: Try installed package version first (most accurate)
+            version = self._get_package_version()
+            if version:
+                self._update_cache(version, VersionSource.CONFIG_FILE)
+                self._cache_stats["misses"] += 1
                 return version
 
-            # Read from config file
+            # Priority 2: Read from config file
             version = self._read_version_from_config_sync()
             if not version:
                 version = self._get_fallback_version()
@@ -213,6 +244,8 @@ class VersionReader:
         """
         Async version getter for better performance.
 
+        Priority: installed package version > config file version > fallback
+
         Returns:
             Version string
         """
@@ -223,12 +256,17 @@ class VersionReader:
             version = self._check_cache()
             if version is not None:
                 self._cache_stats["hits"] += 1
-                self._cache_stats["cache_hits_by_source"][
-                    VersionSource.CACHE.value
-                ] += 1
+                self._cache_stats["cache_hits_by_source"][VersionSource.CACHE.value] += 1
+                return version
+
+            # Priority 1: Try installed package version first (most accurate)
+            version = self._get_package_version()
+            if version:
+                self._update_cache(version, VersionSource.CONFIG_FILE)
+                self._cache_stats["misses"] += 1
                 return version
 
-            # Read from config file asynchronously
+            # Priority 2: Read from config file asynchronously
             version = await self._read_version_from_config_async()
             if not version:
                 version = self._get_fallback_version()
@@ -264,14 +302,10 @@ class VersionReader:
                 entry.access_count += 1
                 entry.last_access = datetime.now()
                 self._cache_stats["hits"] += 1
-                self._cache_stats["cache_hits_by_source"][
-                    VersionSource.CACHE.value
-                ] += 1
+                self._cache_stats["cache_hits_by_source"][VersionSource.CACHE.value] += 1
 
                 if self.config.debug_mode:
-                    self._logger.debug(
-                        f"Cache hit: {entry.version} (source: {entry.source.value})"
-                    )
+                    self._logger.debug(f"Cache hit: {entry.version} (source: {entry.source.value})")
 
                 return entry.version
 
@@ -316,9 +350,7 @@ class VersionReader:
             self._evict_oldest_cache_entry()
 
         if self.config.debug_mode:
-            self._logger.debug(
-                f"Cache updated with version: {version} (source: {source.value})"
-            )
+            self._logger.debug(f"Cache updated with version: {version} (source: {source.value})")
 
     def _evict_oldest_cache_entry(self) -> None:
         """
@@ -387,7 +419,7 @@ class VersionReader:
         Returns:
             Dictionary containing performance metrics
         """
-        metrics = {
+        metrics: Dict[str, Any] = {
             "cache_stats": self._cache_stats.copy(),
             "cache_size": len(self._cache),
             "max_cache_size": self.config.cache_size,
@@ -409,7 +441,7 @@ class VersionReader:
 
     def _read_version_from_config_sync(self) -> str:
         """
-        Synchronous version of reading from .moai/config/config.json.
+        Synchronous version of reading from .moai/config/config.yaml.
 
         Returns:
             Version string or empty string if not found
@@ -420,11 +452,11 @@ class VersionReader:
                 return ""
 
             try:
-                config_data = self._read_json_sync(self._config_path)
+                config_data = self._read_config_sync(self._config_path)
                 version = self._extract_version_from_config(config_data)
                 return version if version else ""
-            except json.JSONDecodeError as e:
-                logger.error(f"Invalid JSON in config {self._config_path}: {e}")
+            except (json.JSONDecodeError, yaml.YAMLError) as e:
+                logger.error(f"Invalid config in {self._config_path}: {e}")
                 return ""
 
         except Exception as e:
@@ -433,7 +465,7 @@ class VersionReader:
 
     async def _read_version_from_config_async(self) -> str:
         """
-        Read version from .moai/config/config.json asynchronously.
+        Read version from .moai/config/config.yaml asynchronously.
 
         Returns:
             Version string or empty string if not found
@@ -444,10 +476,10 @@ class VersionReader:
                 return ""
 
             try:
-                config_data = await self._read_json_async(self._config_path)
+                config_data = await self._read_config_async(self._config_path)
                 return self._extract_version_from_config(config_data)
-            except json.JSONDecodeError as e:
-                logger.error(f"Invalid JSON in config {self._config_path}: {e}")
+            except (json.JSONDecodeError, yaml.YAMLError) as e:
+                logger.error(f"Invalid config in {self._config_path}: {e}")
                 return ""
 
         except Exception as e:
@@ -474,9 +506,7 @@ class VersionReader:
         logger.debug("No version field found in config")
         return ""
 
-    def _get_nested_value(
-        self, config: Dict[str, Any], field_path: str
-    ) -> Optional[str]:
+    def _get_nested_value(self, config: Dict[str, Any], field_path: str) -> Optional[str]:
         """
         Get nested value from config using dot notation.
 
@@ -546,10 +576,43 @@ class VersionReader:
         Returns:
             Fallback version string
         """
+        # Try to get version from package metadata first
+        pkg_version = self._get_package_version()
+        if pkg_version:
+            self._logger.debug(f"Using package metadata version: {pkg_version}")
+            return pkg_version
+
+        # Fall back to configured fallback version
         fallback = self.config.fallback_version
-        self._logger.debug(f"Using fallback version: {fallback}")
+        self._logger.debug(f"Using configured fallback version: {fallback}")
         return fallback
 
+    def _get_package_version(self) -> str:
+        """
+        Get version from installed moai-adk package metadata.
+
+        This allows the statusline to work even when .moai/config/config.json
+        is not found, as long as the moai-adk package is installed.
+
+        Returns:
+            Version string or empty string if package not found
+        """
+        try:
+            from importlib.metadata import PackageNotFoundError, version
+
+            try:
+                pkg_version = version("moai-adk")
+                self._logger.debug(f"Found moai-adk package version: {pkg_version}")
+                return pkg_version
+            except PackageNotFoundError:
+                self._logger.debug("moai-adk package not found in metadata")
+                return ""
+        except ImportError:
+            self._logger.debug("importlib.metadata not available")
+            return ""
+        except Exception as e:
+            self._logger.debug(f"Error getting package version: {e}")
+            return ""
 
     async def _file_exists_async(self, path: Path) -> bool:
         """Async file existence check"""
@@ -569,11 +632,37 @@ class VersionReader:
         with open(path, "r", encoding="utf-8") as f:
             return json.load(f)
 
+    async def _read_config_async(self, path: Path) -> Dict[str, Any]:
+        """Async config file reading (supports YAML and JSON)"""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self._read_config_sync, path)
+
+    def _read_config_sync(self, path: Path) -> Dict[str, Any]:
+        """Synchronous config file reading (supports YAML and JSON)"""
+        with open(path, "r", encoding="utf-8") as f:
+            if path.suffix in (".yaml", ".yml"):
+                return yaml.safe_load(f) or {}
+            else:
+                return json.load(f)
+
     # Backwards compatibility cache methods
     def clear_cache(self) -> None:
         """Clear version cache (backwards compatibility)"""
         self._version_cache = None
         self._cache_time = None
+        # Also clear the main cache dictionary
+        self._cache.clear()
+        # Reset cache statistics
+        self._cache_stats = {
+            "hits": 0,
+            "misses": 0,
+            "errors": 0,
+            "cache_hits_by_source": {
+                VersionSource.CONFIG_FILE.value: 0,
+                VersionSource.CACHE.value: 0,
+                VersionSource.FALLBACK.value: 0,
+            },
+        }
         logger.debug("Version cache cleared")
 
     def get_cache_stats(self) -> Dict[str, int]:
@@ -603,7 +692,12 @@ class VersionReader:
         Returns:
             True if cache is expired
         """
-        return not self._is_cache_valid()
+        # Check if cache entry exists and is still valid
+        config_key = str(self._config_path)
+        if config_key not in self._cache:
+            return True
+        entry = self._cache[config_key]
+        return not self._is_cache_entry_valid(entry)
 
     def get_config(self) -> VersionConfig:
         """Get current configuration"""