moai-adk 0.9.1__py3-none-any.whl → 0.11.0__py3-none-any.whl

moai_adk/templates/.claude/hooks/alfred/shared/handlers/tool.py

@@ -1,90 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:HOOK-TOOL-001 | SPEC: TBD | TEST: tests/hooks/test_handlers.py
-"""Tool usage handlers
-
-PreToolUse, PostToolUse event handling
-"""
-
-from core import HookPayload, HookResult
-from core.checkpoint import create_checkpoint, detect_risky_operation
-from core.tags import scan_recent_changes_for_missing_tags
-
-
-def handle_pre_tool_use(payload: HookPayload) -> HookResult:
-    """PreToolUse event handler (Event-Driven Checkpoint integration)
-
-    Automatically creates checkpoints before dangerous operations.
-    Called before using the Claude Code tool, it notifies the user when danger is detected.
-
-    Args:
-        payload: Claude Code event payload
-                 (includes tool, arguments, cwd keys)
-
-    Returns:
-        HookResult(
-            system_message=checkpoint creation notification (when danger is detected);
-            continue_execution=True (always continue operation)
-        )
-
-    Checkpoint Triggers:
-        - Bash: rm -rf, git merge, git reset --hard
-        - Edit/Write: CLAUDE.md, config.json
-        - MultiEdit: ≥10 files
-
-    Examples:
-        Bash tool (rm -rf) detection:
-        → "🛡️ Checkpoint created: before-delete-20251015-143000"
-
-    Notes:
-        - Return continue_execution=True even after detection of danger (continue operation)
-        - Work continues even when checkpoint fails (ignores)
-        - Transparent background operation
-
-    @TAG:CHECKPOINT-EVENT-001
-    """
-    tool_name = payload.get("tool", "")
-    tool_args = payload.get("arguments", {})
-    cwd = payload.get("cwd", ".")
-
-    # Dangerous operation detection (best-effort)
-    try:
-        is_risky, operation_type = detect_risky_operation(tool_name, tool_args, cwd)
-        # Create checkpoint when danger is detected
-        if is_risky:
-            checkpoint_branch = create_checkpoint(cwd, operation_type)
-            if checkpoint_branch != "checkpoint-failed":
-                system_message = (
-                    f"🛡️ Checkpoint created: {checkpoint_branch}\n"
-                    f"   Operation: {operation_type}"
-                )
-                return HookResult(system_message=system_message, continue_execution=True)
-    except Exception:
-        # Do not fail the hook if risk detection errors out
-        pass
-
-    # TAG Guard (gentle): warn when recent changes miss @TAG
-    issues = scan_recent_changes_for_missing_tags(cwd)
-    if issues:
-        # Summarize first few issues for display
-        preview = "\n".join(
-            f" - {i.path} → 기대 태그: {i.expected}" for i in issues[:5]
-        )
-        more = "" if len(issues) <= 5 else f"\n (외 {len(issues)-5}건 더 존재)"
-        msg = (
-            "⚠️ TAG 누락 감지: 생성/수정한 파일 중 @TAG가 없는 항목이 있습니다.\n"
-            f"{preview}{more}\n"
-            "권장 조치:\n"
-            "  1) SPEC/TEST/CODE/DOC 유형에 맞는 @TAG를 파일 상단 주석이나 헤더에 추가\n"
-            "  2) rg로 확인: rg '@(SPEC|TEST|CODE|DOC):' -n <경로>\n"
-        )
-        return HookResult(system_message=msg, continue_execution=True)
-
-    return HookResult(continue_execution=True)
-
-
-def handle_post_tool_use(payload: HookPayload) -> HookResult:
-    """PostToolUse event handler (default implementation)"""
-    return HookResult()
-
-
-__all__ = ["handle_pre_tool_use", "handle_post_tool_use"]

moai_adk/templates/.claude/hooks/alfred/shared/handlers/user.py

@@ -1,61 +0,0 @@
-#!/usr/bin/env python3
-"""User interaction handlers
-
-Handling the UserPromptSubmit event
-"""
-
-from datetime import datetime
-from pathlib import Path
-
-from core import HookPayload, HookResult
-from core.context import get_jit_context
-
-
-def handle_user_prompt_submit(payload: HookPayload) -> HookResult:
-    """UserPromptSubmit event handler
-
-    Analyze user prompts and automatically add relevant documents into context.
-    Follow the just-in-time (JIT) retrieval principle to load only the documents you need.
-
-    Args:
-        payload: Claude Code event payload
-                 (includes userPrompt, cwd keys)
-
-    Returns:
-        HookResult(
-            system_message=Number of Files loaded (or None),
-            context_files=Recommended document path list
-        )
-
-    TDD History:
-        - RED: JIT document loading scenario testing
-        - GREEN: Recommend documents by calling get_jit_context()
-        - REFACTOR: Message conditional display (only when there is a file)
-        - UPDATE: Migrated to Claude Code standard Hook schema with snake_case fields
-        - FEATURE: Command execution logging for tracking double-run debugging
-    """
-    user_prompt = payload.get("userPrompt", "")
-    cwd = payload.get("cwd", ".")
-    context_files = get_jit_context(user_prompt, cwd)
-
-    # Command execution logging (DEBUG feature for tracking invocations)
-    if user_prompt.startswith("/alfred:"):
-        try:
-            log_dir = Path(cwd) / ".moai" / "logs"
-            log_dir.mkdir(parents=True, exist_ok=True)
-
-            log_file = log_dir / "command-invocations.log"
-            timestamp = datetime.now().isoformat()
-
-            with open(log_file, "a", encoding="utf-8") as f:
-                f.write(f"{timestamp} | {user_prompt}\n")
-        except Exception:
-            # Silently fail if logging fails (don't interrupt main flow)
-            pass
-
-    system_message = f"📎 Loaded {len(context_files)} context file(s)" if context_files else None
-
-    return HookResult(system_message=system_message, context_files=context_files)
-
-
-__all__ = ["handle_user_prompt_submit"]

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

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:HOOKS-CLARITY-001 | SPEC: Individual hook files for better UX
-"""Stop Hook: Handle Execution Interruption
-
-Claude Code Event: Stop
-Purpose: Handle graceful shutdown when execution is interrupted by user
-Execution: Triggered when user stops Claude Code execution (Ctrl+C, stop button)
-
-Output: Continue execution (currently a stub for future enhancements)
-"""
-
-import json
-import signal
-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))
-
-from handlers import handle_stop
-
-
-class HookTimeoutError(Exception):
-    """Hook execution timeout exception"""
-    pass
-
-
-def _timeout_handler(signum, frame):
-    """Signal handler for 5-second timeout"""
-    raise HookTimeoutError("Hook execution exceeded 5-second timeout")
-
-
-def main() -> None:
-    """Main entry point for Stop hook
-
-    Currently a stub for future functionality:
-    - Save partial work before interruption
-    - Create recovery checkpoint
-    - Log interruption reason and context
-    - Notify external systems of stop event
-
-    Exit Codes:
-        0: Success
-        1: Error (timeout, JSON parse failure, handler exception)
-    """
-    # Set 5-second timeout
-    signal.signal(signal.SIGALRM, _timeout_handler)
-    signal.alarm(5)
-
-    try:
-        # Read JSON payload from stdin
-        input_data = sys.stdin.read()
-        data = json.loads(input_data) if input_data.strip() else {}
-
-        # Call handler
-        result = handle_stop(data)
-
-        # Output result as JSON
-        print(json.dumps(result.to_dict()))
-        sys.exit(0)
-
-    except HookTimeoutError:
-        # Timeout - return minimal valid response
-        timeout_response: dict[str, Any] = {
-            "continue": True,
-            "systemMessage": "⚠️ Stop handler timeout"
-        }
-        print(json.dumps(timeout_response))
-        print("Stop 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"Stop 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"Stop error: {e}"}
-        }
-        print(json.dumps(error_response))
-        print(f"Stop unexpected error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    finally:
-        # Always cancel alarm
-        signal.alarm(0)
-
-
-if __name__ == "__main__":
-    main()

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

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:HOOKS-CLARITY-001 | SPEC: Individual hook files for better UX
-"""SubagentStop Hook: Handle Sub-agent Termination
-
-Claude Code Event: SubagentStop
-Purpose: Handle cleanup when a sub-agent execution completes or is terminated
-Execution: Triggered when Task tool completes (sub-agent finishes)
-
-Output: Continue execution (currently a stub for future enhancements)
-"""
-
-import json
-import signal
-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))
-
-from handlers import handle_subagent_stop
-
-
-class HookTimeoutError(Exception):
-    """Hook execution timeout exception"""
-    pass
-
-
-def _timeout_handler(signum, frame):
-    """Signal handler for 5-second timeout"""
-    raise HookTimeoutError("Hook execution exceeded 5-second timeout")
-
-
-def main() -> None:
-    """Main entry point for SubagentStop hook
-
-    Currently a stub for future functionality:
-    - Collect sub-agent execution metrics
-    - Log sub-agent results and errors
-    - Update workflow state based on sub-agent outcome
-    - Trigger follow-up actions based on results
-
-    Exit Codes:
-        0: Success
-        1: Error (timeout, JSON parse failure, handler exception)
-    """
-    # Set 5-second timeout
-    signal.signal(signal.SIGALRM, _timeout_handler)
-    signal.alarm(5)
-
-    try:
-        # Read JSON payload from stdin
-        input_data = sys.stdin.read()
-        data = json.loads(input_data) if input_data.strip() else {}
-
-        # Call handler
-        result = handle_subagent_stop(data)
-
-        # Output result as JSON
-        print(json.dumps(result.to_dict()))
-        sys.exit(0)
-
-    except HookTimeoutError:
-        # Timeout - return minimal valid response
-        timeout_response: dict[str, Any] = {
-            "continue": True,
-            "systemMessage": "⚠️ SubagentStop handler timeout"
-        }
-        print(json.dumps(timeout_response))
-        print("SubagentStop 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"SubagentStop 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"SubagentStop error: {e}"}
-        }
-        print(json.dumps(error_response))
-        print(f"SubagentStop unexpected error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    finally:
-        # Always cancel alarm
-        signal.alarm(0)
-
-
-if __name__ == "__main__":
-    main()

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

@@ -1,120 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:HOOKS-CLARITY-001 | SPEC: Individual hook files for better UX
-"""UserPromptSubmit Hook: Just-In-Time Document Loading
-
-Claude Code Event: UserPromptSubmit
-Purpose: Analyze user prompt and recommend relevant documents to load into context
-Execution: Triggered when user submits a prompt
-
-Output: additionalContext with document path suggestions
-"""
-
-import json
-import signal
-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))
-
-from handlers import handle_user_prompt_submit
-
-
-class HookTimeoutError(Exception):
-    """Hook execution timeout exception"""
-    pass
-
-
-def _timeout_handler(signum, frame):
-    """Signal handler for 5-second timeout"""
-    raise HookTimeoutError("Hook execution exceeded 5-second timeout")
-
-
-def main() -> None:
-    """Main entry point for UserPromptSubmit hook
-
-    Analyzes user prompt patterns and recommends relevant documents:
-    - /alfred:1-plan → spec-metadata.md
-    - /alfred:2-run → development-guide.md
-    - @TAG mentions → TAG documentation
-    - SPEC references → related SPEC files
-
-    Exit Codes:
-        0: Success
-        1: Error (timeout, JSON parse failure, handler exception)
-
-    Note: Uses special output schema for UserPromptSubmit:
-    {
-        "continue": true,
-        "hookSpecificOutput": {
-            "hookEventName": "UserPromptSubmit",
-            "additionalContext": "Document path suggestions..."
-        }
-    }
-    """
-    # Set 5-second timeout
-    signal.signal(signal.SIGALRM, _timeout_handler)
-    signal.alarm(5)
-
-    try:
-        # Read JSON payload from stdin
-        input_data = sys.stdin.read()
-        data = json.loads(input_data) if input_data.strip() else {}
-
-        # Call handler
-        result = handle_user_prompt_submit(data)
-
-        # Output result using UserPromptSubmit-specific schema
-        print(json.dumps(result.to_user_prompt_submit_dict()))
-        sys.exit(0)
-
-    except HookTimeoutError:
-        # Timeout - return minimal valid response
-        timeout_response: dict[str, Any] = {
-            "continue": True,
-            "hookSpecificOutput": {
-                "hookEventName": "UserPromptSubmit",
-                "additionalContext": "⚠️ JIT context timeout - continuing without suggestions"
-            }
-        }
-        print(json.dumps(timeout_response))
-        print("UserPromptSubmit 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": {
-                "hookEventName": "UserPromptSubmit",
-                "error": f"JSON parse error: {e}"
-            }
-        }
-        print(json.dumps(error_response))
-        print(f"UserPromptSubmit JSON parse error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    except Exception as e:
-        # Unexpected error
-        error_response: dict[str, Any] = {
-            "continue": True,
-            "hookSpecificOutput": {
-                "hookEventName": "UserPromptSubmit",
-                "error": f"UserPromptSubmit error: {e}"
-            }
-        }
-        print(json.dumps(error_response))
-        print(f"UserPromptSubmit unexpected error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    finally:
-        # Always cancel alarm
-        signal.alarm(0)
-
-
-if __name__ == "__main__":
-    main()