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

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

@@ -1,174 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:HOOKS-REFACTOR-001 | SPEC: SPEC-HOOKS-REFACTOR-001.md
-"""Alfred Hooks - Main entry point for MoAI-ADK Claude Code Hooks
-
-A main entry point that routes Claude Code events to the appropriate handlers.
-
-🏗️ Architecture:
-┌─────────────────────────────────────────────────────────────┐
-│ alfred_hooks.py (Router)                                    │
-├─────────────────────────────────────────────────────────────┤
-│ - CLI argument parsing                                      │
-│ - JSON I/O (stdin/stdout)                                   │
-│ - Event routing to handlers                                 │
-└─────────────────────────────────────────────────────────────┘
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│ handlers/ (Event Handlers)                                  │
-├─────────────────────────────────────────────────────────────┤
-│ - session.py: SessionStart, SessionEnd                      │
-│ - user.py: UserPromptSubmit                                 │
-│ - tool.py: PreToolUse, PostToolUse                          │
-│ - notification.py: Notification, Stop, SubagentStop         │
-└─────────────────────────────────────────────────────────────┘
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│ core/ (Business Logic)                                      │
-├─────────────────────────────────────────────────────────────┤
-│ - project.py: Language detection, Git info, SPEC progress   │
-│ - context.py: JIT Retrieval, workflow context               │
-│ - checkpoint.py: Event-Driven Checkpoint system             │
-│ - tags.py: TAG search/verification, library version cache   │
-└─────────────────────────────────────────────────────────────┘
-
-🛠️ Usage:
-    python alfred_hooks.py <event_name> < payload.json
-
-📣 Supported Events:
-    - SessionStart: Start Session (display project status)
-    - UserPromptSubmit: Prompt submission (JIT document loading)
-    - PreToolUse: Before using the tool (automatically creates checkpoint)
-    - SessionEnd, PostToolUse, Notification, Stop, SubagentStop
-
-🚦 Exit Codes:
-    - 0: Success
-    - 1: Error (no arguments, JSON parsing failure, exception thrown)
-
-🧪 TDD History:
-    - RED: Module separation design, event routing test
-    - GREEN: 1233 LOC → 9 items Module separation implementation (SRP compliance)
-    - REFACTOR: Import optimization, enhanced error handling
-
-Setup sys.path for package imports
-"""
-
-import json
-import sys
-from pathlib import Path
-from typing import Any
-
-from core import HookResult
-from handlers import (
-    handle_notification,
-    handle_post_tool_use,
-    handle_pre_tool_use,
-    handle_session_end,
-    handle_session_start,
-    handle_stop,
-    handle_subagent_stop,
-    handle_user_prompt_submit,
-)
-
-# Add the hooks directory to sys.path to enable package imports
-HOOKS_DIR = Path(__file__).parent
-if str(HOOKS_DIR) not in sys.path:
-    sys.path.insert(0, str(HOOKS_DIR))
-
-
-def main() -> None:
-    """Main entry point - Claude Code Hook script
-
-    Receives the event name as a CLI argument and reads the JSON payload through stdin.
-    Calls the handler appropriate for the event and outputs the results to stdout as JSON.
-
-    🛠️ Usage:
-        python alfred_hooks.py <event_name> < payload.json
-
-    📣 Supported Events:
-        - SessionStart: Start Session (display project status)
-        - UserPromptSubmit: Prompt submission (JIT document loading)
-        - SessionEnd, PreToolUse, PostToolUse, Notification, Stop, SubagentStop
-
-    🚦 Exit Codes:
-        - 0: Success
-        - 1: Error (no arguments, JSON parsing failure, exception thrown)
-
-    📝 Examples:
-        $ echo '{"cwd": "."}' | python alfred_hooks.py SessionStart
-        {"message": "🚀 MoAI-ADK Session Started\\n...", ...}
-
-    🗒️ Notes:
-        - Claude Code is automatically called (no need for direct user execution)
-        - JSON I/O processing through stdin/stdout
-        - Print error message to stderr
-        - UserPromptSubmit uses a special output schema (hookEventName + additionalContext)
-
-    🧪 TDD History:
-        - RED: Event routing, JSON I/O, error handling testing
-        - GREEN: Handler map-based routing implementation
-        - REFACTOR: Error message clarification, exit code standardization, UserPromptSubmit schema separation
-    """
-    # Check for event argument
-    if len(sys.argv) < 2:
-        print("Usage: alfred_hooks.py <event>", file=sys.stderr)
-        sys.exit(1)
-
-    event_name = sys.argv[1]
-
-    try:
-        # Read JSON from stdin
-        input_data = sys.stdin.read()
-        # Handle empty stdin gracefully (return empty dict)
-        if not input_data or not input_data.strip():
-            data = {}
-        else:
-            data = json.loads(input_data)
-
-        cwd = data.get("cwd", ".")
-
-        # Route to appropriate handler
-        handlers = {
-            "SessionStart": handle_session_start,
-            "UserPromptSubmit": handle_user_prompt_submit,
-            "SessionEnd": handle_session_end,
-            "PreToolUse": handle_pre_tool_use,
-            "PostToolUse": handle_post_tool_use,
-            "Notification": handle_notification,
-            "Stop": handle_stop,
-            "SubagentStop": handle_subagent_stop,
-        }
-
-        handler = handlers.get(event_name)
-        result = handler({"cwd": cwd, **data}) if handler else HookResult()
-
-        # Output Hook result as JSON
-        # Note: UserPromptSubmit uses to_user_prompt_submit_dict() for special schema
-        if event_name == "UserPromptSubmit":
-            print(json.dumps(result.to_user_prompt_submit_dict()))
-        else:
-            print(json.dumps(result.to_dict()))
-
-        sys.exit(0)
-
-    except json.JSONDecodeError as e:
-        # Return valid Hook response even on JSON parse error
-        error_response: dict[str, Any] = {
-            "continue": True,
-            "hookSpecificOutput": {"error": f"JSON parse error: {e}"}
-        }
-        print(json.dumps(error_response))
-        print(f"JSON parse error: {e}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        # Return valid Hook response even on unexpected error
-        error_response: dict[str, Any] = {
-            "continue": True,
-            "hookSpecificOutput": {"error": f"Hook error: {e}"}
-        }
-        print(json.dumps(error_response))
-        print(f"Unexpected error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

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

@@ -1,170 +0,0 @@
-#!/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/context.py

@@ -1,67 +0,0 @@
-#!/usr/bin/env python3
-"""Context Engineering utilities
-
-JIT (Just-in-Time) Retrieval
-"""
-
-from pathlib import Path
-
-
-def get_jit_context(prompt: str, cwd: str) -> list[str]:
-    """JIT Context Retrieval based on prompt.
-
-    Analyze user prompts and automatically recommend relevant documents.
-    Alfred commands and keyword-based pattern matching load only the documents you need.
-
-    Args:
-        prompt: Prompt for user input (case is irrelevant)
-        cwd: Project root directory path
-
-    Returns:
-        List of recommended document paths (relative paths).
-        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
-        - "test" → tests/ (if directory exists)
-
-    Examples:
-        >>> get_jit_context("/alfred:1-plan", "/project")
-        ['.moai/memory/spec-metadata.md']
-        >>> get_jit_context("implement test", "/project")
-        ['tests/']
-        >>> get_jit_context("unknown", "/project")
-        []
-
-    Notes:
-        - Context Engineering: Compliance with JIT Retrieval principles
-        - Minimize initial context burden by loading only necessary documents
-        - Return after checking whether file exists
-
-    TDD History:
-        - RED: 18 items scenario testing (command matching, keywords, empty results)
-        - GREEN: Pattern matching dictionary-based implementation
-        - REFACTOR: Expandable pattern structure, file existence validation added
-    """
-    context_files = []
-    cwd_path = Path(cwd)
-
-    # Pattern matching
-    patterns = {
-        "/alfred:1-plan": [".moai/memory/spec-metadata.md"],
-        "/alfred:2-run": [".moai/memory/development-guide.md"],
-        "test": ["tests/"],
-    }
-
-    for pattern, files in patterns.items():
-        if pattern in prompt.lower():
-            for file in files:
-                file_path = cwd_path / file
-                if file_path.exists():
-                    context_files.append(file)
-
-    return context_files
-
-
-__all__ = ["get_jit_context"]