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

moai_adk/templates/.claude/commands/alfred/9-feedback.md

@@ -0,0 +1,149 @@
+---
+name: alfred:9-feedback
+description: "Create GitHub issues interactively"
+allowed-tools:
+- Bash(gh:*)
+- Task
+- AskUserQuestion
+---
+
+# 🎯 MoAI-ADK Alfred 9-Feedback: Interactive GitHub Issue Creation
+
+> **Purpose**: Create GitHub Issues through an interactive multi-step dialog. Simple command → guided questions → automatic issue creation.
+
+## 📋 Command Purpose
+
+Enable developers to instantly report bugs, request features, suggest improvements, and ask questions through conversational dialogs. No command arguments needed—just run `/alfred:9-feedback` and answer questions.
+
+**Command Format**:
+```bash
+/alfred:9-feedback
+```
+
+That's it! Alfred guides you through the rest.
+
+---
+
+## 🚀 Interactive Execution Flow
+
+### Step 1: Start Command
+```bash
+/alfred:9-feedback
+```
+
+Alfred responds and proceeds to Step 2.
+
+---
+
+### Step 2: Select Issue Type (AskUserQuestion)
+
+**Question**: "What type of issue do you want to create?"
+
+**Options**:
+```
+[ ] 🐛 Bug Report - Something isn't working
+[ ] ✨ Feature Request - Suggest new functionality
+[ ] ⚡ Improvement - Enhance existing features
+[ ] ❓ Question/Discussion - Ask the team
+```
+
+**User Selection**: Selects one (e.g., 🐛 Bug Report)
+
+---
+
+### Step 3: Enter Issue Title (AskUserQuestion)
+
+**Question**: "What is the issue title? (Be concise)"
+
+**Example Input**:
+```
+Login button on homepage not responding to clicks
+```
+
+---
+
+### Step 4: Enter Description (AskUserQuestion)
+
+**Question**: "Provide a detailed description (optional—press Enter to skip)"
+
+**Example Input**:
+```
+When I click the login button on the homepage, nothing happens.
+Tested on Chrome 120.0 on macOS 14.2.
+Expected: Login modal should appear
+Actual: No response
+```
+
+Or just press Enter to skip.
+
+---
+
+### Step 5: Select Priority (AskUserQuestion)
+
+**Question**: "What's the priority level?"
+
+**Options**:
+```
+[ ] 🔴 Critical - System down, data loss, security breach
+[ ] 🟠 High - Major feature broken, significant impact
+[✓] 🟡 Medium - Normal priority (default)
+[ ] 🟢 Low - Minor issues, nice-to-have
+```
+
+**User Selection**: Selects priority (e.g., 🟠 High)
+
+---
+
+### Step 6: Create Issue (Automatic)
+
+Alfred automatically:
+1. Formats title with emoji: "🐛 [BUG] Login button not responding..."
+2. Prepares body with user description + metadata
+3. Assigns labels: bug, reported, priority-high
+4. Executes: `gh issue create --title ... --body ... --label ...`
+5. Parses issue number from response
+
+**Success Output**:
+```
+✅ GitHub Issue #234 created successfully!
+
+📋 Title: 🐛 [BUG] Login button not responding to clicks
+🔴 Priority: High
+🏷️  Labels: bug, reported, priority-high
+🔗 URL: https://github.com/owner/repo/issues/234
+
+💡 Next: Reference this issue in your commits or link to a SPEC document
+```
+
+---
+
+## ⚠️ Important Rules
+
+### ✅ What to Do
+
+- ✅ Ask all 4 questions in sequence (type → title → description → priority)
+- ✅ Preserve exact user wording in title and description
+- ✅ Use AskUserQuestion for all user inputs
+- ✅ Allow skipping description (optional field)
+- ✅ Show issue URL after creation
+
+### ❌ What NOT to Do
+
+- ❌ Accept command arguments (`/alfred:9-feedback --bug` is wrong—just use `/alfred:9-feedback`)
+- ❌ Skip questions or change order
+- ❌ Rephrase user's input
+- ❌ Create issues without labels
+
+---
+
+## 💡 Key Benefits
+
+1. **🚀 No Arguments Needed**: Just `/alfred:9-feedback`
+2. **💬 Conversational**: Intuitive step-by-step dialog
+3. **🏷️ Auto-labeled**: Labels applied automatically
+4. **🔗 Team Visible**: Issues immediately visible
+5. **⏱️ Fast**: Create issues in 30 seconds
+
+---
+
+**Supported since**: MoAI-ADK v0.7.0+

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

@@ -1,19 +1,81 @@
 #!/usr/bin/env python3
+# @CODE:OFFLINE-001 | SPEC: SPEC-OFFLINE-SUPPORT-001 | TEST: tests/unit/test_network_detection.py
 """Project metadata utilities
 
 Project information inquiry (language, Git, SPEC progress, etc.)
+
+Network detection and caching support:
+- is_network_available(): Check network connectivity with timeout
+- get_package_version_info(): Get package version with offline cache support
 """
 
 import json
 import signal
+import socket
 import subprocess
 from contextlib import contextmanager
 from pathlib import Path
 from typing import Any
 
+# Cache directory for version check results
+CACHE_DIR_NAME = ".moai/cache"
+
+
+def find_project_root(start_path: str | Path = ".") -> Path:
+    """Find MoAI-ADK project root by searching upward for .moai/config.json
+
+    Traverses up the directory tree until it finds .moai/config.json or CLAUDE.md,
+    which indicates the project root. This ensures cache and other files are
+    always created in the correct location, regardless of where hooks execute.
+
+    Args:
+        start_path: Starting directory (default: current directory)
+
+    Returns:
+        Project root Path. If not found, returns start_path as absolute path.
+
+    Examples:
+        >>> find_project_root(".")
+        Path("/Users/user/my-project")
+        >>> find_project_root(".claude/hooks/alfred")
+        Path("/Users/user/my-project")  # Found root 3 levels up
+
+    Notes:
+        - Searches for .moai/config.json first (most reliable)
+        - Falls back to CLAUDE.md if config.json not found
+        - Max depth: 10 levels up (prevent infinite loop)
+        - Returns absolute path for consistency
+
+    TDD History:
+        - RED: 4 test scenarios (root, nested, not found, symlinks)
+        - GREEN: Minimal upward search with .moai/config.json detection
+        - REFACTOR: Add CLAUDE.md fallback, max depth limit, absolute path return
+    """
+    current = Path(start_path).resolve()
+    max_depth = 10  # Prevent infinite loop
+
+    for _ in range(max_depth):
+        # Check for .moai/config.json (primary indicator)
+        if (current / ".moai" / "config.json").exists():
+            return current
+
+        # Check for CLAUDE.md (secondary indicator)
+        if (current / "CLAUDE.md").exists():
+            return current
+
+        # Move up one level
+        parent = current.parent
+        if parent == current:  # Reached filesystem root
+            break
+        current = parent
+
+    # Not found - return start_path as absolute
+    return Path(start_path).resolve()
+
 
 class TimeoutError(Exception):
     """Signal-based timeout exception"""
+
     pass
 
 
@@ -30,6 +92,7 @@ def timeout_handler(seconds: int):
     Raises:
         TimeoutError: If operation exceeds timeout
     """
+
     def _handle_timeout(signum, frame):
         raise TimeoutError(f"Operation timed out after {seconds} seconds")
 
@@ -242,7 +305,7 @@ def count_specs(cwd: str) -> dict[str, int]:
     Counts the number of SPECs with status: completed.
 
     Args:
-        cwd: Project root directory path
+        cwd: Project root directory path (or any subdirectory, will search upward)
 
     Returns:
         SPEC progress dictionary. Includes the following keys:
@@ -260,15 +323,19 @@ def count_specs(cwd: str) -> dict[str, int]:
 
     Notes:
         - SPEC File Location: .moai/specs/SPEC-{ID}/spec.md
-        - Completion condition: Include “status: completed” in YAML front matter
+        - Completion condition: Include "status: completed" in YAML front matter
         - If parsing fails, the SPEC is considered incomplete.
+        - Automatically finds project root to locate .moai/specs/
 
     TDD History:
         - RED: 5 items scenario test (0/0, 2/5, 5/5, no directory, parsing error)
         - GREEN: SPEC search with Path.iterdir(), YAML parsing implementation
         - REFACTOR: Strengthened exception handling, improved percentage calculation safety
+        - UPDATE: Add project root detection for consistent path resolution
     """
-    specs_dir = Path(cwd) / ".moai" / "specs"
+    # Find project root to ensure we read specs from correct location
+    project_root = find_project_root(cwd)
+    specs_dir = project_root / ".moai" / "specs"
 
     if not specs_dir.exists():
         return {"completed": 0, "total": 0, "percentage": 0}
@@ -312,7 +379,7 @@ def get_project_language(cwd: str) -> str:
     """Determine the primary project language (prefers config.json).
 
     Args:
-        cwd: Project root directory.
+        cwd: Project root directory (or any subdirectory, will search upward).
 
     Returns:
         Language string in lower-case.
@@ -320,8 +387,11 @@ def get_project_language(cwd: str) -> str:
     Notes:
         - Reads ``.moai/config.json`` first for a quick answer.
         - Falls back to ``detect_language`` if configuration is missing.
+        - Automatically finds project root to locate .moai/config.json
     """
-    config_path = Path(cwd) / ".moai" / "config.json"
+    # Find project root to ensure we read config from correct location
+    project_root = find_project_root(cwd)
+    config_path = project_root / ".moai" / "config.json"
     if config_path.exists():
         try:
             config = json.loads(config_path.read_text())
@@ -332,15 +402,177 @@ def get_project_language(cwd: str) -> str:
             # Fall back to detection on parse errors
             pass
 
-    # Fall back to the original language detection routine
-    return detect_language(cwd)
+    # Fall back to the original language detection routine (use project root)
+    return detect_language(str(project_root))
+
 
+# @CODE:CONFIG-INTEGRATION-001
+def get_version_check_config(cwd: str) -> dict[str, Any]:
+    """Read version check configuration from .moai/config.json
 
-def get_package_version_info() -> dict[str, Any]:
-    """Check MoAI-ADK current and latest version from PyPI
+    Returns version check settings with sensible defaults.
+    Supports frequency-based cache TTL configuration.
 
-    Compares the installed version with the latest version available on PyPI.
-    Returns version information for SessionStart hook to display update recommendations.
+    Args:
+        cwd: Project root directory path
+
+    Returns:
+        dict with keys:
+            - "enabled": Boolean (default: True)
+            - "frequency": "always" | "daily" | "weekly" | "never" (default: "daily")
+            - "cache_ttl_hours": TTL in hours based on frequency
+
+    Frequency to TTL mapping:
+        - "always": 0 hours (no caching)
+        - "daily": 24 hours
+        - "weekly": 168 hours (7 days)
+        - "never": infinity (never check)
+
+    TDD History:
+        - RED: 8 test scenarios (defaults, custom, disabled, TTL, etc.)
+        - GREEN: Minimal config reading with defaults
+        - REFACTOR: Add validation and error handling
+    """
+    # TTL mapping by frequency
+    ttl_by_frequency = {"always": 0, "daily": 24, "weekly": 168, "never": float("inf")}
+
+    # Default configuration
+    defaults = {"enabled": True, "frequency": "daily", "cache_ttl_hours": 24}
+
+    # Find project root to ensure we read config from correct location
+    project_root = find_project_root(cwd)
+    config_path = project_root / ".moai" / "config.json"
+    if not config_path.exists():
+        return defaults
+
+    try:
+        config = json.loads(config_path.read_text())
+
+        # Extract moai.version_check section
+        moai_config = config.get("moai", {})
+        version_check_config = moai_config.get("version_check", {})
+
+        # Read enabled flag (default: True)
+        enabled = version_check_config.get("enabled", defaults["enabled"])
+
+        # Read frequency (default: "daily")
+        frequency = moai_config.get("update_check_frequency", defaults["frequency"])
+
+        # Validate frequency
+        if frequency not in ttl_by_frequency:
+            frequency = defaults["frequency"]
+
+        # Calculate TTL from frequency
+        cache_ttl_hours = ttl_by_frequency[frequency]
+
+        # Allow explicit cache_ttl_hours override
+        if "cache_ttl_hours" in version_check_config:
+            cache_ttl_hours = version_check_config["cache_ttl_hours"]
+
+        return {"enabled": enabled, "frequency": frequency, "cache_ttl_hours": cache_ttl_hours}
+
+    except (OSError, json.JSONDecodeError, KeyError):
+        # Config read or parse error - return defaults
+        return defaults
+
+
+# @CODE:NETWORK-DETECT-001
+def is_network_available(timeout_seconds: float = 0.1) -> bool:
+    """Quick network availability check using socket.
+
+    Does NOT check PyPI specifically, just basic connectivity.
+    Returns immediately on success (< 50ms typically).
+    Returns False on any error without raising exceptions.
+
+    Args:
+        timeout_seconds: Socket timeout in seconds (default 0.1s)
+
+    Returns:
+        True if network appears available, False otherwise
+
+    Examples:
+        >>> is_network_available()
+        True  # Network is available
+        >>> is_network_available(timeout_seconds=0.001)
+        False  # Timeout too short, returns False
+
+    TDD History:
+        - RED: 3 test scenarios (success, failure, timeout)
+        - GREEN: Minimal socket.create_connection implementation
+        - REFACTOR: Add error handling for all exception types
+    """
+    try:
+        # Try connecting to Google's public DNS server (8.8.8.8:53)
+        # This is a reliable host that's typically reachable
+        connection = socket.create_connection(("8.8.8.8", 53), timeout=timeout_seconds)
+        connection.close()
+        return True
+    except (socket.timeout, OSError, Exception):
+        # Any connection error means network is unavailable
+        # This includes: timeout, connection refused, network unreachable, etc.
+        return False
+
+
+# @CODE:VERSION-DETECT-MAJOR-001
+def is_major_version_change(current: str, latest: str) -> bool:
+    """Detect if version change is a major version bump.
+
+    A major version change is when the first (major) component increases:
+    - 0.8.1 → 1.0.0: True (0 → 1)
+    - 1.2.3 → 2.0.0: True (1 → 2)
+    - 0.8.1 → 0.9.0: False (0 → 0, minor changed)
+    - 1.2.3 → 1.3.0: False (1 → 1)
+
+    Args:
+        current: Current version string (e.g., "0.8.1")
+        latest: Latest version string (e.g., "1.0.0")
+
+    Returns:
+        True if major version increased, False otherwise
+
+    Examples:
+        >>> is_major_version_change("0.8.1", "1.0.0")
+        True
+        >>> is_major_version_change("0.8.1", "0.9.0")
+        False
+        >>> is_major_version_change("dev", "1.0.0")
+        False  # Invalid versions return False
+
+    TDD History:
+        - RED: 4 test scenarios (0→1, 1→2, minor, invalid)
+        - GREEN: Minimal version parsing and comparison
+        - REFACTOR: Improve error handling for invalid versions
+    """
+    try:
+        # Parse version strings into integer components
+        current_parts = [int(x) for x in current.split(".")]
+        latest_parts = [int(x) for x in latest.split(".")]
+
+        # Compare major version (first component)
+        if len(current_parts) >= 1 and len(latest_parts) >= 1:
+            return latest_parts[0] > current_parts[0]
+
+        # If parsing succeeds but empty, no major change
+        return False
+
+    except (ValueError, AttributeError, IndexError):
+        # Invalid version format - return False (no exception)
+        return False
+
+
+# @CODE:VERSION-CACHE-INTEGRATION-001
+def get_package_version_info(cwd: str = ".") -> dict[str, Any]:
+    """Check MoAI-ADK current and latest version with caching and offline support.
+
+    Execution flow:
+    1. Try to load from cache (< 50ms)
+    2. If cache invalid, check network
+    3. If network available, query PyPI
+    4. If network unavailable, return current version only
+    5. Save result to cache for next time
+
+    Args:
+        cwd: Project root directory (for cache location)
 
     Returns:
         dict with keys:
@@ -348,44 +580,128 @@ def get_package_version_info() -> dict[str, Any]:
             - "latest": Latest version available on PyPI
             - "update_available": Boolean indicating if update is available
             - "upgrade_command": Recommended upgrade command (if update available)
+            - "release_notes_url": URL to release notes (Phase 3)
+            - "is_major_update": Boolean indicating major version change (Phase 3)
 
     Note:
-        - Has 1-second timeout to avoid blocking SessionStart
-        - Returns graceful fallback if PyPI check fails
-        - Handles version parsing gracefully
+        - Cache hit (< 24 hours): Returns in ~20ms, no network access
+        - Cache miss + online: Query PyPI (1s timeout), cache result
+        - Cache miss + offline: Return current version only (~100ms)
+        - Offline + cached: Return from cache in ~20ms
+
+    TDD History:
+        - RED: 5 test scenarios (network detection, cache integration, offline mode)
+        - GREEN: Integrate VersionCache with network detection
+        - REFACTOR: Extract cache directory constant, improve error handling
+        - Phase 3: Add release_notes_url and is_major_update fields (@CODE:VERSION-INTEGRATE-FIELDS-001)
     """
-    from importlib.metadata import version, PackageNotFoundError
-    import urllib.request
+    import importlib.util
     import urllib.error
+    import urllib.request
+    from importlib.metadata import PackageNotFoundError, version
 
+    # Import VersionCache from the same directory (using dynamic import for testing compatibility)
+    try:
+        version_cache_path = Path(__file__).parent / "version_cache.py"
+        spec = importlib.util.spec_from_file_location("version_cache", version_cache_path)
+        if spec and spec.loader:
+            version_cache_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(version_cache_module)
+            version_cache_class = version_cache_module.VersionCache
+        else:
+            # Skip caching if module can't be loaded
+            version_cache_class = None
+    except (ImportError, OSError):
+        # Graceful degradation: skip caching on import errors
+        version_cache_class = None
+
+    # 1. Find project root (ensure cache is always in correct location)
+    # This prevents creating .moai/cache in wrong locations when hooks run
+    # from subdirectories like .claude/hooks/alfred/
+    project_root = find_project_root(cwd)
+
+    # 2. Initialize cache (skip if VersionCache couldn't be imported)
+    cache_dir = project_root / CACHE_DIR_NAME
+    version_cache = version_cache_class(cache_dir) if version_cache_class else None
+
+    # 2. Get current installed version first (needed for cache validation)
+    current_version = "unknown"
+    try:
+        current_version = version("moai-adk")
+    except PackageNotFoundError:
+        current_version = "dev"
+        # Dev mode - skip cache and return immediately
+        return {
+            "current": "dev",
+            "latest": "unknown",
+            "update_available": False,
+            "upgrade_command": "",
+        }
+
+    # 3. Try to load from cache (fast path with version validation)
+    if version_cache and version_cache.is_valid():
+        cached_info = version_cache.load()
+        if cached_info:
+            # Only use cache if the cached version matches current installed version
+            # This prevents stale cache when package is upgraded locally
+            if cached_info.get("current") == current_version:
+                # Ensure new fields exist for backward compatibility
+                if "release_notes_url" not in cached_info:
+                    # Add missing fields to old cached data
+                    cached_info.setdefault("release_notes_url", None)
+                    cached_info.setdefault("is_major_update", False)
+                return cached_info
+            # else: cache is stale (version changed), fall through to re-check
+
+    # 4. Cache miss or stale - need to query PyPI
     result = {
-        "current": "unknown",
+        "current": current_version,
         "latest": "unknown",
         "update_available": False,
-        "upgrade_command": ""
+        "upgrade_command": "",
     }
 
-    # Get current version
-    try:
-        result["current"] = version("moai-adk")
-    except PackageNotFoundError:
-        result["current"] = "dev"
+    # 5. Check if version check is enabled in config
+    config = get_version_check_config(cwd)
+    if not config["enabled"]:
+        # Version check disabled - return only current version
+        return result
+
+    # 6. Check network before PyPI query
+    if not is_network_available():
+        # Offline mode - return current version only
         return result
 
-    # Get latest version from PyPI (with 1-second timeout)
+    # 7. Network available - query PyPI
+    pypi_data = None
     try:
         with timeout_handler(1):
             url = "https://pypi.org/pypi/moai-adk/json"
             headers = {"Accept": "application/json"}
             req = urllib.request.Request(url, headers=headers)
             with urllib.request.urlopen(req, timeout=0.8) as response:
-                data = json.load(response)
-                result["latest"] = data.get("info", {}).get("version", "unknown")
+                pypi_data = json.load(response)
+                result["latest"] = pypi_data.get("info", {}).get("version", "unknown")
+
+                # Extract release notes URL from project_urls
+                try:
+                    project_urls = pypi_data.get("info", {}).get("project_urls", {})
+                    release_url = project_urls.get("Changelog", "")
+                    if not release_url:
+                        # Fallback to GitHub releases URL pattern
+                        release_url = (
+                            f"https://github.com/modu-ai/moai-adk/releases/tag/v{result['latest']}"
+                        )
+                    result["release_notes_url"] = release_url
+                except (KeyError, AttributeError, TypeError):
+                    result["release_notes_url"] = None
+
     except (urllib.error.URLError, TimeoutError, Exception):
-        # Network error or timeout - return with unknown latest version
-        return result
+        # PyPI query failed - return current version
+        result["release_notes_url"] = None
+        pass
 
-    # Compare versions (simple comparison)
+    # 7. Compare versions (simple comparison)
     if result["current"] != "unknown" and result["latest"] != "unknown":
         try:
             # Parse versions for comparison
@@ -400,17 +716,33 @@ def get_package_version_info() -> dict[str, Any]:
             if latest_parts > current_parts:
                 result["update_available"] = True
                 result["upgrade_command"] = f"uv pip install --upgrade moai-adk>={result['latest']}"
+
+                # Detect major version change
+                result["is_major_update"] = is_major_version_change(
+                    result["current"], result["latest"]
+                )
+            else:
+                result["is_major_update"] = False
         except (ValueError, AttributeError):
             # Version parsing failed - skip comparison
+            result["is_major_update"] = False
             pass
 
+    # 8. Save result to cache (if caching is available)
+    if version_cache:
+        version_cache.save(result)
+
     return result
 
 
 __all__ = [
+    "find_project_root",
     "detect_language",
     "get_git_info",
     "count_specs",
     "get_project_language",
+    "get_version_check_config",
+    "is_network_available",
+    "is_major_version_change",
     "get_package_version_info",
 ]