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

moai_adk/templates/.claude/hooks/moai/lib/renderer.py

@@ -0,0 +1,359 @@
+"""
+Statusline renderer for Claude Code status display
+
+"""
+
+# type: ignore
+# -*- coding: utf-8 -*-
+
+from dataclasses import dataclass
+from typing import List
+
+from .config import StatuslineConfig  # type: ignore[attr-defined]
+
+
+@dataclass
+class StatuslineData:
+    """Status line data structure containing all necessary information"""
+
+    model: str
+    version: str
+    memory_usage: str
+    branch: str
+    git_status: str
+    duration: str
+    directory: str
+    active_task: str
+    claude_version: str = ""  # Claude Code version (e.g., "2.0.46")
+    output_style: str = ""  # Output style name (e.g., "R2-D2", "Yoda")
+    update_available: bool = False
+    latest_version: str = ""
+    context_window: str = ""  # Context window usage (e.g., "15K/200K")
+
+
+class StatuslineRenderer:
+    """Renders status information in various modes (compact, extended, minimal)"""
+
+    # Constraints for each mode
+    _MODE_CONSTRAINTS = {
+        "compact": 80,
+        "extended": 120,
+        "minimal": 40,
+    }
+
+    def __init__(self):
+        """Initialize renderer with configuration"""
+        self._config = StatuslineConfig()
+        self._format_config = self._config.get_format_config()
+        self._display_config = self._config.get_display_config()
+
+    def render(self, data: StatuslineData, mode: str = "compact") -> str:
+        """
+        Render statusline with given data in specified mode
+
+        Args:
+            data: StatuslineData instance with all required fields
+            mode: Display mode - "compact" (80 chars), "extended" (120 chars), "minimal" (40 chars)
+
+        Returns:
+            Formatted statusline string
+        """
+        render_method = {
+            "compact": self._render_compact,
+            "extended": self._render_extended,
+            "minimal": self._render_minimal,
+        }.get(mode, self._render_compact)
+
+        return render_method(data)
+
+    def _render_compact(self, data: StatuslineData) -> str:
+        """
+        Render compact mode: 🤖 Model | 💰 Context | 💬 Style | 📁 Directory | 📊 Changes | 💾 Memory | 🔀 Branch
+        Constraint: <= 80 characters
+
+        Args:
+            data: StatuslineData instance
+
+        Returns:
+            Formatted statusline string (max 80 chars)
+        """
+        max_length = self._MODE_CONSTRAINTS["compact"]
+        parts = self._build_compact_parts(data)
+
+        # Join all parts with separator (no brackets)
+        result = self._format_config.separator.join(parts)
+
+        # Adjust if too long
+        if len(result) > max_length:
+            result = self._fit_to_constraint(data, max_length)
+
+        return result
+
+    def _build_compact_parts(self, data: StatuslineData) -> List[str]:
+        """
+        Build parts list for compact mode with labeled sections
+        Format: 🤖 Model | 💰 Context | 💬 Style | 📁 Directory | 📊 Changes | 💾 Memory | 🔀 Branch
+
+        Args:
+            data: StatuslineData instance
+
+        Returns:
+            List of parts to be joined
+        """
+        parts = []
+
+        # 1. Add model first (cloud service context)
+        if self._display_config.model:
+            parts.append(f"🤖 {data.model}")
+
+        # 2. Add context window usage if available
+        if data.context_window:
+            parts.append(f"💰 {data.context_window}")
+
+        # 3. Add output style if not empty
+        if data.output_style:
+            parts.append(f"💬 {data.output_style}")
+
+        # 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}")
+
+        # 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}")
+
+        # 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)
+
+        return parts
+
+    def _fit_to_constraint(self, data: StatuslineData, max_length: int) -> str:
+        """
+        Fit statusline to character constraint by truncating
+        Format: 🤖 Model | 💰 Context | 💬 Style | 📁 Directory | 📊 Changes | 💾 Memory | 🔀 Branch
+
+        Args:
+            data: StatuslineData instance
+            max_length: Maximum allowed length
+
+        Returns:
+            Truncated statusline string
+        """
+        truncated_branch = self._truncate_branch(data.branch, max_length=30)
+
+        # Build parts list in new order
+        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 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():
+            parts.append(data.active_task)
+
+        result = self._format_config.separator.join(parts)
+
+        # 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 = []
+            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 and memory_usage
+        if len(result) > max_length:
+            parts = [f"🤖 {data.model}"]
+            if data.context_window:
+                parts.append(f"💰 {data.context_window}")
+            if data.git_status:
+                parts.append(f"📊 {data.git_status}")
+            parts.append(f"🔀 {truncated_branch}")
+            result = self._format_config.separator.join(parts)
+
+        # Final fallback to minimal if still too long
+        if len(result) > max_length:
+            result = self._render_minimal(data)
+
+        return result
+
+    def _render_extended(self, data: StatuslineData) -> str:
+        """
+        Render extended mode: Full path and detailed info with labels
+        Constraint: <= 120 characters
+        Format: 🤖 Model | 💰 Context | 💬 Style | 📁 Directory | 📊 Changes | 💾 Memory | 🔀 Branch
+
+        Args:
+            data: StatuslineData instance
+
+        Returns:
+            Formatted statusline string (max 120 chars)
+        """
+        branch = self._truncate_branch(data.branch, max_length=30)
+
+        # Build parts list in new order
+        parts = []
+
+        # 1. Model first
+        if self._display_config.model:
+            parts.append(f"🤖 {data.model}")
+
+        # 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)
+
+        result = self._format_config.separator.join(parts)
+
+        # If exceeds limit, try truncating
+        if len(result) > 120:
+            branch = self._truncate_branch(data.branch, max_length=20)
+            parts = []
+            if self._display_config.model:
+                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"🔀 {branch}")
+            result = self._format_config.separator.join(parts)
+
+        return result
+
+    def _render_minimal(self, data: StatuslineData) -> str:
+        """
+        Render minimal mode: Extreme space constraint with minimal labels
+        Constraint: <= 40 characters
+        Format: 🤖 Model | 💰 Context
+
+        Args:
+            data: StatuslineData instance
+
+        Returns:
+            Formatted statusline string (max 40 chars)
+        """
+        parts = []
+
+        # Add model if display enabled
+        if self._display_config.model:
+            parts.append(f"🤖 {data.model}")
+
+        # Add context window usage if available (💰 icon)
+        if data.context_window:
+            parts.append(f"💰 {data.context_window}")
+
+        result = self._format_config.separator.join(parts)
+
+        # Add git_status if it fits
+        if self._display_config.git_status and data.git_status:
+            status_label = f"📊 {data.git_status}"
+            if len(result) + len(status_label) + len(self._format_config.separator) <= 40:
+                result += f"{self._format_config.separator}{status_label}"
+
+        return result
+
+    @staticmethod
+    def _truncate_branch(branch: str, max_length: int = 30) -> str:
+        """
+        Truncate branch name intelligently, preserving SPEC ID if present
+
+        Args:
+            branch: Branch name to truncate
+            max_length: Maximum allowed length
+
+        Returns:
+            Truncated branch name
+        """
+        if len(branch) <= max_length:
+            return branch
+
+        # Try to preserve SPEC ID in feature branches
+        if "SPEC" in branch:
+            parts = branch.split("-")
+            for i, part in enumerate(parts):
+                if "SPEC" in part and i + 1 < len(parts):
+                    # Found SPEC ID, include it
+                    spec_truncated = "-".join(parts[: i + 2])
+                    if len(spec_truncated) <= max_length:
+                        return spec_truncated
+
+        # Simple truncation with ellipsis for very long names
+        return f"{branch[: max_length - 1]}…" if len(branch) > max_length else branch
+
+    @staticmethod
+    def _truncate_version(version: str) -> str:
+        """
+        Truncate version string for minimal display by removing 'v' prefix
+
+        Args:
+            version: Version string (e.g., "v0.20.1" or "0.20.1")
+
+        Returns:
+            Truncated version string
+        """
+        if version.startswith("v"):
+            return version[1:]
+        return version

moai_adk/templates/.claude/hooks/moai/lib/tag_linkage.py

@@ -0,0 +1,333 @@
+"""TAG linkage manager module for TAG System v2.0.
+
+Implements T4: Linkage Manager for bidirectional TAG↔CODE mapping
+with atomic database operations.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from . import tag_validator
+
+# Import atomic_write functions directly
+from .atomic_write import atomic_write_json, atomic_write_text
+
+logger = logging.getLogger(__name__)
+
+
+def spec_document_exists(spec_id: str) -> bool:
+    """Check if SPEC document exists in .moai/specs/.
+
+    Args:
+        spec_id: SPEC identifier to check
+
+    Returns:
+        True if SPEC document exists, False otherwise
+    """
+    # Get specs directory from current working directory
+    specs_dir = Path.cwd() / ".moai" / "specs"
+
+    if not specs_dir.exists():
+        return False
+
+    # Check for SPEC directory
+    spec_dir = specs_dir / spec_id
+    return spec_dir.exists() and spec_dir.is_dir()
+
+
+class LinkageManager:
+    """Manage bidirectional TAG↔CODE mapping database.
+
+    Provides atomic database operations for TAG tracking,
+    with support for TAG→Files and File→TAGs lookups.
+
+    Attributes:
+        db_path: Path to linkage database file
+    """
+
+    def __init__(self, db_path: Path) -> None:
+        """Initialize linkage manager.
+
+        Args:
+            db_path: Path to linkage database JSON file
+        """
+        self.db_path = Path(db_path)
+        self._ensure_database()
+
+    def _ensure_database(self) -> None:
+        """Ensure database file exists with proper structure."""
+        if not self.db_path.exists():
+            # Create new database with empty structure
+            self._write_database({"tags": [], "files": {}})
+
+    def _load_database(self) -> dict[str, Any]:
+        """Load database from disk.
+
+        Returns:
+            Database dictionary with 'tags' and 'files' keys
+        """
+        try:
+            if not self.db_path.exists():
+                return {"tags": [], "files": {}}
+
+            with open(self.db_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            # Validate structure
+            if not isinstance(data, dict):
+                logger.warning(f"Invalid database structure in {self.db_path}")
+                return {"tags": [], "files": {}}
+
+            if "tags" not in data:
+                data["tags"] = []
+            if "files" not in data:
+                data["files"] = {}
+
+            return data
+
+        except (json.JSONDecodeError, OSError) as e:
+            logger.error(f"Error loading database {self.db_path}: {e}")
+            return {"tags": [], "files": {}}
+
+    def _write_database(self, data: dict[str, Any]) -> bool:
+        """Write database to disk atomically.
+
+        Args:
+            data: Database dictionary to write
+
+        Returns:
+            True if write succeeded, False otherwise
+        """
+        return atomic_write_json(self.db_path, data)
+
+    def add_tag(self, tag: tag_validator.TAG) -> bool:
+        """Add TAG to linkage database.
+
+        Args:
+            tag: TAG object to add
+
+        Returns:
+            True if TAG added successfully, False otherwise
+
+        Examples:
+            >>> tag = TAG("SPEC-AUTH-001", Path("auth.py"), 10)
+            >>> manager.add_tag(tag)
+            True
+        """
+        try:
+            data = self._load_database()
+
+            # Create TAG entry
+            tag_entry = {
+                "spec_id": tag.spec_id,
+                "verb": tag.verb,
+                "file_path": str(tag.file_path),
+                "line": tag.line,
+            }
+
+            # Check for duplicate
+            if tag_entry not in data["tags"]:
+                data["tags"].append(tag_entry)
+
+            # Update file index
+            file_key = str(tag.file_path)
+            if file_key not in data["files"]:
+                data["files"][file_key] = []
+
+            if tag.spec_id not in data["files"][file_key]:
+                data["files"][file_key].append(tag.spec_id)
+
+            # Write database atomically
+            return self._write_database(data)
+
+        except Exception as e:
+            logger.error(f"Error adding TAG to database: {e}")
+            return False
+
+    def remove_tag(self, tag: tag_validator.TAG) -> bool:
+        """Remove specific TAG from database.
+
+        Args:
+            tag: TAG object to remove
+
+        Returns:
+            True if TAG removed successfully, False otherwise
+        """
+        try:
+            data = self._load_database()
+
+            tag_entry = {
+                "spec_id": tag.spec_id,
+                "verb": tag.verb,
+                "file_path": str(tag.file_path),
+                "line": tag.line,
+            }
+
+            # Remove from tags list
+            if tag_entry in data["tags"]:
+                data["tags"].remove(tag_entry)
+
+            # Update file index
+            file_key = str(tag.file_path)
+            if file_key in data["files"] and tag.spec_id in data["files"][file_key]:
+                data["files"][file_key].remove(tag.spec_id)
+
+                # Clean up empty file entries
+                if not data["files"][file_key]:
+                    del data["files"][file_key]
+
+            return self._write_database(data)
+
+        except Exception as e:
+            logger.error(f"Error removing TAG from database: {e}")
+            return False
+
+    def remove_file_tags(self, file_path: Path) -> bool:
+        """Remove all TAGs for a file.
+
+        Args:
+            file_path: Path to file whose TAGs should be removed
+
+        Returns:
+            True if TAGs removed successfully, False otherwise
+
+        Examples:
+            >>> manager.remove_file_tags(Path("deleted.py"))
+            True
+        """
+        try:
+            data = self._load_database()
+
+            file_key = str(file_path)
+
+            # Remove all TAGs for this file
+            data["tags"] = [tag for tag in data["tags"] if tag["file_path"] != file_key]
+
+            # Remove file index
+            if file_key in data["files"]:
+                del data["files"][file_key]
+
+            return self._write_database(data)
+
+        except Exception as e:
+            logger.error(f"Error removing file TAGs: {e}")
+            return False
+
+    def get_all_tags(self) -> list[dict[str, Any]]:
+        """Get all TAGs in database.
+
+        Returns:
+            List of TAG dictionaries
+        """
+        data = self._load_database()
+        return data.get("tags", [])
+
+    def get_code_locations(self, spec_id: str) -> list[dict[str, Any]]:
+        """Get all code locations for a SPEC-ID.
+
+        Args:
+            spec_id: SPEC identifier to query
+
+        Returns:
+            List of location dictionaries with file_path, line, and verb
+
+        Examples:
+            >>> locations = manager.get_code_locations("SPEC-AUTH-001")
+            >>> len(locations)
+            3
+        """
+        data = self._load_database()
+        tags = data.get("tags", [])
+
+        # Filter TAGs by spec_id
+        locations = [
+            {
+                "file_path": tag["file_path"],
+                "line": tag["line"],
+                "verb": tag["verb"],
+            }
+            for tag in tags
+            if tag["spec_id"] == spec_id
+        ]
+
+        return locations
+
+    def get_tags_by_file(self, file_path: Path) -> list[dict[str, Any]]:
+        """Get all TAGs for a specific file.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            List of TAG dictionaries for the file
+
+        Examples:
+            >>> tags = manager.get_tags_by_file(Path("auth.py"))
+            >>> len(tags)
+            2
+        """
+        data = self._load_database()
+        tags = data.get("tags", [])
+        file_key = str(file_path)
+
+        # Filter TAGs by file_path
+        return [
+            {
+                "spec_id": tag["spec_id"],
+                "verb": tag["verb"],
+                "file_path": tag["file_path"],
+                "line": tag["line"],
+            }
+            for tag in tags
+            if tag["file_path"] == file_key
+        ]
+
+    def get_all_spec_ids(self) -> list[str]:
+        """Get all unique SPEC-IDs in database.
+
+        Returns:
+            Sorted list of unique SPEC-ID strings
+        """
+        data = self._load_database()
+        tags = data.get("tags", [])
+
+        spec_ids = {tag["spec_id"] for tag in tags}
+        return sorted(spec_ids)
+
+    def find_orphaned_tags(self) -> list[dict[str, Any]]:
+        """Find TAGs referencing nonexistent SPEC documents.
+
+        Returns:
+            List of orphaned TAG dictionaries
+
+        Examples:
+            >>> orphans = manager.find_orphaned_tags()
+            >>> len(orphans)
+            1
+        """
+        data = self._load_database()
+        tags = data.get("tags", [])
+
+        orphans = [tag for tag in tags if not spec_document_exists(tag["spec_id"])]
+
+        return orphans
+
+    def clear(self) -> bool:
+        """Clear all TAGs from database.
+
+        Returns:
+            True if database cleared successfully, False otherwise
+        """
+        return self._write_database({"tags": [], "files": {}})
+
+
+__all__ = [
+    "spec_document_exists",
+    "LinkageManager",
+    "atomic_write_json",
+    "atomic_write_text",
+]