moai-adk 0.4.5__py3-none-any.whl → 0.20.1__py3-none-any.whl

moai_adk/templates/.claude/hooks/alfred/session_start__show_project_info.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+# SessionStart Hook: Enhanced Project Information
+"""SessionStart Hook: Enhanced Project Information
+
+Claude Code Event: SessionStart
+Purpose: Display enhanced project status with Git info, test status, and SPEC progress
+Execution: Triggered automatically when Claude Code session begins
+
+Enhanced Features:
+- Last commit information with relative time
+- Test coverage and status
+- Risk assessment
+- Formatted output with clear sections
+"""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+# Setup import path for shared modules
+HOOKS_DIR = Path(__file__).parent
+SHARED_DIR = HOOKS_DIR / "shared"
+if str(SHARED_DIR) not in sys.path:
+    sys.path.insert(0, str(SHARED_DIR))
+
+# Try to import existing modules, provide fallbacks if not available
+try:
+    from utils.timeout import CrossPlatformTimeout
+    from utils.timeout import TimeoutError as PlatformTimeoutError
+except ImportError:
+    # Fallback timeout implementation
+
+    class CrossPlatformTimeout:
+        def __init__(self, seconds):
+            self.seconds = seconds
+
+        def start(self):
+            pass
+
+        def cancel(self):
+            pass
+
+    class PlatformTimeoutError(Exception):
+        pass
+
+
+def get_git_info() -> dict[str, Any]:
+    """Get comprehensive git information"""
+    try:
+        # Get current branch
+        branch = subprocess.run(
+            ["git", "branch", "--show-current"],
+            capture_output=True,
+            text=True,
+            timeout=3
+        ).stdout.strip()
+
+        # Get last commit hash and message
+        last_commit = subprocess.run(
+            ["git", "log", "--pretty=format:%h %s", "-1"],
+            capture_output=True,
+            text=True,
+            timeout=3
+        ).stdout.strip()
+
+        # Get commit time (relative)
+        commit_time = subprocess.run(
+            ["git", "log", "--pretty=format:%ar", "-1"],
+            capture_output=True,
+            text=True,
+            timeout=3
+        ).stdout.strip()
+
+        # Get number of changed files
+        changes = subprocess.run(
+            ["git", "status", "--porcelain"],
+            capture_output=True,
+            text=True,
+            timeout=3
+        ).stdout.strip()
+        num_changes = len(changes.splitlines()) if changes else 0
+
+        return {
+            "branch": branch,
+            "last_commit": last_commit,
+            "commit_time": commit_time,
+            "changes": num_changes
+        }
+
+    except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
+        return {
+            "branch": "unknown",
+            "last_commit": "unknown",
+            "commit_time": "unknown",
+            "changes": 0
+        }
+
+
+def get_test_info() -> dict[str, Any]:
+    """Get test coverage and status information"""
+    try:
+        # Try to get test coverage (basic check)
+        coverage_result = subprocess.run(
+            ["python", "-m", "pytest", "--cov", "--tb=no", "-q"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            cwd=Path.cwd()
+        )
+
+        # Parse coverage from output (basic implementation)
+        coverage = "unknown"
+        if coverage_result.returncode == 0:
+            output = coverage_result.stdout
+            if "coverage:" in output.lower():
+                # Extract percentage from coverage output
+                import re
+                match = re.search(r'(\d+)%', output)
+                if match:
+                    coverage = f"{match.group(1)}%"
+
+        # Determine test status
+        test_status = "✅" if coverage_result.returncode == 0 else "❌"
+
+        return {
+            "coverage": coverage,
+            "status": test_status
+        }
+
+    except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
+        return {
+            "coverage": "unknown",
+            "status": "❓"
+        }
+
+
+def get_spec_progress() -> dict[str, Any]:
+    """Get SPEC progress information"""
+    try:
+        specs_dir = Path.cwd() / ".moai" / "specs"
+        if not specs_dir.exists():
+            return {"completed": 0, "total": 0, "percentage": 0}
+
+        spec_folders = [d for d in specs_dir.iterdir() if d.is_dir() and d.name.startswith("SPEC-")]
+        total = len(spec_folders)
+
+        # Simple completion check - look for spec.md files
+        completed = sum(1 for folder in spec_folders if (folder / "spec.md").exists())
+
+        percentage = (completed / total * 100) if total > 0 else 0
+
+        return {
+            "completed": completed,
+            "total": total,
+            "percentage": round(percentage, 0)
+        }
+
+    except Exception:
+        return {"completed": 0, "total": 0, "percentage": 0}
+
+
+def calculate_risk(git_info: dict, spec_progress: dict, test_info: dict) -> str:
+    """Calculate overall project risk level"""
+    risk_score = 0
+
+    # Git changes contribute to risk
+    if git_info["changes"] > 20:
+        risk_score += 10
+    elif git_info["changes"] > 10:
+        risk_score += 5
+
+    # SPEC progress contributes to risk
+    if spec_progress["percentage"] < 50:
+        risk_score += 15
+    elif spec_progress["percentage"] < 80:
+        risk_score += 8
+
+    # Test status contributes to risk
+    if test_info["status"] != "✅":
+        risk_score += 12
+    elif test_info["coverage"] == "unknown":
+        risk_score += 5
+
+    # Determine risk level
+    if risk_score >= 20:
+        return "HIGH"
+    elif risk_score >= 10:
+        return "MEDIUM"
+    else:
+        return "LOW"
+
+
+def format_session_output() -> str:
+    """Format the complete session start output"""
+    # Gather information
+    git_info = get_git_info()
+    test_info = get_test_info()
+    spec_progress = get_spec_progress()
+    risk_level = calculate_risk(git_info, spec_progress, test_info)
+
+    # Get MoAI version from config if available
+    moai_version = "unknown"
+    try:
+        config_path = Path.cwd() / ".moai" / "config.json"
+        if config_path.exists():
+            config = json.loads(config_path.read_text())
+            moai_version = config.get("moai", {}).get("version", "unknown")
+    except Exception:
+        pass
+
+    # Format output
+    output = [
+        "🚀 MoAI-ADK Session Started",
+        "",
+        "📊 Project Status:",
+        f"🗿 Version: {moai_version} | 🌿 {git_info['branch']} ({git_info['branch'][:8] if git_info['branch'] != 'unknown' else 'unknown'})",
+        f"📝 Changes: {git_info['changes']} | 🧪 Tests: {test_info['coverage']} {test_info['status']}",
+        f"📋 SPEC Progress: {spec_progress['completed']}/{spec_progress['total']} ({spec_progress['percentage']}%) | 🚨 Risk: {risk_level}",
+        f"🔨 Last: {git_info['last_commit']} ({git_info['commit_time']})"
+    ]
+
+    return "\n".join(output)
+
+
+def main() -> None:
+    """Main entry point for enhanced SessionStart hook
+
+    Displays enhanced project information including:
+    - Programming language and version
+    - Git branch, changes, and last commit with time
+    - SPEC progress (completed/total)
+    - Test coverage and status
+    - Risk assessment
+
+    Exit Codes:
+        0: Success
+        1: Error (timeout, JSON parse failure, handler exception)
+    """
+    # Set 5-second timeout
+    timeout = CrossPlatformTimeout(5)
+    timeout.start()
+
+    try:
+        # Read JSON payload from stdin (for compatibility)
+        input_data = sys.stdin.read()
+        data = json.loads(input_data) if input_data.strip() else {}
+
+        # Generate enhanced session output
+        session_output = format_session_output()
+
+        # Return as system message
+        result: dict[str, Any] = {
+            "continue": True,
+            "systemMessage": session_output
+        }
+
+        print(json.dumps(result))
+        sys.exit(0)
+
+    except PlatformTimeoutError:
+        # Timeout - return minimal valid response
+        timeout_response: dict[str, Any] = {
+            "continue": True,
+            "systemMessage": "⚠️ Session start timeout - continuing without project info",
+        }
+        print(json.dumps(timeout_response))
+        print("SessionStart hook timeout after 5 seconds", file=sys.stderr)
+        sys.exit(1)
+
+    except json.JSONDecodeError as e:
+        # JSON parse error
+        error_response: dict[str, Any] = {
+            "continue": True,
+            "hookSpecificOutput": {"error": f"JSON parse error: {e}"},
+        }
+        print(json.dumps(error_response))
+        print(f"SessionStart JSON parse error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    except Exception as e:
+        # Unexpected error
+        error_response: dict[str, Any] = {
+            "continue": True,
+            "hookSpecificOutput": {"error": f"SessionStart error: {e}"},
+        }
+        print(json.dumps(error_response))
+        print(f"SessionStart unexpected error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    finally:
+        # Always cancel timeout
+        timeout.cancel()
+
+
+if __name__ == "__main__":
+    main()

moai_adk/templates/.claude/hooks/alfred/shared/core/__init__.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Core module for Alfred Hooks
+
+Common type definitions and utility functions
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, NotRequired, TypedDict
+
+
+class HookPayload(TypedDict):
+    """Claude Code Hook event payload type definition
+
+    Data structure that Claude Code passes to the Hook script.
+    Use NotRequired because fields may vary depending on the event.
+    """
+
+    cwd: str
+    userPrompt: NotRequired[str]  # Includes only UserPromptSubmit events
+    tool: NotRequired[str]  # PreToolUse/PostToolUse events
+    arguments: NotRequired[dict[str, Any]]  # Tool arguments
+
+
+@dataclass
+class HookResult:
+    """Hook execution result following Claude Code standard schema.
+
+    Attributes conform to Claude Code Hook output specification:
+    https://docs.claude.com/en/docs/claude-code/hooks
+
+    Standard Fields (Claude Code schema - included in JSON output):
+        continue_execution: Allow execution to continue (default True)
+        suppress_output: Suppress hook output display (default False)
+        decision: "approve" or "block" operation (optional)
+        reason: Explanation for decision (optional)
+        permission_decision: "allow", "deny", or "ask" (optional)
+        system_message: Message displayed to user (top-level field)
+
+    Internal Fields (MoAI-ADK only - NOT in JSON output):
+        context_files: List of context files to load (internal use only)
+        suggestions: Suggestions for user (internal use only)
+        exit_code: Exit code for diagnostics (internal use only)
+
+    Note:
+        - systemMessage appears at TOP LEVEL in JSON output
+        - hookSpecificOutput is ONLY used for UserPromptSubmit events
+        - Internal fields are used for Python logic but not serialized to JSON
+    """
+
+    # Claude Code standard fields
+    continue_execution: bool = True
+    suppress_output: bool = False
+    decision: Literal["approve", "block"] | None = None
+    reason: str | None = None
+    permission_decision: Literal["allow", "deny", "ask"] | None = None
+
+    # MoAI-ADK custom fields (wrapped in hookSpecificOutput)
+    system_message: str | None = None
+    context_files: list[str] = field(default_factory=list)
+    suggestions: list[str] = field(default_factory=list)
+    exit_code: int = 0
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to Claude Code standard Hook output schema.
+
+        Returns:
+            Dictionary conforming to Claude Code Hook specification with:
+            - Top-level fields: continue, suppressOutput, decision, reason,
+              permissionDecision, systemMessage
+            - MoAI-ADK internal fields (context_files, suggestions, exit_code)
+              are NOT included in JSON output (used for internal logic only)
+
+        Examples:
+            >>> result = HookResult(continue_execution=True)
+            >>> result.to_dict()
+            {'continue': True}
+
+            >>> result = HookResult(decision="block", reason="Dangerous")
+            >>> result.to_dict()
+            {'decision': 'block', 'reason': 'Dangerous'}
+
+            >>> result = HookResult(system_message="Test")
+            >>> result.to_dict()
+            {'continue': True, 'systemMessage': 'Test'}
+
+        Note:
+            - systemMessage is a TOP-LEVEL field (not nested in hookSpecificOutput)
+            - hookSpecificOutput is ONLY used for UserPromptSubmit events
+            - context_files, suggestions, exit_code are internal-only fields
+        """
+        output: dict[str, Any] = {}
+
+        # Add decision or continue flag
+        if self.decision:
+            output["decision"] = self.decision
+        else:
+            output["continue"] = self.continue_execution
+
+        # Add reason if provided (works with both decision and permissionDecision)
+        if self.reason:
+            output["reason"] = self.reason
+
+        # Add suppressOutput if True
+        if self.suppress_output:
+            output["suppressOutput"] = True
+
+        # Add permissionDecision if set
+        if self.permission_decision:
+            output["permissionDecision"] = self.permission_decision
+
+        # Add systemMessage at TOP LEVEL (required by Claude Code schema)
+        if self.system_message:
+            output["systemMessage"] = self.system_message
+
+        # Note: context_files, suggestions, exit_code are internal-only fields
+        # and are NOT included in the JSON output per Claude Code schema
+
+        return output
+
+    def to_user_prompt_submit_dict(self) -> dict[str, Any]:
+        """UserPromptSubmit Hook-specific output format.
+
+        Claude Code requires a special schema for UserPromptSubmit events.
+        The result is wrapped in the standard Hook schema with hookSpecificOutput.
+
+        Returns:
+            Claude Code UserPromptSubmit Hook Dictionary matching schema:
+            {
+                "continue": true,
+                "hookSpecificOutput": {
+                    "hookEventName": "UserPromptSubmit",
+                    "additionalContext": "string"
+                }
+            }
+
+        Examples:
+            >>> result = HookResult(context_files=["tests/"])
+            >>> result.to_user_prompt_submit_dict()
+            {'continue': True, 'hookSpecificOutput': \
+{'hookEventName': 'UserPromptSubmit', 'additionalContext': '📎 Context: tests/'}}
+        """
+        # Convert context_files to additionalContext string
+        if self.context_files:
+            context_str = "\n".join([f"📎 Context: {f}" for f in self.context_files])
+        else:
+            context_str = ""
+
+        # Add system_message if there is one
+        if self.system_message:
+            if context_str:
+                context_str = f"{self.system_message}\n\n{context_str}"
+            else:
+                context_str = self.system_message
+
+        return {
+            "continue": self.continue_execution,
+            "hookSpecificOutput": {
+                "hookEventName": "UserPromptSubmit",
+                "additionalContext": context_str,
+            },
+        }
+
+
+__all__ = ["HookPayload", "HookResult"]
+
+# Note: core module exports:
+# - HookPayload, HookResult (type definitions)
+# - project.py: detect_language, get_git_info, count_specs, get_project_language
+# - context.py: get_jit_context
+# - checkpoint.py: detect_risky_operation, create_checkpoint, log_checkpoint, list_checkpoints

moai_adk/templates/.claude/hooks/alfred/{core → shared/core}/checkpoint.py

@@ -56,7 +56,7 @@ def detect_risky_operation(tool_name: str, tool_args: dict[str, Any], cwd: str)
 
     Risky Operations:
         - Bash tool: rm -rf, git merge, git reset --hard, git rebase, script execution
-        - Edit/Write tool: CLAUDE.md, config.json, .moai/memory/*.md
+        - Edit/Write tool: CLAUDE.md, config.json, .claude/skills/*.md
         - MultiEdit tool: Edit ≥10 items File simultaneously
         - Script execution: Python, Node, Java, Go, Rust, Dart, Swift, Kotlin, Shell scripts
 
@@ -98,8 +98,8 @@ def detect_risky_operation(tool_name: str, tool_args: dict[str, Any], cwd: str)
         critical_files = [
             "CLAUDE.md",
             "config.json",
-            ".moai/memory/development-guide.md",
-            ".moai/memory/spec-metadata.md",
+            ".claude/skills/moai-alfred-dev-guide/reference.md",
+            ".claude/skills/moai-alfred-spec-metadata-extended/reference.md",
             ".moai/config.json",
         ]
 

moai_adk/templates/.claude/hooks/alfred/{core → shared/core}/context.py

@@ -22,13 +22,13 @@ def get_jit_context(prompt: str, cwd: str) -> list[str]:
         If there is no matching pattern or file, an empty list []
 
     Patterns:
-        - "/alfred:1-plan" → .moai/memory/spec-metadata.md
-        - "/alfred:2-run" → .moai/memory/development-guide.md
+        - "/alfred:1-plan" → .claude/skills/moai-alfred-spec-metadata-extended/reference.md
+        - "/alfred:2-run" → .claude/skills/moai-alfred-dev-guide/reference.md
         - "test" → tests/ (if directory exists)
 
     Examples:
         >>> get_jit_context("/alfred:1-plan", "/project")
-        ['.moai/memory/spec-metadata.md']
+        ['.claude/skills/moai-alfred-spec-metadata-extended/reference.md']
         >>> get_jit_context("implement test", "/project")
         ['tests/']
         >>> get_jit_context("unknown", "/project")
@@ -49,8 +49,8 @@ def get_jit_context(prompt: str, cwd: str) -> list[str]:
 
     # Pattern matching
     patterns = {
-        "/alfred:1-plan": [".moai/memory/spec-metadata.md"],
-        "/alfred:2-run": [".moai/memory/development-guide.md"],
+        "/alfred:1-plan": [".claude/skills/moai-alfred-spec-metadata-extended/reference.md"],
+        "/alfred:2-run": [".claude/skills/moai-alfred-dev-guide/reference.md"],
         "test": ["tests/"],
     }