moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/statusline/__init__.py

@@ -16,6 +16,7 @@ __version__ = "0.1.0"
 from .alfred_detector import AlfredDetector, AlfredTask
 from .config import StatuslineConfig
 from .git_collector import GitCollector, GitInfo
+from .memory_collector import MemoryCollector, MemoryInfo
 from .metrics_tracker import MetricsTracker
 from .renderer import StatuslineData, StatuslineRenderer
 from .update_checker import UpdateChecker, UpdateInfo
@@ -27,6 +28,8 @@ __all__ = [
     "StatuslineConfig",
     "GitCollector",
     "GitInfo",
+    "MemoryCollector",
+    "MemoryInfo",
     "MetricsTracker",
     "AlfredDetector",
     "AlfredTask",

moai_adk/statusline/enhanced_output_style_detector.py

@@ -58,7 +58,7 @@ class OutputStyleDetector:
 
     def __init__(self):
         self.cache = {}
-        self.cache_ttl = 5  # Cache for 5 seconds to balance performance and accuracy
+        self.cache_ttl: float = 5.0  # Cache for 5 seconds to balance performance and accuracy
 
     def detect_from_session_context(self, session_data: Dict[str, Any]) -> Optional[str]:
         """
@@ -291,7 +291,7 @@ class OutputStyleDetector:
             print(f"Message pattern analysis error: {e}", file=sys.stderr)
             return None
 
-    def get_output_style(self, session_context: Dict[str, Any] = None) -> str:
+    def get_output_style(self, session_context: Optional[Dict[str, Any]] = None) -> str:
         """
         Get the current output style using all available detection methods.
 
@@ -332,8 +332,8 @@ class OutputStyleDetector:
                 print(f"{method_name} detection failed: {e}", file=sys.stderr)
                 continue
 
-        # Default fallback
-        return "R2-D2"
+        # Default fallback - Mr. Alfred is the default output style
+        return "Mr. Alfred"
 
 
 def safe_collect_output_style() -> str:
@@ -363,7 +363,7 @@ def safe_collect_output_style() -> str:
 
     except Exception as e:
         print(f"Output style detection failed: {e}", file=sys.stderr)
-        return "R2-D2"
+        return "Mr. Alfred"
 
 
 # For backward compatibility

moai_adk/statusline/main.py

@@ -1,4 +1,5 @@
 # type: ignore
+# -*- coding: utf-8 -*-
 #!/usr/bin/env python3
 """
 Claude Code Statusline Integration
@@ -125,6 +126,23 @@ def safe_collect_version() -> str:
 # safe_collect_output_style function removed - no longer needed
 
 
+def safe_collect_memory() -> str:
+    """
+    Safely collect memory usage with fallback.
+
+    Returns:
+        Formatted memory usage string (e.g., "128MB")
+    """
+    try:
+        from .memory_collector import MemoryCollector
+
+        collector = MemoryCollector()
+        return collector.get_display_string(mode="process")
+    except (ImportError, OSError, AttributeError, RuntimeError):
+        # Memory collector errors
+        return "N/A"
+
+
 def safe_check_update(current_version: str) -> tuple[bool, Optional[str]]:
     """
     Safely check for updates with fallback.
@@ -246,6 +264,7 @@ def build_statusline_data(session_context: dict, mode: str = "compact") -> str:
         duration = safe_collect_duration()
         active_task = safe_collect_alfred_task()
         version = safe_collect_version()
+        memory_usage = safe_collect_memory()
         update_available, latest_version = safe_check_update(version)
 
         # Build StatuslineData with dynamic fields
@@ -253,7 +272,7 @@ def build_statusline_data(session_context: dict, mode: str = "compact") -> str:
             model=model,
             claude_version=claude_version,
             version=version,
-            memory_usage="256MB",  # TODO: Get actual memory usage
+            memory_usage=memory_usage,
             branch=branch,
             git_status=git_status,
             duration=duration,

moai_adk/statusline/memory_collector.py

@@ -0,0 +1,268 @@
+"""
+Memory collector for MoAI-ADK statusline
+
+Collects memory usage information for display in the status bar.
+Uses psutil for cross-platform memory monitoring.
+"""
+
+import logging
+import os
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MemoryInfo:
+    """Memory usage information"""
+
+    # Process memory (current Python process)
+    process_rss_mb: float  # Resident Set Size
+    process_vms_mb: float  # Virtual Memory Size
+
+    # System memory
+    system_total_mb: float
+    system_available_mb: float
+    system_percent: float
+
+    # Formatted strings for display
+    display_process: str  # e.g., "128MB"
+    display_system: str  # e.g., "8.2GB/16GB"
+    display_percent: str  # e.g., "51%"
+
+    timestamp: datetime
+
+
+class MemoryCollector:
+    """
+    Memory collector for statusline display.
+
+    Features:
+    - Process memory monitoring (current Python process)
+    - System memory monitoring
+    - Caching with configurable TTL
+    - Graceful degradation on errors
+    - Multiple display format options
+    """
+
+    # Cache configuration
+    DEFAULT_CACHE_TTL_SECONDS = 10  # Memory doesn't change rapidly
+
+    def __init__(self, cache_ttl_seconds: Optional[int] = None):
+        """
+        Initialize memory collector.
+
+        Args:
+            cache_ttl_seconds: Cache TTL in seconds. If None, uses default.
+        """
+        self._cache_ttl = timedelta(seconds=cache_ttl_seconds or self.DEFAULT_CACHE_TTL_SECONDS)
+        self._cache: Optional[MemoryInfo] = None
+        self._cache_time: Optional[datetime] = None
+        self._logger = logging.getLogger(__name__)
+
+        # Check if psutil is available
+        self._psutil_available = self._check_psutil()
+
+    def _check_psutil(self) -> bool:
+        """Check if psutil is available."""
+        try:
+            import psutil  # noqa: F401
+
+            return True
+        except ImportError:
+            self._logger.warning("psutil not available, memory monitoring disabled")
+            return False
+
+    def get_memory_info(self, force_refresh: bool = False) -> Optional[MemoryInfo]:
+        """
+        Get memory usage information.
+
+        Args:
+            force_refresh: If True, bypass cache and force fresh collection
+
+        Returns:
+            MemoryInfo object or None if collection fails
+        """
+        if not self._psutil_available:
+            return None
+
+        # Check cache
+        if not force_refresh and self._is_cache_valid():
+            return self._cache
+
+        try:
+            memory_info = self._collect_memory_info()
+            self._update_cache(memory_info)
+            return memory_info
+        except Exception as e:
+            self._logger.error(f"Error collecting memory info: {e}")
+            return self._cache  # Return stale cache on error
+
+    def get_display_string(self, mode: str = "process", force_refresh: bool = False) -> str:
+        """
+        Get formatted memory string for statusline display.
+
+        Args:
+            mode: Display mode
+                - "process": Process memory (e.g., "128MB")
+                - "system": System memory usage (e.g., "8.2GB/16GB")
+                - "percent": System memory percentage (e.g., "51%")
+                - "compact": Process memory compact (e.g., "128M")
+            force_refresh: If True, bypass cache
+
+        Returns:
+            Formatted memory string, or "N/A" on error
+        """
+        memory_info = self.get_memory_info(force_refresh)
+
+        if memory_info is None:
+            return "N/A"
+
+        if mode == "process":
+            return memory_info.display_process
+        elif mode == "system":
+            return memory_info.display_system
+        elif mode == "percent":
+            return memory_info.display_percent
+        elif mode == "compact":
+            # Compact format without "MB" suffix
+            return self._format_compact(memory_info.process_rss_mb)
+        else:
+            return memory_info.display_process
+
+    def _collect_memory_info(self) -> MemoryInfo:
+        """
+        Collect memory information using psutil.
+
+        Returns:
+            MemoryInfo object with current memory usage
+        """
+        import psutil
+
+        # Get current process info
+        process = psutil.Process(os.getpid())
+        process_memory = process.memory_info()
+
+        # Convert to MB
+        process_rss_mb = process_memory.rss / (1024 * 1024)
+        process_vms_mb = process_memory.vms / (1024 * 1024)
+
+        # Get system memory info
+        system_memory = psutil.virtual_memory()
+        system_total_mb = system_memory.total / (1024 * 1024)
+        system_available_mb = system_memory.available / (1024 * 1024)
+        system_percent = system_memory.percent
+
+        # Format display strings
+        display_process = self._format_size(process_rss_mb)
+        display_system = (
+            f"{self._format_size(system_total_mb - system_available_mb)}/{self._format_size(system_total_mb)}"
+        )
+        display_percent = f"{system_percent:.0f}%"
+
+        return MemoryInfo(
+            process_rss_mb=process_rss_mb,
+            process_vms_mb=process_vms_mb,
+            system_total_mb=system_total_mb,
+            system_available_mb=system_available_mb,
+            system_percent=system_percent,
+            display_process=display_process,
+            display_system=display_system,
+            display_percent=display_percent,
+            timestamp=datetime.now(),
+        )
+
+    def _format_size(self, size_mb: float) -> str:
+        """
+        Format size in MB to human-readable string.
+
+        Args:
+            size_mb: Size in megabytes
+
+        Returns:
+            Formatted string (e.g., "128MB", "1.2GB")
+        """
+        if size_mb >= 1024:
+            return f"{size_mb / 1024:.1f}GB"
+        elif size_mb >= 100:
+            return f"{size_mb:.0f}MB"
+        elif size_mb >= 10:
+            return f"{size_mb:.1f}MB"
+        else:
+            return f"{size_mb:.2f}MB"
+
+    def _format_compact(self, size_mb: float) -> str:
+        """
+        Format size in compact format for tight spaces.
+
+        Args:
+            size_mb: Size in megabytes
+
+        Returns:
+            Compact formatted string (e.g., "128M", "1.2G")
+        """
+        if size_mb >= 1024:
+            return f"{size_mb / 1024:.1f}G"
+        else:
+            return f"{size_mb:.0f}M"
+
+    def _is_cache_valid(self) -> bool:
+        """Check if cache is still valid."""
+        if self._cache is None or self._cache_time is None:
+            return False
+
+        age = datetime.now() - self._cache_time
+        return age < self._cache_ttl
+
+    def _update_cache(self, memory_info: MemoryInfo) -> None:
+        """Update cache with new memory info."""
+        self._cache = memory_info
+        self._cache_time = datetime.now()
+
+    def clear_cache(self) -> None:
+        """Clear the memory cache."""
+        self._cache = None
+        self._cache_time = None
+
+    def get_cache_age_seconds(self) -> Optional[float]:
+        """
+        Get cache age in seconds.
+
+        Returns:
+            Cache age in seconds, or None if no cache
+        """
+        if self._cache_time is None:
+            return None
+        return (datetime.now() - self._cache_time).total_seconds()
+
+
+# Singleton instance for convenience
+_default_collector: Optional[MemoryCollector] = None
+
+
+def get_memory_collector() -> MemoryCollector:
+    """
+    Get the default memory collector instance.
+
+    Returns:
+        MemoryCollector singleton instance
+    """
+    global _default_collector
+    if _default_collector is None:
+        _default_collector = MemoryCollector()
+    return _default_collector
+
+
+def get_memory_display(mode: str = "process") -> str:
+    """
+    Convenience function to get memory display string.
+
+    Args:
+        mode: Display mode ("process", "system", "percent", "compact")
+
+    Returns:
+        Formatted memory string
+    """
+    return get_memory_collector().get_display_string(mode)

moai_adk/statusline/renderer.py

@@ -4,6 +4,7 @@ Statusline renderer for Claude Code status display
 """
 
 # type: ignore
+# -*- coding: utf-8 -*-
 
 from dataclasses import dataclass
 from typing import List
@@ -67,7 +68,7 @@ class StatuslineRenderer:
 
     def _render_compact(self, data: StatuslineData) -> str:
         """
-        Render compact mode: 🤖 Model | 🔅 Version | 💰 Context | 💬 Style | 📊 Changes | 🔀 Branch
+        Render compact mode: 🤖 Model | 💰 Context | 💬 Style | 📁 Directory | 📊 Changes | 💾 Memory | 🔀 Branch
         Constraint: <= 80 characters
 
         Args:
@@ -91,7 +92,7 @@ class StatuslineRenderer:
     def _build_compact_parts(self, data: StatuslineData) -> List[str]:
         """
         Build parts list for compact mode with labeled sections
-        Format: 🤖 Model | 🔅 Version | 💰 Context | 💬 Style | 📊 Changes | 🔀 Branch
+        Format: 🤖 Model | 💰 Context | 💬 Style | 📁 Directory | 📊 Changes | 💾 Memory | 🔀 Branch
 
         Args:
             data: StatuslineData instance
@@ -101,32 +102,35 @@ class StatuslineRenderer:
         """
         parts = []
 
-        # Add model if display enabled (most important - cloud service context)
+        # 1. Add model first (cloud service context)
         if self._display_config.model:
             parts.append(f"🤖 {data.model}")
 
-        # Add Claude Code version if available
-        if data.claude_version:
-            claude_ver_str = data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
-            parts.append(f"🔅 {claude_ver_str}")
-
-        # Add context window usage if available (💰 icon)
+        # 2. Add context window usage if available
         if data.context_window:
             parts.append(f"💰 {data.context_window}")
 
-        # Add output style if not empty
+        # 3. Add output style if not empty
         if data.output_style:
             parts.append(f"💬 {data.output_style}")
 
-        # Add git status if display enabled and status not empty
+        # 4. Add directory (project context)
+        if self._display_config.directory and data.directory:
+            parts.append(f"📁 {data.directory}")
+
+        # 5. Add git status if display enabled and status not empty
         if self._display_config.git_status and data.git_status:
             parts.append(f"📊 {data.git_status}")
 
-        # Add Git info (development context)
+        # 6. Add memory usage if display enabled
+        if self._display_config.memory_usage and data.memory_usage:
+            parts.append(f"💾 {data.memory_usage}")
+
+        # 7. Add Git branch (development context)
         if self._display_config.branch:
             parts.append(f"🔀 {data.branch}")
 
-        # Add active_task if display enabled and not empty
+        # 8. Add active_task if display enabled and not empty
         if self._display_config.active_task and data.active_task.strip():
             parts.append(data.active_task)
 
@@ -135,7 +139,7 @@ class StatuslineRenderer:
     def _fit_to_constraint(self, data: StatuslineData, max_length: int) -> str:
         """
         Fit statusline to character constraint by truncating
-        Format: 🤖 Model | 🔅 Version | 💰 Context | 💬 Style | 📊 Changes | 🔀 Branch
+        Format: 🤖 Model | 💰 Context | 💬 Style | 📁 Directory | 📊 Changes | 💾 Memory | 🔀 Branch
 
         Args:
             data: StatuslineData instance
@@ -146,12 +150,10 @@ class StatuslineRenderer:
         """
         truncated_branch = self._truncate_branch(data.branch, max_length=30)
 
-        # Build parts list
-        parts = [f"🤖 {data.model}"]
+        # Build parts list in new order
+        parts = []
 
-        if data.claude_version:
-            claude_ver_str = data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
-            parts.append(f"🔅 {claude_ver_str}")
+        parts.append(f"🤖 {data.model}")
 
         if data.context_window:
             parts.append(f"💰 {data.context_window}")
@@ -159,9 +161,15 @@ class StatuslineRenderer:
         if data.output_style:
             parts.append(f"💬 {data.output_style}")
 
+        if self._display_config.directory and data.directory:
+            parts.append(f"📁 {data.directory}")
+
         if self._display_config.git_status and data.git_status:
             parts.append(f"📊 {data.git_status}")
 
+        if self._display_config.memory_usage and data.memory_usage:
+            parts.append(f"💾 {data.memory_usage}")
+
         parts.append(f"🔀 {truncated_branch}")
 
         if data.active_task.strip():
@@ -172,23 +180,22 @@ class StatuslineRenderer:
         # If still too long, try more aggressive branch truncation
         if len(result) > max_length:
             truncated_branch = self._truncate_branch(data.branch, max_length=12)
-            parts = [f"🤖 {data.model}"]
-
-            if data.claude_version:
-                claude_ver_str = (
-                    data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
-                )
-                parts.append(f"🔅 {claude_ver_str}")
+            parts = []
+            parts.append(f"🤖 {data.model}")
             if data.context_window:
                 parts.append(f"💰 {data.context_window}")
             if data.output_style:
                 parts.append(f"💬 {data.output_style}")
+            if self._display_config.directory and data.directory:
+                parts.append(f"📁 {data.directory}")
             if data.git_status:
                 parts.append(f"📊 {data.git_status}")
+            if self._display_config.memory_usage and data.memory_usage:
+                parts.append(f"💾 {data.memory_usage}")
             parts.append(f"🔀 {truncated_branch}")
             result = self._format_config.separator.join(parts)
 
-        # If still too long, remove output_style
+        # If still too long, remove output_style and memory_usage
         if len(result) > max_length:
             parts = [f"🤖 {data.model}"]
             if data.context_window:
@@ -208,7 +215,7 @@ class StatuslineRenderer:
         """
         Render extended mode: Full path and detailed info with labels
         Constraint: <= 120 characters
-        Format: 🤖 Model | 🔅 Version | 💰 Context | 💬 Style | 📊 Changes | 🔀 Branch
+        Format: 🤖 Model | 💰 Context | 💬 Style | 📁 Directory | 📊 Changes | 💾 Memory | 🔀 Branch
 
         Args:
             data: StatuslineData instance
@@ -218,28 +225,38 @@ class StatuslineRenderer:
         """
         branch = self._truncate_branch(data.branch, max_length=30)
 
-        # Build parts list
+        # Build parts list in new order
         parts = []
 
+        # 1. Model first
         if self._display_config.model:
             parts.append(f"🤖 {data.model}")
 
-        if data.claude_version:
-            claude_ver_str = data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
-            parts.append(f"🔅 {claude_ver_str}")
-
+        # 2. Context window
         if data.context_window:
             parts.append(f"💰 {data.context_window}")
 
+        # 3. Output style
         if data.output_style:
             parts.append(f"💬 {data.output_style}")
 
+        # 4. Directory
+        if self._display_config.directory and data.directory:
+            parts.append(f"📁 {data.directory}")
+
+        # 5. Git status
         if self._display_config.git_status and data.git_status:
             parts.append(f"📊 {data.git_status}")
 
+        # 6. Memory usage
+        if self._display_config.memory_usage and data.memory_usage:
+            parts.append(f"💾 {data.memory_usage}")
+
+        # 7. Git branch
         if self._display_config.branch:
             parts.append(f"🔀 {branch}")
 
+        # 8. Active task
         if self._display_config.active_task and data.active_task.strip():
             parts.append(data.active_task)
 
@@ -251,17 +268,16 @@ class StatuslineRenderer:
             parts = []
             if self._display_config.model:
                 parts.append(f"🤖 {data.model}")
-            if data.claude_version:
-                claude_ver_str = (
-                    data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
-                )
-                parts.append(f"🔅 {claude_ver_str}")
             if data.context_window:
                 parts.append(f"💰 {data.context_window}")
             if data.output_style:
                 parts.append(f"💬 {data.output_style}")
+            if self._display_config.directory and data.directory:
+                parts.append(f"📁 {data.directory}")
             if data.git_status:
                 parts.append(f"📊 {data.git_status}")
+            if self._display_config.memory_usage and data.memory_usage:
+                parts.append(f"💾 {data.memory_usage}")
             parts.append(f"🔀 {branch}")
             result = self._format_config.separator.join(parts)
 

moai_adk/tag_system/__init__.py

@@ -0,0 +1,48 @@
+"""TAG System v2.0 for MoAI-ADK.
+
+Provides TAG annotation, validation, parsing, and linkage management
+for SPEC-First TDD workflow.
+"""
+
+from .linkage import (
+    LinkageManager,
+    spec_document_exists,
+)
+from .parser import (
+    extract_tags_from_directory,
+    extract_tags_from_file,
+    extract_tags_from_files,
+    extract_tags_from_source,
+)
+from .validator import (
+    DEFAULT_VERB,
+    TAG,
+    VALID_VERBS,
+    get_default_verb,
+    parse_tag_string,
+    validate_spec_id_format,
+    validate_tag,
+    validate_verb,
+)
+
+__all__ = [
+    # Validator
+    "TAG",
+    "VALID_VERBS",
+    "DEFAULT_VERB",
+    "validate_spec_id_format",
+    "validate_verb",
+    "get_default_verb",
+    "validate_tag",
+    "parse_tag_string",
+    # Parser
+    "extract_tags_from_source",
+    "extract_tags_from_file",
+    "extract_tags_from_files",
+    "extract_tags_from_directory",
+    # Linkage
+    "LinkageManager",
+    "spec_document_exists",
+]
+
+__version__ = "2.0.0"