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

moai_adk/templates/.claude/hooks/moai/lib/atomic_write.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Atomic file operations for MoAI hooks.
+
+Provides safe file write operations with atomic semantics
+to prevent race conditions and data corruption.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+
+# Maximum file size for state/cache files (1MB)
+MAX_STATE_FILE_SIZE = 1024 * 1024  # 1MB
+
+
+def atomic_write_text(
+    file_path: Path | str,
+    content: str,
+    encoding: str = "utf-8",
+    make_dirs: bool = True,
+) -> bool:
+    """Atomically write text content to a file.
+
+    Uses write-to-temp-then-rename pattern to prevent race conditions
+    and partial writes from corrupting data.
+
+    Args:
+        file_path: Path to the file
+        content: Content to write
+        encoding: File encoding (default: utf-8)
+        make_dirs: Create parent directories if needed (default: True)
+
+    Returns:
+        True if write succeeded, False otherwise
+    """
+    path = Path(file_path)
+
+    if make_dirs:
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # Write to temporary file first
+        fd, temp_path = tempfile.mkstemp(dir=path.parent, prefix=".tmp_", suffix=path.suffix or ".tmp")
+        try:
+            # Write content to temp file
+            with os.fdopen(fd, "w", encoding=encoding) as f:
+                f.write(content)
+
+            # Atomic rename (overwrites target if exists)
+            os.replace(temp_path, path)
+            return True
+        except Exception:
+            # Clean up temp file on error
+            try:
+                os.unlink(temp_path)
+            except OSError:
+                pass
+            return False
+    except (OSError, ValueError):
+        return False
+
+
+def atomic_write_json(
+    file_path: Path | str,
+    data: Any,
+    indent: int = 2,
+    encoding: str = "utf-8",
+    ensure_ascii: bool = True,
+    make_dirs: bool = True,
+) -> bool:
+    """Atomically write JSON data to a file.
+
+    Uses write-to-temp-then-rename pattern to prevent race conditions
+    and partial writes from corrupting data.
+
+    Args:
+        file_path: Path to the file
+        data: Data to serialize as JSON
+        indent: JSON indentation (default: 2)
+        encoding: File encoding (default: utf-8)
+        ensure_ascii: Escape non-ASCII characters (default: True)
+        make_dirs: Create parent directories if needed (default: True)
+
+    Returns:
+        True if write succeeded, False otherwise
+    """
+    path = Path(file_path)
+
+    if make_dirs:
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # Write to temporary file first
+        fd, temp_path = tempfile.mkstemp(dir=path.parent, prefix=".tmp_", suffix=".json")
+        try:
+            # Write JSON to temp file
+            with os.fdopen(fd, "w", encoding=encoding) as f:
+                json.dump(data, f, indent=indent, ensure_ascii=ensure_ascii)
+
+            # Atomic rename (overwrites target if exists)
+            os.replace(temp_path, path)
+            return True
+        except Exception:
+            # Clean up temp file on error
+            try:
+                os.unlink(temp_path)
+            except OSError:
+                pass
+            return False
+    except (OSError, ValueError, TypeError):
+        return False
+
+
+__all__ = [
+    "MAX_STATE_FILE_SIZE",
+    "atomic_write_text",
+    "atomic_write_json",
+]

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

@@ -2,41 +2,14 @@
 """Event-Driven Checkpoint system
 
 Detect risky tasks and create automatic checkpoints
-@TAG:CHECKPOINT-EVENT-001
 """
 
 import json
-import re
 import subprocess
 from datetime import datetime
 from pathlib import Path
 from typing import Any
 
-# Script execution pattern for each language supported by 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]:
     """Risk task detection (for Event-Driven Checkpoint)
@@ -56,7 +29,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
 
@@ -73,7 +46,6 @@ def detect_risky_operation(tool_name: str, tool_args: dict[str, Any], cwd: str)
         - Performance: lightweight string matching (< 1ms)
         - Extensibility: Easily added to the patterns dictionary
 
-    @TAG:CHECKPOINT-EVENT-001
     """
     # Bash tool: Detect dangerous commands
     if tool_name == "Bash":
@@ -98,9 +70,12 @@ 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",
-            ".moai/config.json",
+            "config.yaml",
+            ".claude/skills/moai-core-dev-guide/reference.md",
+            ".claude/skills/moai-core-spec-metadata-extended/reference.md",
+            ".moai/config/config.json",  # Legacy monolithic config
+            ".moai/config/config.yaml",  # Legacy monolithic config
+            ".moai/config/sections/",  # Section-based config (any file in sections/)
         ]
 
         if any(cf in file_path for cf in critical_files):
@@ -143,7 +118,6 @@ def create_checkpoint(cwd: str, operation_type: str) -> str:
         - Do not check dirty working directory (allow uncommitted changes)
         - Automatically record checkpoint logs (.moai/checkpoints.log)
 
-    @TAG:CHECKPOINT-EVENT-001
     """
     timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
     branch_name = f"before-{operation_type}-{timestamp}"
@@ -164,7 +138,11 @@ def create_checkpoint(cwd: str, operation_type: str) -> str:
 
         return branch_name
 
-    except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
+    except (
+        subprocess.CalledProcessError,
+        subprocess.TimeoutExpired,
+        FileNotFoundError,
+    ):
         # Fallback (ignore) in case of Git error
         return "checkpoint-failed"
 
@@ -192,7 +170,6 @@ def log_checkpoint(cwd: str, branch_name: str, operation_type: str) -> None:
         - Record in append mode (preserve existing logs)
         - Ignored in case of failure (not critical)
 
-    @TAG:CHECKPOINT-EVENT-001
     """
     log_file = Path(cwd) / ".moai" / "checkpoints.log"
 
@@ -217,7 +194,7 @@ def list_checkpoints(cwd: str, max_count: int = 10) -> list[dict[str, str]]:
     """Checkpoint list (parsing .moai/checkpoints.log)
 
     Returns a list of recently created checkpoints.
-    Used in the SessionStart, /alfred:0-project restore command.
+    Used in the SessionStart, /moai:0-project restore command.
 
     Args:
         cwd: Project root directory path
@@ -239,7 +216,6 @@ def list_checkpoints(cwd: str, max_count: int = 10) -> list[dict[str, str]]:
         - Ignore lines where JSON parsing fails
         - Return only the latest max_count
 
-    @TAG:CHECKPOINT-EVENT-001
     """
     log_file = Path(cwd) / ".moai" / "checkpoints.log"
 

moai_adk/templates/.claude/hooks/moai/lib/common.py

@@ -0,0 +1,161 @@
+"""Common utility functions for MoAI hooks
+
+Consolidated fallback implementations used across multiple hooks.
+"""
+
+from __future__ import annotations
+
+import re
+import statistics
+from typing import Any
+
+
+def merge_configs(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    """Recursively merge configuration dictionaries.
+
+    Deep merges two configuration dictionaries, with override values
+    taking precedence. Nested dictionaries are merged recursively.
+
+    Args:
+        base: Base configuration dictionary
+        override: Override configuration dictionary (values take precedence)
+
+    Returns:
+        Merged configuration dictionary
+
+    Examples:
+        >>> base = {"a": 1, "b": {"c": 2}}
+        >>> override = {"b": {"d": 3}}
+        >>> merge_configs(base, override)
+        {'a': 1, 'b': {'c': 2, 'd': 3}}
+    """
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = merge_configs(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def format_duration(seconds: float) -> str:
+    """Format duration in seconds to readable string.
+
+    Converts seconds to human-readable format (s, m, h).
+
+    Args:
+        seconds: Duration in seconds
+
+    Returns:
+        Formatted duration string (e.g., "2.5m", "1.3h")
+    """
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes = seconds / 60
+    if minutes < 60:
+        return f"{minutes:.1f}m"
+    hours = minutes / 60
+    return f"{hours:.1f}h"
+
+
+def get_summary_stats(values: list[float]) -> dict[str, float]:
+    """Get summary statistics for a list of values.
+
+    Calculates mean, min, max, and standard deviation.
+
+    Args:
+        values: List of numeric values
+
+    Returns:
+        Dictionary with keys: mean, min, max, std
+    """
+    if not values:
+        return {"mean": 0, "min": 0, "max": 0, "std": 0}
+
+    return {
+        "mean": statistics.mean(values),
+        "min": min(values),
+        "max": max(values),
+        "std": statistics.stdev(values) if len(values) > 1 else 0,
+    }
+
+
+def is_root_whitelisted(filename: str, config: dict[str, Any]) -> bool:
+    """Check if file is allowed in project root.
+
+    Consolidated from pre_tool__document_management.py and session_end__auto_cleanup.py
+
+    Args:
+        filename: Name of the file
+        config: Configuration dictionary
+
+    Returns:
+        True if file is whitelisted for root directory
+    """
+    whitelist = config.get("document_management", {}).get("root_whitelist", [])
+
+    for pattern in whitelist:
+        # Convert glob pattern to regex
+        regex = pattern.replace("*", ".*").replace("?", ".")
+        if re.match(f"^{regex}$", filename):
+            return True
+
+    return False
+
+
+def get_file_pattern_category(filename: str, config: dict[str, Any]) -> tuple[str, str] | None:
+    """Match filename against patterns to determine category.
+
+    Consolidated from pre_tool__document_management.py and session_end__auto_cleanup.py
+
+    Args:
+        filename: Name of the file to categorize
+        config: Configuration dictionary
+
+    Returns:
+        Tuple of (directory_type, category) or None if no match
+    """
+    patterns = config.get("document_management", {}).get("file_patterns", {})
+
+    for dir_type, categories in patterns.items():
+        for category, pattern_list in categories.items():
+            for pattern in pattern_list:
+                # Convert glob pattern to regex
+                regex = pattern.replace("*", ".*").replace("?", ".")
+                if re.match(f"^{regex}$", filename):
+                    return (dir_type, category)
+
+    return None
+
+
+def suggest_moai_location(filename: str, config: dict[str, Any]) -> str:
+    """Suggest appropriate .moai/ location based on file pattern.
+
+    Consolidated from pre_tool__document_management.py and session_end__auto_cleanup.py
+
+    Args:
+        filename: Name of the file
+        config: Configuration dictionary
+
+    Returns:
+        Suggested .moai/ path
+    """
+    # Try pattern matching first
+    match = get_file_pattern_category(filename, config)
+
+    if match:
+        dir_type, category = match
+        base_dir = config.get("document_management", {}).get("directories", {}).get(dir_type, {}).get("base", "")
+        if base_dir:
+            return f"{base_dir}{category}/"
+
+    # Default fallback suggestions
+    if filename.endswith(".md"):
+        return ".moai/temp/work/"
+    elif filename.endswith((".sh", ".py", ".js")):
+        return ".moai/scripts/dev/"
+    elif filename.endswith((".tmp", ".temp", ".bak")):
+        return ".moai/temp/work/"
+
+    # Ultimate fallback
+    return ".moai/temp/work/"