moai-adk 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

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

@@ -1,271 +0,0 @@
-#!/usr/bin/env python3
-"""Event-Driven Checkpoint system
-
-위험한 작업 감지 및 자동 Checkpoint 생성
-@TAG:CHECKPOINT-EVENT-001
-"""
-
-import json
-import re
-import subprocess
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-# MoAI-ADK 지원 언어별 스크립트 실행 패턴
-# Python, TypeScript, Java, Go, Rust, Dart, Swift, Kotlin + Shell
-SCRIPT_EXECUTION_PATTERN = re.compile(
-    r"\b("
-    # Python ecosystem
-    r"python3?|pytest|pip|uv|"
-    # JavaScript/TypeScript ecosystem
-    r"node|npm|npx|yarn|bun|tsx|ts-node|vitest|jest|"
-    # Java ecosystem
-    r"java|javac|mvn|gradle|"
-    # Go
-    r"go|"
-    # Rust
-    r"cargo|"
-    # Dart/Flutter
-    r"dart|flutter|"
-    # Swift
-    r"swift|xcodebuild|"
-    # Kotlin
-    r"kotlinc?|"
-    # Shell scripts and build tools
-    r"bash|sh|zsh|fish|make"
-    r")\b"
-)
-
-
-def detect_risky_operation(tool_name: str, tool_args: dict[str, Any], cwd: str) -> tuple[bool, str]:
-    """위험한 작업 감지 (Event-Driven Checkpoint용)
-
-    Claude Code tool 사용 전 위험한 작업을 자동으로 감지합니다.
-    위험 감지 시 자동으로 checkpoint를 생성하여 롤백 가능하게 합니다.
-
-    Args:
-        tool_name: Claude Code tool 이름 (Bash, Edit, Write, MultiEdit)
-        tool_args: Tool 인자 딕셔너리
-        cwd: 프로젝트 루트 디렉토리 경로
-
-    Returns:
-        (is_risky, operation_type) 튜플
-        - is_risky: 위험한 작업 여부 (bool)
-        - operation_type: 작업 유형 (str: delete, merge, script, critical-file, refactor)
-
-    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
-        - MultiEdit tool: ≥10개 파일 동시 수정
-        - Script execution: Python, Node, Java, Go, Rust, Dart, Swift, Kotlin, Shell scripts
-
-    Examples:
-        >>> detect_risky_operation("Bash", {"command": "rm -rf src/"}, ".")
-        (True, 'delete')
-        >>> detect_risky_operation("Edit", {"file_path": "CLAUDE.md"}, ".")
-        (True, 'critical-file')
-        >>> detect_risky_operation("Read", {"file_path": "test.py"}, ".")
-        (False, '')
-
-    Notes:
-        - False Positive 최소화: 안전한 작업은 무시
-        - 성능: 가벼운 문자열 매칭 (< 1ms)
-        - 확장성: patterns 딕셔너리로 쉽게 추가 가능
-
-    @TAG:CHECKPOINT-EVENT-001
-    """
-    # Bash tool: 위험한 명령어 감지
-    if tool_name == "Bash":
-        command = tool_args.get("command", "")
-
-        # 대규모 삭제
-        if any(pattern in command for pattern in ["rm -rf", "git rm"]):
-            return (True, "delete")
-
-        # Git 병합/리셋/리베이스
-        if any(pattern in command for pattern in ["git merge", "git reset --hard", "git rebase"]):
-            return (True, "merge")
-
-        # 외부 스크립트 실행 (파괴적 가능성)
-        if any(command.startswith(prefix) for prefix in ["python ", "node ", "bash ", "sh "]):
-            return (True, "script")
-
-    # Edit/Write tool: 중요 파일 감지
-    if tool_name in ("Edit", "Write"):
-        file_path = tool_args.get("file_path", "")
-
-        critical_files = [
-            "CLAUDE.md",
-            "config.json",
-            ".moai/memory/development-guide.md",
-            ".moai/memory/spec-metadata.md",
-            ".moai/config.json",
-        ]
-
-        if any(cf in file_path for cf in critical_files):
-            return (True, "critical-file")
-
-    # MultiEdit tool: 대규모 수정 감지
-    if tool_name == "MultiEdit":
-        edits = tool_args.get("edits", [])
-        if len(edits) >= 10:
-            return (True, "refactor")
-
-    return (False, "")
-
-
-def create_checkpoint(cwd: str, operation_type: str) -> str:
-    """Checkpoint 생성 (Git local branch)
-
-    위험한 작업 전 자동으로 checkpoint를 생성합니다.
-    Git local branch로 생성하여 원격 저장소 오염을 방지합니다.
-
-    Args:
-        cwd: 프로젝트 루트 디렉토리 경로
-        operation_type: 작업 유형 (delete, merge, script 등)
-
-    Returns:
-        checkpoint_branch: 생성된 브랜치명
-        실패 시 "checkpoint-failed" 반환
-
-    Branch Naming:
-        before-{operation}-{YYYYMMDD-HHMMSS}
-        예: before-delete-20251015-143000
-
-    Examples:
-        >>> create_checkpoint(".", "delete")
-        'before-delete-20251015-143000'
-
-    Notes:
-        - Local branch만 생성 (원격 push 안 함)
-        - Git 오류 시 fallback (무시하고 계속 진행)
-        - Dirty working directory 체크 안 함 (커밋 안 된 변경사항 허용)
-        - Checkpoint 로그 자동 기록 (.moai/checkpoints.log)
-
-    @TAG:CHECKPOINT-EVENT-001
-    """
-    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
-    branch_name = f"before-{operation_type}-{timestamp}"
-
-    try:
-        # 현재 브랜치에서 새 local branch 생성 (체크아웃 안 함)
-        result = subprocess.run(
-            ["git", "branch", branch_name],
-            cwd=cwd,
-            check=True,
-            capture_output=True,
-            text=True,
-            timeout=2,
-        )
-
-        # Checkpoint 로그 기록
-        log_checkpoint(cwd, branch_name, operation_type)
-
-        return branch_name
-
-    except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
-        # Git 오류 시 fallback (무시)
-        return "checkpoint-failed"
-
-
-def log_checkpoint(cwd: str, branch_name: str, operation_type: str) -> None:
-    """Checkpoint 로그 기록 (.moai/checkpoints.log)
-
-    Checkpoint 생성 이력을 JSON Lines 형식으로 기록합니다.
-    SessionStart에서 이 로그를 읽어 checkpoint 목록을 표시합니다.
-
-    Args:
-        cwd: 프로젝트 루트 디렉토리 경로
-        branch_name: 생성된 checkpoint 브랜치명
-        operation_type: 작업 유형
-
-    Log Format (JSON Lines):
-        {"timestamp": "2025-10-15T14:30:00", "branch": "before-delete-...", "operation": "delete"}
-
-    Examples:
-        >>> log_checkpoint(".", "before-delete-20251015-143000", "delete")
-        # .moai/checkpoints.log에 1줄 추가
-
-    Notes:
-        - 파일 없으면 자동 생성
-        - append 모드로 기록 (기존 로그 보존)
-        - 실패 시 무시 (critical하지 않음)
-
-    @TAG:CHECKPOINT-EVENT-001
-    """
-    log_file = Path(cwd) / ".moai" / "checkpoints.log"
-
-    try:
-        log_file.parent.mkdir(parents=True, exist_ok=True)
-
-        log_entry = {
-            "timestamp": datetime.now().isoformat(),
-            "branch": branch_name,
-            "operation": operation_type,
-        }
-
-        with log_file.open("a") as f:
-            f.write(json.dumps(log_entry) + "\n")
-
-    except (OSError, PermissionError):
-        # 로그 실패는 무시 (critical하지 않음)
-        pass
-
-
-def list_checkpoints(cwd: str, max_count: int = 10) -> list[dict[str, str]]:
-    """Checkpoint 목록 조회 (.moai/checkpoints.log 파싱)
-
-    최근 생성된 checkpoint 목록을 반환합니다.
-    SessionStart, /alfred:0-project restore 커맨드에서 사용합니다.
-
-    Args:
-        cwd: 프로젝트 루트 디렉토리 경로
-        max_count: 반환할 최대 개수 (기본 10개)
-
-    Returns:
-        Checkpoint 목록 (최신순)
-        [{"timestamp": "...", "branch": "...", "operation": "..."}, ...]
-
-    Examples:
-        >>> list_checkpoints(".")
-        [
-            {"timestamp": "2025-10-15T14:30:00", "branch": "before-delete-...", "operation": "delete"},
-            {"timestamp": "2025-10-15T14:25:00", "branch": "before-merge-...", "operation": "merge"},
-        ]
-
-    Notes:
-        - 로그 파일 없으면 빈 리스트 반환
-        - JSON 파싱 실패한 줄은 무시
-        - 최신 max_count개만 반환
-
-    @TAG:CHECKPOINT-EVENT-001
-    """
-    log_file = Path(cwd) / ".moai" / "checkpoints.log"
-
-    if not log_file.exists():
-        return []
-
-    checkpoints = []
-
-    try:
-        with log_file.open("r") as f:
-            for line in f:
-                try:
-                    checkpoints.append(json.loads(line.strip()))
-                except json.JSONDecodeError:
-                    # 파싱 실패한 줄 무시
-                    pass
-    except (OSError, PermissionError):
-        return []
-
-    # 최근 max_count개만 반환 (최신순)
-    return checkpoints[-max_count:]
-
-
-__all__ = [
-    "detect_risky_operation",
-    "create_checkpoint",
-    "log_checkpoint",
-    "list_checkpoints",
-]

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

@@ -1,110 +0,0 @@
-#!/usr/bin/env python3
-"""Context Engineering utilities
-
-JIT (Just-in-Time) Retrieval 및 워크플로우 컨텍스트 관리
-"""
-
-import time
-from pathlib import Path
-from typing import Any
-
-# Workflow context shared across phases
-_workflow_context: dict[str, Any] = {}
-
-
-def get_jit_context(prompt: str, cwd: str) -> list[str]:
-    """프롬프트 기반 JIT Context Retrieval
-
-    사용자 프롬프트를 분석하여 관련 문서를 자동으로 추천합니다.
-    Alfred 커맨드, 키워드 기반 패턴 매칭으로 필요한 문서만 로드합니다.
-
-    Args:
-        prompt: 사용자 입력 프롬프트 (대소문자 무관)
-        cwd: 프로젝트 루트 디렉토리 경로
-
-    Returns:
-        추천 문서 경로 리스트 (상대 경로).
-        매칭되는 패턴이 없거나 파일이 없으면 빈 리스트 []
-
-    Patterns:
-        - "/alfred:1-spec" → .moai/memory/spec-metadata.md
-        - "/alfred:2-build" → .moai/memory/development-guide.md
-        - "test" → tests/ (디렉토리가 존재하는 경우)
-
-    Examples:
-        >>> get_jit_context("/alfred:1-spec", "/project")
-        ['.moai/memory/spec-metadata.md']
-        >>> get_jit_context("implement test", "/project")
-        ['tests/']
-        >>> get_jit_context("unknown", "/project")
-        []
-
-    Notes:
-        - Context Engineering: JIT Retrieval 원칙 준수
-        - 필요한 문서만 로드하여 초기 컨텍스트 부담 최소화
-        - 파일 존재 여부 확인 후 반환
-
-    TDD History:
-        - RED: 18개 시나리오 테스트 (커맨드 매칭, 키워드, 빈 결과)
-        - GREEN: 패턴 매칭 딕셔너리 기반 구현
-        - REFACTOR: 확장 가능한 패턴 구조, 파일 존재 검증 추가
-    """
-    context_files = []
-    cwd_path = Path(cwd)
-
-    # Pattern matching
-    patterns = {
-        "/alfred:1-spec": [".moai/memory/spec-metadata.md"],
-        "/alfred:2-build": [".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
-
-
-def save_phase_context(phase: str, data: dict):
-    """Store per-phase workflow context data.
-
-    Args:
-        phase: ``"analysis"``, ``"implementation"`` or ``"verification"``.
-        data: Payload to share with later phases.
-
-    Notes:
-        - Enables reuse of expensive analysis across phases.
-        - Entries expire after 10 minutes to avoid stale data.
-    """
-    _workflow_context[phase] = {"data": data, "timestamp": time.time()}
-
-
-def load_phase_context(phase: str) -> dict | None:
-    """Load previously stored workflow context for a phase.
-
-    Returns:
-        Stored context data or ``None`` when expired or missing.
-    """
-    if phase in _workflow_context:
-        ctx = _workflow_context[phase]
-        # Only accept entries that are younger than 10 minutes
-        if time.time() - ctx["timestamp"] < 600:
-            return ctx["data"]
-    return None
-
-
-def clear_workflow_context():
-    """Clear all cached workflow context (call at workflow end)."""
-    _workflow_context.clear()
-
-
-__all__ = [
-    "get_jit_context",
-    "save_phase_context",
-    "load_phase_context",
-    "clear_workflow_context",
-]

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

@@ -1,284 +0,0 @@
-#!/usr/bin/env python3
-"""Project metadata utilities
-
-프로젝트 정보 조회 (언어, Git, SPEC 진행도 등)
-"""
-
-import json
-import subprocess
-from pathlib import Path
-from typing import Any
-
-
-def detect_language(cwd: str) -> str:
-    """프로젝트 언어 감지 (20개 언어 지원)
-
-    파일 시스템을 탐색하여 프로젝트의 주 개발 언어를 감지합니다.
-    pyproject.toml, tsconfig.json 등의 설정 파일을 우선 검사하며,
-    TypeScript 우선 원칙을 적용합니다 (tsconfig.json 존재 시).
-
-    Args:
-        cwd: 프로젝트 루트 디렉토리 경로 (절대/상대 경로 모두 가능)
-
-    Returns:
-        감지된 언어명 (소문자). 감지 실패 시 "Unknown Language" 반환.
-        지원 언어: 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: 21개 언어 감지 테스트 작성 (20개 언어 + 1개 unknown)
-        - GREEN: 20개 언어 + unknown 구현, 모든 테스트 통과
-        - REFACTOR: 파일 검사 순서 최적화, TypeScript 우선 원칙 적용
-    """
-    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 명령어 실행 헬퍼 함수
-
-    Git 명령어를 안전하게 실행하고 출력을 반환합니다.
-    코드 중복을 제거하고 일관된 에러 처리를 제공합니다.
-
-    Args:
-        args: Git 명령어 인자 리스트 (git은 자동 추가)
-        cwd: 실행 디렉토리 경로
-        timeout: 타임아웃 (초, 기본 2초)
-
-    Returns:
-        Git 명령어 출력 (stdout, 앞뒤 공백 제거)
-
-    Raises:
-        subprocess.TimeoutExpired: 타임아웃 초과
-        subprocess.CalledProcessError: Git 명령어 실패
-
-    Examples:
-        >>> _run_git_command(["branch", "--show-current"], ".")
-        'main'
-    """
-    result = subprocess.run(
-        ["git"] + args,
-        cwd=cwd,
-        capture_output=True,
-        text=True,
-        timeout=timeout,
-        check=True,
-    )
-    return result.stdout.strip()
-
-
-def get_git_info(cwd: str) -> dict[str, Any]:
-    """Git 리포지토리 정보 수집
-
-    Git 리포지토리의 현재 상태를 조회합니다.
-    브랜치명, 커밋 해시, 변경사항 개수를 반환하며,
-    Git 리포지토리가 아닌 경우 빈 딕셔너리를 반환합니다.
-
-    Args:
-        cwd: 프로젝트 루트 디렉토리 경로
-
-    Returns:
-        Git 정보 딕셔너리. 다음 키를 포함:
-        - branch: 현재 브랜치명 (str)
-        - commit: 현재 커밋 해시 (str, full hash)
-        - changes: 변경된 파일 개수 (int, staged + unstaged)
-
-        Git 리포지토리가 아니거나 조회 실패 시 빈 딕셔너리 {}
-
-    Examples:
-        >>> get_git_info("/path/to/git/repo")
-        {'branch': 'main', 'commit': 'abc123...', 'changes': 3}
-        >>> get_git_info("/path/to/non-git")
-        {}
-
-    Notes:
-        - 타임아웃: 각 Git 명령어 2초
-        - 보안: subprocess.run(shell=False)로 안전한 실행
-        - 에러 처리: 모든 예외 시 빈 딕셔너리 반환
-
-    TDD History:
-        - RED: 3개 시나리오 테스트 (Git 리포, 비 Git, 에러)
-        - GREEN: subprocess 기반 Git 명령어 실행 구현
-        - REFACTOR: 타임아웃 추가 (2초), 예외 처리 강화, 헬퍼 함수로 중복 제거
-    """
-    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])
-
-        return {
-            "branch": branch,
-            "commit": commit,
-            "changes": changes,
-        }
-
-    except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
-        return {}
-
-
-def count_specs(cwd: str) -> dict[str, int]:
-    """SPEC 파일 카운트 및 진행도 계산
-
-    .moai/specs/ 디렉토리를 탐색하여 SPEC 파일 개수와
-    완료 상태(status: completed)인 SPEC 개수를 집계합니다.
-
-    Args:
-        cwd: 프로젝트 루트 디렉토리 경로
-
-    Returns:
-        SPEC 진행도 딕셔너리. 다음 키를 포함:
-        - completed: 완료된 SPEC 개수 (int)
-        - total: 전체 SPEC 개수 (int)
-        - percentage: 완료율 (int, 0~100)
-
-        .moai/specs/ 디렉토리가 없으면 모두 0
-
-    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 파일 위치: .moai/specs/SPEC-{ID}/spec.md
-        - 완료 조건: YAML front matter에 "status: completed" 포함
-        - 파싱 실패 시 해당 SPEC은 미완료로 간주
-
-    TDD History:
-        - RED: 5개 시나리오 테스트 (0/0, 2/5, 5/5, 디렉토리 없음, 파싱 에러)
-        - GREEN: Path.iterdir()로 SPEC 탐색, YAML 파싱 구현
-        - REFACTOR: 예외 처리 강화, 퍼센트 계산 안전성 개선
-    """
-    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):
-            # 파일 읽기 실패 또는 인코딩 오류 - 미완료로 간주
-            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)
-
-
-__all__ = [
-    "detect_language",
-    "get_git_info",
-    "count_specs",
-    "get_project_language",
-]