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

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

@@ -0,0 +1,190 @@
+# type: ignore
+"""
+Git information collector for statusline
+
+"""
+
+import logging
+import re
+import subprocess
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class GitInfo:
+    """Git repository information"""
+
+    branch: str
+    staged: int
+    modified: int
+    untracked: int
+
+
+class GitCollector:
+    """Collects git information from repository with 5-second caching"""
+
+    # Configuration constants
+    _CACHE_TTL_SECONDS = 5
+    _GIT_COMMAND_TIMEOUT = 2
+
+    # File status prefixes from git status --porcelain
+    _STATUS_ADDED = "A"
+    _STATUS_MODIFIED = "M"
+    _STATUS_UNTRACKED = "??"
+
+    def __init__(self):
+        """Initialize git collector with cache"""
+        self._cache: Optional[GitInfo] = None
+        self._cache_time: Optional[datetime] = None
+        self._cache_ttl = timedelta(seconds=self._CACHE_TTL_SECONDS)
+
+    def collect_git_info(self) -> GitInfo:
+        """
+        Collect git information from the repository
+
+        Returns:
+            GitInfo containing branch name and change counts
+        """
+        # Check cache validity first
+        if self._is_cache_valid():
+            return self._cache
+
+        # Run git command and parse output
+        git_info = self._fetch_git_info()
+        self._update_cache(git_info)
+        return git_info
+
+    def _fetch_git_info(self) -> GitInfo:
+        """
+        Fetch git information from command
+
+        Returns:
+            GitInfo from command or error defaults
+        """
+        try:
+            result = subprocess.run(
+                ["git", "status", "-b", "--porcelain"],
+                capture_output=True,
+                text=True,
+                timeout=self._GIT_COMMAND_TIMEOUT,
+            )
+
+            if result.returncode != 0:
+                logger.debug(f"Git command failed: {result.stderr}")
+                return self._create_error_info()
+
+            return self._parse_git_output(result.stdout)
+
+        except subprocess.TimeoutExpired:
+            logger.warning("Git command timed out")
+            return self._create_error_info()
+        except Exception as e:
+            logger.debug(f"Error collecting git info: {e}")
+            return self._create_error_info()
+
+    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
+        return datetime.now() - self._cache_time < self._cache_ttl
+
+    def _update_cache(self, git_info: GitInfo) -> None:
+        """Update cache with new git info"""
+        self._cache = git_info
+        self._cache_time = datetime.now()
+
+    def _parse_git_output(self, output: str) -> GitInfo:
+        """
+        Parse git status output into GitInfo
+
+        Args:
+            output: Output from 'git status -b --porcelain'
+
+        Returns:
+            GitInfo with parsed data
+        """
+        lines = output.strip().split("\n")
+
+        # Extract branch name from first line (## branch_name...)
+        branch = self._extract_branch(lines[0] if lines else "")
+
+        # Count file changes from remaining lines
+        staged, modified, untracked = self._count_changes(lines[1:])
+
+        return GitInfo(
+            branch=branch,
+            staged=staged,
+            modified=modified,
+            untracked=untracked,
+        )
+
+    def _count_changes(self, lines: list) -> tuple[int, int, int]:
+        """
+        Count staged, modified, and untracked files
+
+        Args:
+            lines: Lines from git status output (excluding header)
+
+        Returns:
+            Tuple of (staged_count, modified_count, untracked_count)
+        """
+        staged = 0
+        modified = 0
+        untracked = 0
+
+        for line in lines:
+            if not line or len(line) < 2:
+                continue
+
+            status = line[:2]
+
+            # Check staged changes (first character)
+            if status[0] == self._STATUS_ADDED:
+                staged += 1
+            elif status[0] == self._STATUS_MODIFIED:
+                staged += 1
+
+            # Check unstaged/working directory changes (second character)
+            # Detects: M(modified), D(deleted), A(added), R(renamed), C(copied), T(type changed)
+            if len(status) > 1 and status[1] not in (" ", "."):
+                modified += 1
+
+            # Check untracked files
+            if status == self._STATUS_UNTRACKED:
+                untracked += 1
+
+        return staged, modified, untracked
+
+    @staticmethod
+    def _extract_branch(branch_line: str) -> str:
+        """
+        Extract branch name from git status -b output
+
+        Format: ## branch_name...origin/branch_name
+
+        Args:
+            branch_line: First line from git status -b
+
+        Returns:
+            Branch name or "unknown" if parsing fails
+        """
+        if not branch_line.startswith("##"):
+            return "unknown"
+
+        # Use regex to extract branch name before first dot
+        match = re.match(r"##\s+([^\s\.]+)", branch_line)
+        return match.group(1) if match else "unknown"
+
+    @staticmethod
+    def _create_error_info() -> GitInfo:
+        """Create error info with default values for graceful degradation"""
+        return GitInfo(
+            branch="unknown",
+            staged=0,
+            modified=0,
+            untracked=0,
+        )

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

@@ -13,6 +13,8 @@ Features:
 - Cross-platform compatibility
 """
 
+from __future__ import annotations
+
 import hashlib
 import logging
 import subprocess
@@ -25,7 +27,7 @@ from datetime import datetime, timedelta
 from enum import Enum
 from pathlib import Path
 from queue import Empty, Queue
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional
 
 
 class GitOperationType(Enum):
@@ -45,7 +47,7 @@ class GitCommand:
     """Git command specification"""
 
     operation_type: GitOperationType
-    args: List[str]
+    args: list[str]
     cache_ttl_seconds: int = 60
     retry_count: int = 2
     timeout_seconds: int = 10
@@ -62,8 +64,8 @@ class GitResult:
     execution_time: float = 0.0
     cached: bool = False
     cache_hit: bool = False
-    operation_type: Optional[GitOperationType] = None
-    command: List[str] = field(default_factory=list)
+    operation_type: GitOperationType | None = None
+    command: list[str] = field(default_factory=list)
 
 
 @dataclass
@@ -82,7 +84,7 @@ class GitOperationError(Exception):
     def __init__(
         self,
         message: str,
-        command: List[str] = None,
+        command: list[str] = None,
         return_code: int = -1,
         stderr: str = "",
         execution_time: float = 0.0,
@@ -113,7 +115,7 @@ class GitOperationsManager:
         self._semaphore = threading.Semaphore(max_workers)  # Limit concurrent Git operations
 
         # Cache management
-        self._cache: Dict[str, CacheEntry] = {}
+        self._cache: dict[str, CacheEntry] = {}
         self._cache_lock = threading.RLock()
         self._cache_size_limit = cache_size_limit
 
@@ -129,7 +131,7 @@ class GitOperationsManager:
 
         # Git command queue for sequential operations when needed
         self._command_queue: "Queue[Any]" = Queue()
-        self._queue_processor_thread: Optional[threading.Thread] = None
+        self._queue_processor_thread: threading.Thread | None = None
         self._queue_active = True
 
         # Start queue processor thread
@@ -163,7 +165,7 @@ class GitOperationsManager:
         self._queue_processor_thread = threading.Thread(target=process_queue, daemon=True)
         self._queue_processor_thread.start()
 
-    def _generate_cache_key(self, operation_type: GitOperationType, args: List[str]) -> str:
+    def _generate_cache_key(self, operation_type: GitOperationType, args: list[str]) -> str:
         """Generate cache key for Git operation"""
         # Include current working directory and branch for context-aware caching
         try:
@@ -320,7 +322,7 @@ class GitOperationsManager:
                 command=full_command.copy(),
             )
 
-    def execute_git_command(self, command: Union[GitCommand, str], *args) -> GitResult:
+    def execute_git_command(self, command: GitCommand | str, *args: str) -> GitResult:
         """Execute Git command with caching and retry logic"""
         # Convert string command to GitCommand
         if isinstance(command, str):
@@ -374,7 +376,7 @@ class GitOperationsManager:
 
         return last_result or GitResult(success=False, stderr="Unknown error")
 
-    def execute_parallel(self, commands: List[GitCommand]) -> List[GitResult]:
+    def execute_parallel(self, commands: list[GitCommand]) -> List[GitResult]:
         """Execute multiple Git commands in parallel with controlled concurrency"""
         futures = []
         results = []
@@ -466,7 +468,7 @@ class GitOperationsManager:
     def queue_command(
         self,
         command: GitCommand,
-        callback: Optional[Callable[[GitResult], None]] = None,
+        callback: Callable[[GitResult], None] | None = None,
     ) -> None:
         """Queue a Git command for background execution"""
         try:
@@ -504,7 +506,7 @@ class GitOperationsManager:
                 "queue": {"pending": self._command_queue.qsize()},
             }
 
-    def clear_cache(self, operation_type: Optional[GitOperationType] = None) -> int:
+    def clear_cache(self, operation_type: GitOperationType | None = None) -> int:
         """Clear cache entries, optionally filtered by operation type"""
         with self._cache_lock:
             if operation_type is None:
@@ -575,7 +577,7 @@ def get_git_info(use_cache: bool = True) -> Dict[str, Any]:
 
 def run_git_command(
     operation_type: GitOperationType,
-    args: List[str],
+    args: list[str],
     cache_ttl: int = 60,
     timeout: int = 10,
 ) -> GitResult:

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

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""Language Detection Library for Multi-Language Support.
+
+Detects programming language from file path and project configuration.
+Supports Python, TypeScript, JavaScript, Go, Rust, Java, Kotlin, Ruby, PHP, C/C++.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+# Language configuration with test file patterns
+LANGUAGE_CONFIGS: dict[str, dict] = {
+    "Python": {
+        "extensions": [".py", ".pyi"],
+        "indicators": ["pyproject.toml", "requirements.txt", "setup.py", "setup.cfg", "poetry.lock"],
+        "test_frameworks": ["pytest", "unittest"],
+        "coverage_tools": ["coverage.py", "pytest-cov"],
+        "test_patterns": ["tests/test_*.py", "test_*.py"],
+        "source_patterns": ["*.py", "src/**/*.py"],
+        "test_command": "uv run pytest -q tests/",
+        "coverage_command": "uv run coverage run --branch -m pytest -q tests/ && uv run coverage report --format=json",
+    },
+    "TypeScript": {
+        "extensions": [".ts", ".tsx"],
+        "indicators": ["package.json", "tsconfig.json"],
+        "test_frameworks": ["jest", "vitest", "mocha"],
+        "coverage_tools": ["c8", "istanbul", "vitest"],
+        "test_patterns": ["**/*.test.ts", "**/*.spec.ts", "**/*.test.tsx"],
+        "source_patterns": ["*.ts", "*.tsx", "src/**/*.ts"],
+        "test_command": "npm test -- --run",
+        "coverage_command": "npm run test:coverage -- --reporter=json",
+    },
+    "JavaScript": {
+        "extensions": [".js", ".jsx"],
+        "indicators": ["package.json"],
+        "test_frameworks": ["jest", "vitest", "mocha"],
+        "coverage_tools": ["c8", "istanbul", "nyc"],
+        "test_patterns": ["**/*.test.js", "**/*.spec.js"],
+        "source_patterns": ["*.js", "*.jsx", "src/**/*.js"],
+        "test_command": "npm test -- --run",
+        "coverage_command": "npm run test:coverage -- --coverageReporters=json",
+    },
+    "Go": {
+        "extensions": [".go"],
+        "indicators": ["go.mod", "go.sum"],
+        "test_frameworks": ["testing", "testify"],
+        "coverage_tools": ["go test -cover"],
+        "test_patterns": ["*_test.go"],
+        "source_patterns": ["*.go", "cmd/**/*.go", "pkg/**/*.go"],
+        "test_command": "go test ./...",
+        "coverage_command": "go test -coverprofile=coverage.out ./... && go tool cover -func=coverage.out",
+    },
+    "Rust": {
+        "extensions": [".rs"],
+        "indicators": ["Cargo.toml", "Cargo.lock"],
+        "test_frameworks": ["cargo test"],
+        "coverage_tools": ["tarpaulin", "cargo-llvm-cov"],
+        "test_patterns": ["**/*_test.rs", "tests/**/*.rs"],
+        "source_patterns": ["*.rs", "src/**/*.rs"],
+        "test_command": "cargo test",
+        "coverage_command": "cargo tarpaulin --out Json -- --test-threads=1",
+    },
+    "Java": {
+        "extensions": [".java"],
+        "indicators": ["pom.xml", "build.gradle", "build.gradle.kts", "gradle.properties"],
+        "test_frameworks": ["JUnit"],
+        "coverage_tools": ["JaCoCo"],
+        "test_patterns": ["**/*Test.java", "src/test/**/*.java"],
+        "source_patterns": ["*.java", "src/main/**/*.java"],
+        "test_command": "mvn test",
+        "coverage_command": "mvn jacoco:report",
+    },
+    "Kotlin": {
+        "extensions": [".kt", ".kts"],
+        "indicators": ["build.gradle.kts", "pom.xml", "gradle.properties"],
+        "test_frameworks": ["JUnit", "Kotest"],
+        "coverage_tools": ["JaCoCo", "Kover"],
+        "test_patterns": ["**/*Test.kt", "src/test/**/*.kt"],
+        "source_patterns": ["*.kt", "src/main/**/*.kt"],
+        "test_command": "gradle test",
+        "coverage_command": "gradle jacocoTestReport",
+    },
+    "Ruby": {
+        "extensions": [".rb"],
+        "indicators": ["Gemfile", "Rakefile"],
+        "test_frameworks": ["RSpec", "Minitest"],
+        "coverage_tools": ["SimpleCov"],
+        "test_patterns": ["**/*_spec.rb", "test/**/*.rb"],
+        "source_patterns": ["*.rb", "lib/**/*.rb"],
+        "test_command": "bundle exec rspec",
+        "coverage_command": "COVERAGE=true bundle exec rspec",
+    },
+    "PHP": {
+        "extensions": [".php"],
+        "indicators": ["composer.json"],
+        "test_frameworks": ["Pest", "PHPUnit"],
+        "coverage_tools": ["phpunit coverage", "pest coverage"],
+        "test_patterns": ["**/*Test.php", "tests/**/*.php"],
+        "source_patterns": ["*.php", "src/**/*.php"],
+        "test_command": "vendor/bin/pest",
+        "coverage_command": "vendor/bin/pest --coverage",
+    },
+    "C": {
+        "extensions": [".c", ".cpp", ".cc", ".h", ".hpp"],
+        "indicators": ["CMakeLists.txt", "Makefile", "configure.ac"],
+        "test_frameworks": ["googletest", "Catch2"],
+        "coverage_tools": ["gcov", "lcov"],
+        "test_patterns": ["**/*_test.cc", "**/*_test.c", "tests/**/*.c"],
+        "source_patterns": ["*.c", "*.cpp", "*.cc", "*.h", "*.hpp", "src/**/*.c"],
+        "test_command": "make test",
+        "coverage_command": "make coverage",
+    },
+}
+
+
+def detect_language(file_path: Path) -> str | None:
+    """Detect programming language from file path and project context.
+
+    Args:
+        file_path: Path to the source file
+
+    Returns:
+        Language name or None if unknown
+    """
+    # First try: File extension
+    ext = file_path.suffix.lower()
+
+    for language, config in LANGUAGE_CONFIGS.items():
+        if ext in config["extensions"]:
+            return language
+
+    # Second try: Project indicators
+    project_root = _find_project_root(file_path)
+    if project_root:
+        for language, config in LANGUAGE_CONFIGS.items():
+            for indicator in config["indicators"]:
+                if (project_root / indicator).exists():
+                    # Verify extension matches
+                    if ext in config.get("extensions", []):
+                        return language
+
+    return None
+
+
+def _find_project_root(file_path: Path) -> Path | None:
+    """Find project root directory by looking for indicator files.
+
+    Args:
+        file_path: Starting file path
+
+    Returns:
+        Path to project root or None
+    """
+    current = file_path.parent if file_path.is_file() else file_path
+
+    # Common project root indicators
+    root_indicators = [
+        "pyproject.toml",
+        "package.json",
+        "go.mod",
+        "Cargo.toml",
+        "pom.xml",
+        "build.gradle",
+        "Gemfile",
+        "composer.json",
+        "CMakeLists.txt",
+        ".git",
+    ]
+
+    # Search up the directory tree
+    max_depth = 5
+    depth = 0
+
+    while depth < max_depth and current != current.parent:
+        for indicator in root_indicators:
+            if (current / indicator).exists():
+                return current
+
+        current = current.parent
+        depth += 1
+
+    return None
+
+
+def get_test_file_path(source_file: Path) -> Path | None:
+    """Determine the expected test file path for a source file.
+
+    Args:
+        source_file: Path to the source file
+
+    Returns:
+        Expected test file path or None
+    """
+    language = detect_language(source_file)
+    if not language:
+        return None
+
+    stem = source_file.stem
+
+    # Language-specific test file conventions
+    if language == "Python":
+        # module.py → tests/test_module.py
+        # src/module.py → tests/test_module.py
+        return Path("tests") / f"test_{stem}.py"
+
+    elif language in ("TypeScript", "JavaScript"):
+        # module.ts → module.test.ts
+        return source_file.parent / f"{stem}.test{source_file.suffix}"
+
+    elif language == "Go":
+        # module.go → module_test.go (same directory)
+        return source_file.parent / f"{stem}_test.go"
+
+    elif language == "Rust":
+        # module.rs → module_test.rs (same directory for unit tests)
+        # or tests/module_test.rs (integration tests)
+        return source_file.parent / f"{stem}_test.rs"
+
+    elif language == "Java":
+        # Module.java → ModuleTest.java
+        # Usually in src/test/java/.../ModuleTest.java
+        return source_file.parent / f"{stem}Test.java"
+
+    elif language == "Kotlin":
+        # Module.kt → ModuleTest.kt
+        return source_file.parent / f"{stem}Test.kt"
+
+    elif language == "Ruby":
+        # module.rb → module_spec.rb
+        return source_file.parent / f"{stem}_spec.rb"
+
+    elif language == "PHP":
+        # Module.php → ModuleTest.php
+        return source_file.parent / f"{stem}Test.php"
+
+    elif language == "C":
+        # module.cc → module_test.cc
+        return source_file.parent / f"{stem}_test.cc"
+
+    return None
+
+
+def get_test_command(language: str) -> str | None:
+    """Get test command for a language.
+
+    Args:
+        language: Programming language name
+
+    Returns:
+        Test command string or None
+    """
+    config = LANGUAGE_CONFIGS.get(language, {})
+    return config.get("test_command")
+
+
+def get_coverage_command(language: str) -> str | None:
+    """Get coverage command for a language.
+
+    Args:
+        language: Programming language name
+
+    Returns:
+        Coverage command string or None
+    """
+    config = LANGUAGE_CONFIGS.get(language, {})
+    return config.get("coverage_command")
+
+
+def get_coverage_target() -> int:
+    """Get target coverage percentage from quality.yaml.
+
+    Returns:
+        Target coverage percentage (default: 100)
+    """
+    # Try to read from config
+    config_path = Path(".moai/config/sections/quality.yaml")
+    if config_path.exists():
+        import yaml
+
+        try:
+            with open(config_path) as f:
+                config = yaml.safe_load(f)
+                return config.get("constitution", {}).get("test_coverage_target", 100)
+        except Exception:
+            pass
+
+    return 100
+
+
+__all__ = [
+    "LANGUAGE_CONFIGS",
+    "detect_language",
+    "get_test_file_path",
+    "get_test_command",
+    "get_coverage_command",
+    "get_coverage_target",
+]