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

moai_adk/templates/.claude/hooks/alfred/core/project.py

@@ -1,416 +0,0 @@
-#!/usr/bin/env python3
-"""Project metadata utilities
-
-Project information inquiry (language, Git, SPEC progress, etc.)
-"""
-
-import json
-import signal
-import subprocess
-from contextlib import contextmanager
-from pathlib import Path
-from typing import Any
-
-
-class TimeoutError(Exception):
-    """Signal-based timeout exception"""
-    pass
-
-
-@contextmanager
-def timeout_handler(seconds: int):
-    """Hard timeout using SIGALRM (works on Unix systems including macOS)
-
-    This uses kernel-level signal to interrupt ANY blocking operation,
-    even if subprocess.run() timeout fails on macOS.
-
-    Args:
-        seconds: Timeout duration in seconds
-
-    Raises:
-        TimeoutError: If operation exceeds timeout
-    """
-    def _handle_timeout(signum, frame):
-        raise TimeoutError(f"Operation timed out after {seconds} seconds")
-
-    # Set the signal handler
-    old_handler = signal.signal(signal.SIGALRM, _handle_timeout)
-    signal.alarm(seconds)
-    try:
-        yield
-    finally:
-        signal.alarm(0)  # Disable alarm
-        signal.signal(signal.SIGALRM, old_handler)
-
-
-def detect_language(cwd: str) -> str:
-    """Detect project language (supports 20 items languages)
-
-    Browse the File system to detect your project's main development language.
-    First, check configuration files such as pyproject.toml and tsconfig.json.
-    Apply TypeScript first principles (if tsconfig.json exists).
-
-    Args:
-        cwd: Project root directory path (both absolute and relative paths are possible)
-
-    Returns:
-        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
-
-    Examples:
-        >>> detect_language("/path/to/python/project")
-        'python'
-        >>> detect_language("/path/to/typescript/project")
-        'typescript'
-        >>> detect_language("/path/to/unknown/project")
-        'Unknown Language'
-
-    TDD History:
-        - RED: Write a 21 items language detection test (20 items language + 1 items unknown)
-        - GREEN: 20 items language + unknown implementation, all tests passed
-        - REFACTOR: Optimize file inspection order, apply TypeScript priority principle
-    """
-    cwd_path = Path(cwd)
-
-    # Language detection mapping
-    language_files = {
-        "pyproject.toml": "python",
-        "tsconfig.json": "typescript",
-        "package.json": "javascript",
-        "pom.xml": "java",
-        "go.mod": "go",
-        "Cargo.toml": "rust",
-        "pubspec.yaml": "dart",
-        "Package.swift": "swift",
-        "build.gradle.kts": "kotlin",
-        "composer.json": "php",
-        "Gemfile": "ruby",
-        "mix.exs": "elixir",
-        "build.sbt": "scala",
-        "project.clj": "clojure",
-        "CMakeLists.txt": "cpp",
-        "Makefile": "c",
-    }
-
-    # Check standard language files
-    for file_name, language in language_files.items():
-        if (cwd_path / file_name).exists():
-            # Special handling for package.json - prefer typescript if tsconfig exists
-            if file_name == "package.json" and (cwd_path / "tsconfig.json").exists():
-                return "typescript"
-            return language
-
-    # Check for C# project files (*.csproj)
-    if any(cwd_path.glob("*.csproj")):
-        return "csharp"
-
-    # Check for Haskell project files (*.cabal)
-    if any(cwd_path.glob("*.cabal")):
-        return "haskell"
-
-    # Check for Shell scripts (*.sh)
-    if any(cwd_path.glob("*.sh")):
-        return "shell"
-
-    # Check for Lua files (*.lua)
-    if any(cwd_path.glob("*.lua")):
-        return "lua"
-
-    return "Unknown Language"
-
-
-def _run_git_command(args: list[str], cwd: str, timeout: int = 2) -> str:
-    """Git command execution with HARD timeout protection
-
-    Safely execute Git commands and return output.
-    Uses SIGALRM (kernel-level interrupt) to handle macOS subprocess timeout bug.
-    Eliminates code duplication and provides consistent error handling.
-
-    Args:
-        args: Git command argument list (git adds automatically)
-        cwd: Execution directory path
-        timeout: Timeout (seconds, default 2 seconds)
-
-    Returns:
-        Git command output (stdout, removing leading and trailing spaces)
-
-    Raises:
-        subprocess.TimeoutExpired: Timeout exceeded (via TimeoutError)
-        subprocess.CalledProcessError: Git command failed
-
-    Examples:
-        >>> _run_git_command(["branch", "--show-current"], ".")
-        'main'
-
-    TDD History:
-        - RED: Git command hang scenario test
-        - GREEN: SIGALRM-based timeout implementation
-        - REFACTOR: Exception conversion to subprocess.TimeoutExpired
-    """
-    try:
-        with timeout_handler(timeout):
-            result = subprocess.run(
-                ["git"] + args,
-                cwd=cwd,
-                capture_output=True,
-                text=True,
-                check=False,  # Don't raise on non-zero exit - we'll check manually
-            )
-
-            # Check exit code manually
-            if result.returncode != 0:
-                raise subprocess.CalledProcessError(
-                    result.returncode, ["git"] + args, result.stdout, result.stderr
-                )
-
-            return result.stdout.strip()
-
-    except TimeoutError:
-        # Convert to subprocess.TimeoutExpired for consistent error handling
-        raise subprocess.TimeoutExpired(["git"] + args, timeout)
-
-
-def get_git_info(cwd: str) -> dict[str, Any]:
-    """Gather Git repository information
-
-    View the current status of a Git repository.
-    Returns the branch name, commit hash, number of changes, and last commit message.
-    If it is not a Git repository, it returns an empty dictionary.
-
-    Args:
-        cwd: Project root directory path
-
-    Returns:
-        Git information dictionary. Includes the following keys:
-        - branch: Current branch name (str)
-        - commit: Current commit hash (str, full hash)
-        - changes: Number of changed files (int, staged + unstaged)
-        - last_commit: Last commit message (str, subject only)
-
-        Empty dictionary {} if it is not a Git repository or the query fails.
-
-    Examples:
-        >>> get_git_info("/path/to/git/repo")
-        {'branch': 'main', 'commit': 'abc123...', 'changes': 3, 'last_commit': 'Fix bug'}
-        >>> get_git_info("/path/to/non-git")
-        {}
-
-    Notes:
-        - Timeout: 2 seconds for each Git command
-        - Security: Safe execution with subprocess.run(shell=False)
-        - Error handling: Returns an empty dictionary in case of all exceptions
-        - Commit message limited to 50 characters for display purposes
-
-    TDD History:
-        - RED: 3 items scenario test (Git repo, non-Git, error)
-        - GREEN: Implementation of subprocess-based Git command execution
-        - REFACTOR: Add timeout (2 seconds), strengthen exception handling, remove duplicates with helper function
-        - UPDATE: Added last_commit message field for SessionStart display
-    """
-    try:
-        # Check if it's a git repository
-        _run_git_command(["rev-parse", "--git-dir"], cwd)
-
-        # Get branch name, commit hash, and changes
-        branch = _run_git_command(["branch", "--show-current"], cwd)
-        commit = _run_git_command(["rev-parse", "HEAD"], cwd)
-        status_output = _run_git_command(["status", "--short"], cwd)
-        changes = len([line for line in status_output.splitlines() if line])
-
-        # Get last commit message (subject only, limited to 50 chars)
-        last_commit = _run_git_command(["log", "-1", "--format=%s"], cwd)
-        if len(last_commit) > 50:
-            last_commit = last_commit[:47] + "..."
-
-        return {
-            "branch": branch,
-            "commit": commit,
-            "changes": changes,
-            "last_commit": last_commit,
-        }
-
-    except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
-        return {}
-
-
-def count_specs(cwd: str) -> dict[str, int]:
-    """SPEC File count and progress calculation
-
-    Browse the .moai/specs/ directory to find the number of SPEC Files and
-    Counts the number of SPECs with status: completed.
-
-    Args:
-        cwd: Project root directory path
-
-    Returns:
-        SPEC progress dictionary. Includes the following keys:
-        - completed: Number of completed SPECs (int)
-        - total: total number of SPECs (int)
-        - percentage: completion percentage (int, 0~100)
-
-        All 0 if .moai/specs/ directory does not exist
-
-    Examples:
-        >>> count_specs("/path/to/project")
-        {'completed': 2, 'total': 5, 'percentage': 40}
-        >>> count_specs("/path/to/no-specs")
-        {'completed': 0, 'total': 0, 'percentage': 0}
-
-    Notes:
-        - SPEC File Location: .moai/specs/SPEC-{ID}/spec.md
-        - Completion condition: Include “status: completed” in YAML front matter
-        - If parsing fails, the SPEC is considered incomplete.
-
-    TDD History:
-        - RED: 5 items scenario test (0/0, 2/5, 5/5, no directory, parsing error)
-        - GREEN: SPEC search with Path.iterdir(), YAML parsing implementation
-        - REFACTOR: Strengthened exception handling, improved percentage calculation safety
-    """
-    specs_dir = Path(cwd) / ".moai" / "specs"
-
-    if not specs_dir.exists():
-        return {"completed": 0, "total": 0, "percentage": 0}
-
-    completed = 0
-    total = 0
-
-    for spec_dir in specs_dir.iterdir():
-        if not spec_dir.is_dir() or not spec_dir.name.startswith("SPEC-"):
-            continue
-
-        spec_file = spec_dir / "spec.md"
-        if not spec_file.exists():
-            continue
-
-        total += 1
-
-        # Parse YAML front matter
-        try:
-            content = spec_file.read_text()
-            if content.startswith("---"):
-                yaml_end = content.find("---", 3)
-                if yaml_end > 0:
-                    yaml_content = content[3:yaml_end]
-                    if "status: completed" in yaml_content:
-                        completed += 1
-        except (OSError, UnicodeDecodeError):
-            # File read failure or encoding error - considered incomplete
-            pass
-
-    percentage = int(completed / total * 100) if total > 0 else 0
-
-    return {
-        "completed": completed,
-        "total": total,
-        "percentage": percentage,
-    }
-
-
-def get_project_language(cwd: str) -> str:
-    """Determine the primary project language (prefers config.json).
-
-    Args:
-        cwd: Project root directory.
-
-    Returns:
-        Language string in lower-case.
-
-    Notes:
-        - Reads ``.moai/config.json`` first for a quick answer.
-        - Falls back to ``detect_language`` if configuration is missing.
-    """
-    config_path = Path(cwd) / ".moai" / "config.json"
-    if config_path.exists():
-        try:
-            config = json.loads(config_path.read_text())
-            lang = config.get("language", "")
-            if lang:
-                return lang
-        except (OSError, json.JSONDecodeError):
-            # Fall back to detection on parse errors
-            pass
-
-    # Fall back to the original language detection routine
-    return detect_language(cwd)
-
-
-def get_package_version_info() -> dict[str, Any]:
-    """Check MoAI-ADK current and latest version from PyPI
-
-    Compares the installed version with the latest version available on PyPI.
-    Returns version information for SessionStart hook to display update recommendations.
-
-    Returns:
-        dict with keys:
-            - "current": Current installed version
-            - "latest": Latest version available on PyPI
-            - "update_available": Boolean indicating if update is available
-            - "upgrade_command": Recommended upgrade command (if update available)
-
-    Note:
-        - Has 1-second timeout to avoid blocking SessionStart
-        - Returns graceful fallback if PyPI check fails
-        - Handles version parsing gracefully
-    """
-    from importlib.metadata import version, PackageNotFoundError
-    import urllib.request
-    import urllib.error
-
-    result = {
-        "current": "unknown",
-        "latest": "unknown",
-        "update_available": False,
-        "upgrade_command": ""
-    }
-
-    # Get current version
-    try:
-        result["current"] = version("moai-adk")
-    except PackageNotFoundError:
-        result["current"] = "dev"
-        return result
-
-    # Get latest version from PyPI (with 1-second timeout)
-    try:
-        with timeout_handler(1):
-            url = "https://pypi.org/pypi/moai-adk/json"
-            headers = {"Accept": "application/json"}
-            req = urllib.request.Request(url, headers=headers)
-            with urllib.request.urlopen(req, timeout=0.8) as response:
-                data = json.load(response)
-                result["latest"] = data.get("info", {}).get("version", "unknown")
-    except (urllib.error.URLError, TimeoutError, Exception):
-        # Network error or timeout - return with unknown latest version
-        return result
-
-    # Compare versions (simple comparison)
-    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(".")]
-
-            # Pad shorter version with zeros
-            max_len = max(len(current_parts), len(latest_parts))
-            current_parts.extend([0] * (max_len - len(current_parts)))
-            latest_parts.extend([0] * (max_len - len(latest_parts)))
-
-            if latest_parts > current_parts:
-                result["update_available"] = True
-                result["upgrade_command"] = f"uv pip install --upgrade moai-adk>={result['latest']}"
-        except (ValueError, AttributeError):
-            # Version parsing failed - skip comparison
-            pass
-
-    return result
-
-
-__all__ = [
-    "detect_language",
-    "get_git_info",
-    "count_specs",
-    "get_project_language",
-    "get_package_version_info",
-]

moai_adk/templates/.claude/hooks/alfred/core/tags.py

@@ -1,198 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:HOOK-TAG-001 | SPEC: TBD | TEST: tests/hooks/test_tag_validation.py
-"""TAG validation helpers for MoAI-ADK hooks
-
-Fast checks used by PreToolUse/PostToolUse to nudge users when
-new or modified files are missing required @TAG annotations.
-
-Configurable rules with sensible defaults:
-- Load patterns from .moai/tag-rules.json if present.
-- Otherwise, apply default glob patterns (folder names are not hard-coded only).
-
-Defaults (order matters; first match wins):
-1) SPEC
-   - .moai/specs/**
-   - **/SPEC-*/spec.md
-2) TEST
-   - **/*_test.py, **/test_*.py, **/*.test.* (ts,tsx,js,jsx,go,rs)
-   - **/*.spec.* (ts,tsx,js,jsx)
-   - tests/**
-3) DOC
-   - docs/**/*.md, **/README.md, **/*.api.md
-4) CODE
-   - Source extensions: .py,.ts,.tsx,.js,.jsx,.go,.rs,.java,.kt,.rb,.php,.c,.cpp,.cs,.swift,.scala
-   - Excluding TEST patterns
-
-Notes:
-- Best-effort: skip binary/large files and non-target paths
-- Do not block execution; return a list of issues for messaging
-"""
-
-from __future__ import annotations
-
-import fnmatch
-import json
-import subprocess
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Iterable, List, Optional
-
-DEFAULT_CODE_EXTS = (
-    ".py", ".ts", ".tsx", ".js", ".jsx", ".go", ".rs",
-    ".java", ".kt", ".rb", ".php", ".c", ".cpp", ".cs",
-    ".swift", ".scala"
-)
-
-
-@dataclass
-class TagIssue:
-    path: str
-    expected: str  # one of @SPEC, @TEST, @CODE, @DOC
-    reason: str
-
-
-@dataclass
-class Rule:
-    include: List[str]
-    expect: str  # '@SPEC:' | '@TEST:' | '@CODE:' | '@DOC:'
-    exclude: List[str]
-
-
-def _load_rules(cwd: str) -> List[Rule]:
-    """Load tag rules from .moai/tag-rules.json or return defaults.
-
-    Schema example:
-    {
-      "rules": [
-        {"include": ["**/*_test.py", "**/*.test.ts"], "expect": "@TEST:", "exclude": []},
-        {"include": ["docs/**/*.md", "**/README.md"], "expect": "@DOC:", "exclude": []}
-      ]
-    }
-    """
-    cfg = Path(cwd) / ".moai" / "tag-rules.json"
-    if cfg.exists():
-        try:
-            data = json.loads(cfg.read_text(encoding="utf-8"))
-            items = data.get("rules", [])
-            rules: List[Rule] = []
-            for it in items:
-                include = list(it.get("include", []))
-                expect = str(it.get("expect", ""))
-                exclude = list(it.get("exclude", []))
-                if include and expect in ("@SPEC:", "@TEST:", "@CODE:", "@DOC:"):
-                    rules.append(Rule(include=include, expect=expect, exclude=exclude))
-            if rules:
-                return rules
-        except Exception:
-            pass
-
-    # Defaults (ordered)
-    return [
-        Rule(
-            include=[".moai/specs/**", "**/SPEC-*/spec.md"],
-            expect="@SPEC:",
-            exclude=[]
-        ),
-        Rule(
-            include=[
-                "**/*_test.py", "**/test_*.py", "**/*.test.ts",
-                "**/*.test.tsx", "**/*.test.js", "**/*.test.jsx",
-                "**/*.test.go", "**/*.test.rs", "**/*.spec.ts",
-                "**/*.spec.tsx", "tests/**"
-            ],
-            expect="@TEST:",
-            exclude=[".claude/**"]
-        ),
-        Rule(
-            include=["docs/**/*.md", "**/README.md", "**/*.api.md"],
-            expect="@DOC:",
-            exclude=[".claude/**"]
-        ),
-        Rule(
-            include=["**/*"],
-            expect="@CODE:",
-            exclude=[
-                "tests/**", "docs/**", ".moai/**", ".claude/**",
-                "**/*.md", "**/*.json", "**/*.yml", "**/*.yaml",
-                "**/*.toml", "**/*.lock", "**/*.svg", "**/*.png",
-                "**/*.jpg", "**/*.jpeg", "**/*.gif"
-            ]
-        ),
-    ]
-
-
-def _match_any(path: str, patterns: List[str]) -> bool:
-    return any(fnmatch.fnmatch(path, pat) for pat in patterns)
-
-
-def _needs_tag_str(path_str: str, rules: List[Rule]) -> Optional[str]:
-    p = path_str
-    for rule in rules:
-        if _match_any(p, rule.include) and not _match_any(p, rule.exclude):
-            if rule.expect == "@CODE:":
-                # CODE: limit to source-like extensions to reduce noise
-                if not any(p.endswith(ext) for ext in DEFAULT_CODE_EXTS):
-                    continue
-            return rule.expect
-    return None
-
-
-def _has_tag(content: str, expected: str) -> bool:
-    return expected in content
-
-
-def _iter_recent_changes(cwd: str) -> Iterable[Path]:
-    root = Path(cwd)
-    try:
-        # Staged files
-        r1 = subprocess.run(
-            ["git", "diff", "--name-only", "--cached"],
-            cwd=cwd, capture_output=True, text=True, timeout=1
-        )
-        # Modified (unstaged) tracked files
-        r2 = subprocess.run(
-            ["git", "ls-files", "-m"],
-            cwd=cwd, capture_output=True, text=True, timeout=1
-        )
-        # Untracked (other) files respecting .gitignore
-        r3 = subprocess.run(
-            ["git", "ls-files", "-o", "--exclude-standard"],
-            cwd=cwd, capture_output=True, text=True, timeout=1
-        )
-        names = set()
-        if r1.returncode == 0:
-            names.update([line.strip() for line in r1.stdout.splitlines() if line.strip()])
-        if r2.returncode == 0:
-            names.update([line.strip() for line in r2.stdout.splitlines() if line.strip()])
-        if r3.returncode == 0:
-            names.update([line.strip() for line in r3.stdout.splitlines() if line.strip()])
-        for n in names:
-            p = (root / n).resolve()
-            if p.is_file():
-                yield p
-    except Exception:
-        return []
-
-
-def scan_recent_changes_for_missing_tags(cwd: str) -> list[TagIssue]:
-    issues: list[TagIssue] = []
-    rules = _load_rules(cwd)
-    root = Path(cwd).resolve()
-    for path in _iter_recent_changes(cwd):
-        try:
-            content = path.read_text(encoding="utf-8", errors="ignore")
-        except Exception:
-            continue
-        # compute relative path once and use for matching/excluding
-        try:
-            rel = path.resolve().relative_to(root)
-            rel_s = rel.as_posix()
-        except Exception:
-            rel_s = path.name
-
-        expected = _needs_tag_str(rel_s, rules)
-        if not expected:
-            continue
-        if not _has_tag(content, expected):
-            issues.append(TagIssue(path=rel_s, expected=expected, reason="missing tag"))
-    return issues

moai_adk/templates/.claude/hooks/alfred/handlers/__init__.py

@@ -1,21 +0,0 @@
-#!/usr/bin/env python3
-"""Event handlers for Alfred Hooks
-
-Claude Code Event Handlers
-"""
-
-from .notification import handle_notification, handle_stop, handle_subagent_stop
-from .session import handle_session_end, handle_session_start
-from .tool import handle_post_tool_use, handle_pre_tool_use
-from .user import handle_user_prompt_submit
-
-__all__ = [
-    "handle_session_start",
-    "handle_session_end",
-    "handle_user_prompt_submit",
-    "handle_pre_tool_use",
-    "handle_post_tool_use",
-    "handle_notification",
-    "handle_stop",
-    "handle_subagent_stop",
-]

moai_adk/templates/.claude/hooks/alfred/handlers/notification.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python3
-"""Notification and control handlers
-
-Notification, Stop, SubagentStop event handling
-"""
-
-from core import HookPayload, HookResult
-
-
-def handle_notification(payload: HookPayload) -> HookResult:
-    """Notification event handler (default implementation)"""
-    return HookResult()
-
-
-def handle_stop(payload: HookPayload) -> HookResult:
-    """Stop event handler (default implementation)"""
-    return HookResult()
-
-
-def handle_subagent_stop(payload: HookPayload) -> HookResult:
-    """SubagentStop event handler (default implementation)"""
-    return HookResult()
-
-
-__all__ = ["handle_notification", "handle_stop", "handle_subagent_stop"]