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

moai_adk/templates/.claude/commands/alfred/1-plan.md

@@ -21,7 +21,7 @@ allowed-tools:
 ---
 
 # 🏗️ MoAI-ADK Step 1: Establish a plan (Plan) - Always make a plan first and then proceed.
-> Interactive prompts rely on `Skill("moai-alfred-interactive-questions")` so AskUserQuestion renders TUI selection menus for user surveys and approvals.
+> **Note**: Interactive prompts use `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` for TUI selection menus. The skill is loaded on-demand when user interaction is required.
 
 ## 🎯 Command Purpose
 
@@ -29,6 +29,22 @@ allowed-tools:
 
 **Plan for**: $ARGUMENTS
 
+## 🤖 CodeRabbit AI Integration (Local Only)
+
+This local environment includes CodeRabbit AI review integration for SPEC documents:
+
+**Automatic workflows:**
+- ✅ SPEC review: CodeRabbit analyzes SPEC metadata and EARS structure
+- ✅ GitHub Issue sync: SPEC files automatically create/update GitHub Issues
+- ✅ Auto-approval: Draft PRs are approved when quality meets standards (80%+)
+- ✅ SPEC quality validation: Checklist for metadata, structure, and content
+
+**Scope:**
+- 🏠 **Local environment**: Full CodeRabbit integration with auto-approval
+- 📦 **Published packages**: Users get GitHub Issue sync only (no CodeRabbit)
+
+> See `.coderabbit.yaml` for detailed review rules and SPEC validation checklist
+
 ## 💡 Planning philosophy: "Always make a plan first and then proceed."
 
 `/alfred:1-plan` is a general-purpose command that **creates a plan**, rather than simply “creating” a SPEC document.
@@ -126,14 +142,28 @@ Invoking the Task tool (Explore agent):
 Call the Task tool:
 - subagent_type: "spec-builder"
 - description: "Analyze the plan and establish a plan"
-- prompt: "Please analyze the project document and suggest SPEC candidates.
- Run in analysis mode, and must include the following:
- 1. In-depth analysis of product/structure/tech.md
- 2. Identify SPEC candidates and Determine priorities
- 3. Design EARS structure
- 4. Wait for user approval
- User input: $ARGUMENTS
- (Optional) Explore results: $EXPLORE_RESULTS"
+- prompt: """You are spec-builder agent.
+
+LANGUAGE CONFIGURATION:
+- conversation_language: {{CONVERSATION_LANGUAGE}}
+- language_name: {{CONVERSATION_LANGUAGE_NAME}}
+
+CRITICAL INSTRUCTION:
+All SPEC documents and analysis must be generated in conversation_language.
+- If conversation_language is 'ko' (Korean): Generate ALL analysis, plans, and SPEC documents in Korean
+- If conversation_language is 'ja' (Japanese): Generate ALL analysis, plans, and SPEC documents in Japanese
+- If conversation_language is other language: Follow the specified language
+
+TASK:
+Please analyze the project document and suggest SPEC candidates.
+Run in analysis mode, and must include the following:
+1. In-depth analysis of product/structure/tech.md
+2. Identify SPEC candidates and Determine priorities
+3. Design EARS structure
+4. Wait for user approval
+
+User input: $ARGUMENTS
+(Optional) Explore results: $EXPLORE_RESULTS"""
 ```
 
 ### Plan analysis progress
@@ -156,7 +186,7 @@ Call the Task tool:
 
 ### User verification steps
 
-After reviewing your implementation plan, Alfred invokes `Skill("moai-alfred-interactive-questions")` to present the following options:
+After reviewing your implementation plan, Alfred invokes `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` to present the following options:
 - **"Go"** or **"Start"**: Start writing the plan as planned
 - **"Modify [Content]"**: Request modifications to the plan
 - **"Stop"**: Stop writing the plan
@@ -165,21 +195,37 @@ After reviewing your implementation plan, Alfred invokes `Skill("moai-alfred-int
 
 ## 🚀 STEP 2: Create plan document (after user approval)
 
-After user approval (collected via `Skill("moai-alfred-interactive-questions")`), call the spec-builder and git-manager agents using the **Task tool**.
+After user approval (collected via `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)`), call the spec-builder and git-manager agents using the **Task tool**.
 
 ### ⚙️ How to call an agent
 
 ```
 1. Call spec-builder (create plan):
    - subagent_type: "spec-builder"
-- description: "Create SPEC document"
- - prompt: "Please fill out the SPEC document according to the plan approved in STEP 1.
- Create a specification for the EARS structure."
+   - description: "Create SPEC document"
+   - prompt: """You are spec-builder agent.
+
+LANGUAGE CONFIGURATION:
+- conversation_language: {{CONVERSATION_LANGUAGE}}
+- language_name: {{CONVERSATION_LANGUAGE_NAME}}
+
+CRITICAL INSTRUCTION:
+ALL SPEC documents MUST be generated in conversation_language:
+- spec.md: Full document in conversation_language
+- plan.md: Full document in conversation_language
+- acceptance.md: Full document in conversation_language
+
+YAML frontmatter and @TAG identifiers MUST remain in English.
+Code examples and technical keywords can be mixed (code in English, narrative in user language).
+
+TASK:
+Please fill out the SPEC document according to the plan approved in STEP 1.
+Create a specification for the EARS structure."""
 
 2. Invoke git-manager (Git task):
    - subagent_type: "git-manager"
-- description: "Create Git branch/PR"
- - prompt: "After completing the plan, please create a branch and Draft PR."
+   - description: "Create Git branch/PR"
+   - prompt: "After completing the plan, please create a branch and Draft PR."
 ```
 
 ## function
@@ -549,6 +595,48 @@ The `git-manager` agent does **all at once** after the SPEC is complete:
 3. **Initial commit**: Commit SPEC document and create tags
 4. **Remote Sync**: Apply synchronization strategy for each mode
 
+### Phase 3.5: CodeRabbit SPEC Review (Local Only)
+
+**After Draft PR is created, CodeRabbit automatically:**
+
+```bash
+echo "🤖 Waiting for CodeRabbit SPEC review..."
+
+# CodeRabbit triggers automatically on Draft PR creation
+# Review includes:
+# - SPEC metadata validation (YAML frontmatter)
+# - EARS structure completeness check
+# - Acceptance criteria quality (Given-When-Then)
+# - @TAG system traceability
+# - Documentation clarity
+
+# Expected time: 1-2 minutes
+for i in {1..12}; do
+    sleep 10
+
+    # Check PR review status
+    approval=$(gh pr view $pr_num --json reviewDecision --jq '.reviewDecision')
+
+    if [ "$approval" = "APPROVED" ]; then
+        echo "✅ CodeRabbit approved SPEC PR!"
+        echo "→ Ready for development with /alfred:2-run SPEC-$spec_id"
+        break
+    fi
+
+    echo "⏳ CodeRabbit reviewing... ($i/12)"
+done
+```
+
+**CodeRabbit review includes:**
+- ✅ YAML frontmatter validation (7 required fields)
+- ✅ HISTORY section structure and completeness
+- ✅ EARS requirements clarity (Ubiquitous/Event/State/Optional/Constraints)
+- ✅ Acceptance criteria quality (Given-When-Then scenarios)
+- ✅ @TAG system compliance (SPEC/TEST/CODE/DOC traceability)
+- ✅ Documentation and formatting
+
+See `.coderabbit.yaml` for detailed SPEC review checklist.
+
 ## Writing Tips
 
 - Information that is not in the product/structure/tech document is supplemented by asking a new question. 

moai_adk/templates/.claude/commands/alfred/2-run.md

@@ -24,7 +24,7 @@ allowed-tools:
 ---
 
 # ⚒️ MoAI-ADK Phase 2: Run the plan - Flexible implementation strategy
-> Interactive prompts rely on `Skill("moai-alfred-interactive-questions")` so AskUserQuestion renders TUI selection menus for user surveys and approvals.
+> **Note**: Interactive prompts use `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` for TUI selection menus. The skill is loaded on-demand when user interaction is required.
 
 ## 🎯 Command Purpose
 
@@ -137,7 +137,7 @@ Task tool call example:
           3. TAG chain design
  4. Step-by-step execution plan
  5. Risks and response plans
-6. Create action plan and use `Skill("moai-alfred-interactive-questions")` to confirm the next action with the user
+6. Create action plan and use `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` to confirm the next action with the user
  (Optional) Explore results: $EXPLORE_RESULTS"
 ```
 
@@ -181,26 +181,38 @@ After reviewing the action plan, select one of the following:
 
 ## 🚀 STEP 2: Execute task (after user approval)
 
-After user approval (gathered through `Skill("moai-alfred-interactive-questions")`), **call the tdd-implementer agent using the Task tool**.
+After user approval (gathered through `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)`), **call the tdd-implementer agent using the Task tool**.
 
 ### ⚙️ How to call an agent
 
 **STEP 2 calls tdd-implementer using the Task tool**:
 
 ```
-Task tool call example:
+Call the Task tool:
 - subagent_type: "tdd-implementer"
-- description: "Execute task"
-- prompt: "Please execute the task according to the plan approved in STEP 1.
- For TDD scenario:
- - Perform RED → GREEN → REFACTOR cycle,
- Perform the following for each TAG:
- 1. RED Phase: Write a test that fails with the @TEST:ID tag
- 2. GREEN Phase: Minimal implementation with the @CODE:ID tag
- 3. REFACTOR Phase: Improve code quality
- 4. Verify TAG completion conditions and proceed to the next TAG
-
-Execute on: $ARGUMENTS"
+- description: "Execute task with TDD implementation"
+- prompt: """You are tdd-implementer agent.
+
+LANGUAGE CONFIGURATION:
+- conversation_language: {{CONVERSATION_LANGUAGE}}
+- language_name: {{CONVERSATION_LANGUAGE_NAME}}
+
+CRITICAL INSTRUCTION:
+Code and technical output MUST be in English.
+Code comments MAY be in {{CONVERSATION_LANGUAGE}} if appropriate.
+Test descriptions and documentation can use {{CONVERSATION_LANGUAGE}}.
+
+TASK: Execute the task according to the plan approved in STEP 1.
+
+For TDD scenario:
+- Perform RED → GREEN → REFACTOR cycle
+- Perform the following for each TAG:
+  1. RED Phase: Write a test that fails with the @TEST:ID tag
+  2. GREEN Phase: Minimal implementation with the @CODE:ID tag
+  3. REFACTOR Phase: Improve code quality
+  4. Verify TAG completion conditions and proceed to the next TAG
+
+Execute on: $ARGUMENTS"""
 ```
 
 ## 🔗 TDD optimization for each language
@@ -254,7 +266,7 @@ The `implementation-planner` agent does the following:
 2. **Library selection**: Check the latest stable version and verify compatibility through WebFetch
 3. **TAG chain design**: Determine TAG order and dependency
 4. **Establishment of implementation strategy**: Step-by-step implementation plan and risk identification
-5. **Create action plan**: Create a structured plan and, via `Skill("moai-alfred-interactive-questions")`, collect user approval before proceeding
+5. **Create action plan**: Create a structured plan and, via `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)`, collect user approval before proceeding
 
 ### Phase 2: Task execution phase (after approval)
 

moai_adk/templates/.claude/commands/alfred/3-sync.md

@@ -5,30 +5,31 @@ description: "Document synchronization + PR Ready conversion"
 # - ko: "문서 동기화 + PR Ready 전환"
 # - ja: "ドキュメント同期 + PR Ready変換"
 # - zh: "文档同步 + PR Ready转换"
-argument-hint: "Mode target path - Mode: auto (default)|force|status|project, target path: Synchronization target path"
+argument-hint: 'Mode target path - Mode: auto (default)|force|status|project, target
+  path: Synchronization target path'
 allowed-tools:
-  - Read
-  - Write
-  - Edit
-  - MultiEdit
-  - Bash(git:*)
-  - Bash(gh:*)
-  - Bash(python3:*)
-  - Task
-  - Grep
-  - Glob
-  - TodoWrite
+- Read
+- Write
+- Edit
+- MultiEdit
+- Bash(git:*)
+- Bash(gh:*)
+- Bash(python3:*)
+- Task
+- Grep
+- Glob
+- TodoWrite
 ---
 
 # 📚 MoAI-ADK Step 3: Document Synchronization (+Optional PR Ready)
-> Interactive prompts rely on `Skill("moai-alfred-interactive-questions")` so AskUserQuestion renders TUI selection menus for user surveys and approvals.
+> **Note**: Interactive prompts use `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` for TUI selection menus. The skill is loaded on-demand when user interaction is required.
 
 ## 🚀 START HERE
 
 **CRITICAL**: Load the TUI Survey Skill FIRST before any user interaction:
 
 ```
-Skill("moai-alfred-interactive-questions")
+AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)
 ```
 
 This Skill MUST be loaded at the very beginning to enable TUI menu rendering for AskUserQuestion calls throughout this workflow.
@@ -44,7 +45,7 @@ Synchronize code changes to Living Documents and verify @TAG system to ensure co
 ## 📋 Execution flow
 
 **Phase 0: Skill Loading** (IMMEDIATE)
-- Load `Skill("moai-alfred-interactive-questions")` at the very start
+- Load `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` at the very start
 - This enables TUI menu rendering for all user interactions
 
 **Phase 1: Analysis & Planning**
@@ -160,10 +161,26 @@ Invoking the Task tool (Explore agent):
 
 2. doc-syncer call (synchronization plan):
    - subagent_type: "doc-syncer"
-- description: "Establish a document synchronization plan"
- - prompt: "Please analyze Git changes and establish a document synchronization plan.
-             $ARGUMENTS
-(Optional) TAG validation results: $TAG_VALIDATION_RESULTS"
+   - description: "Establish a document synchronization plan"
+   - prompt: """You are doc-syncer agent.
+
+LANGUAGE CONFIGURATION:
+- conversation_language: {{CONVERSATION_LANGUAGE}}
+- language_name: {{CONVERSATION_LANGUAGE_NAME}}
+
+CRITICAL INSTRUCTION:
+Documentation updates MUST respect conversation_language:
+- User-facing documentation (README, guides): {{CONVERSATION_LANGUAGE}}
+- SPEC documents (spec.md, plan.md, acceptance.md): {{CONVERSATION_LANGUAGE}}
+- Code comments: {{CONVERSATION_LANGUAGE}} (when not technical keywords)
+- Technical documentation and YAML frontmatter: English
+
+TASK:
+Please analyze Git changes and establish a document synchronization plan.
+Ensure all documentation updates align with the conversation_language setting.
+
+$ARGUMENTS
+(Optional) TAG validation results: $TAG_VALIDATION_RESULTS"""
 ```
 
 ### Synchronization analysis in progress
@@ -226,7 +243,7 @@ To skip pre-verification, use the `/alfred:3-sync --skip-pre-check` option.
 
 ### User verification steps
 
-After reviewing your sync plan, `Skill("moai-alfred-interactive-questions")` presents the following options for user decision:
+After reviewing your sync plan, `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` presents the following options for user decision:
 - **"Proceed"** or **"Start"**: Start synchronization as planned
 - **"Modify [Contents]"**: Request modifications to your sync plan
 - **"Abort"**: Abort the sync operation
@@ -235,7 +252,7 @@ After reviewing your sync plan, `Skill("moai-alfred-interactive-questions")` pre
 
 ## 🚀 STEP 2: Execute document synchronization (after user approval)
 
-After user approval (collected via `Skill("moai-alfred-interactive-questions")`), the doc-syncer agent performs **Living Document synchronization and @TAG updates**, and optionally executes PR Ready transitions only in team mode.
+After user approval (collected via `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)`), the doc-syncer agent performs **Living Document synchronization and @TAG updates**, and optionally executes PR Ready transitions only in team mode.
 
 ### Phase 2 Details: SPEC Completion Processing (Automatic)
 

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

@@ -5,11 +5,44 @@ Project information inquiry (language, Git, SPEC progress, etc.)
 """
 
 import json
+import signal
 import subprocess
+from contextlib import contextmanager
 from pathlib import Path
 from typing import Any
 
 
+class TimeoutError(Exception):
+    """Signal-based timeout exception"""
+    pass
+
+
+@contextmanager
+def timeout_handler(seconds: int):
+    """Hard timeout using SIGALRM (works on Unix systems including macOS)
+
+    This uses kernel-level signal to interrupt ANY blocking operation,
+    even if subprocess.run() timeout fails on macOS.
+
+    Args:
+        seconds: Timeout duration in seconds
+
+    Raises:
+        TimeoutError: If operation exceeds timeout
+    """
+    def _handle_timeout(signum, frame):
+        raise TimeoutError(f"Operation timed out after {seconds} seconds")
+
+    # Set the signal handler
+    old_handler = signal.signal(signal.SIGALRM, _handle_timeout)
+    signal.alarm(seconds)
+    try:
+        yield
+    finally:
+        signal.alarm(0)  # Disable alarm
+        signal.signal(signal.SIGALRM, old_handler)
+
+
 def detect_language(cwd: str) -> str:
     """Detect project language (supports 20 items languages)
 
@@ -89,9 +122,10 @@ def detect_language(cwd: str) -> str:
 
 
 def _run_git_command(args: list[str], cwd: str, timeout: int = 2) -> str:
-    """Git command execution helper function
+    """Git command execution with HARD timeout protection
 
     Safely execute Git commands and return output.
+    Uses SIGALRM (kernel-level interrupt) to handle macOS subprocess timeout bug.
     Eliminates code duplication and provides consistent error handling.
 
     Args:
@@ -103,29 +137,46 @@ def _run_git_command(args: list[str], cwd: str, timeout: int = 2) -> str:
         Git command output (stdout, removing leading and trailing spaces)
 
     Raises:
-        subprocess.TimeoutExpired: Timeout exceeded
+        subprocess.TimeoutExpired: Timeout exceeded (via TimeoutError)
         subprocess.CalledProcessError: Git command failed
 
     Examples:
         >>> _run_git_command(["branch", "--show-current"], ".")
         'main'
+
+    TDD History:
+        - RED: Git command hang scenario test
+        - GREEN: SIGALRM-based timeout implementation
+        - REFACTOR: Exception conversion to subprocess.TimeoutExpired
     """
-    result = subprocess.run(
-        ["git"] + args,
-        cwd=cwd,
-        capture_output=True,
-        text=True,
-        timeout=timeout,
-        check=True,
-    )
-    return result.stdout.strip()
+    try:
+        with timeout_handler(timeout):
+            result = subprocess.run(
+                ["git"] + args,
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                check=False,  # Don't raise on non-zero exit - we'll check manually
+            )
+
+            # Check exit code manually
+            if result.returncode != 0:
+                raise subprocess.CalledProcessError(
+                    result.returncode, ["git"] + args, result.stdout, result.stderr
+                )
+
+            return result.stdout.strip()
+
+    except TimeoutError:
+        # Convert to subprocess.TimeoutExpired for consistent error handling
+        raise subprocess.TimeoutExpired(["git"] + args, timeout)
 
 
 def get_git_info(cwd: str) -> dict[str, Any]:
     """Gather Git repository information
 
     View the current status of a Git repository.
-    Returns the branch name, commit hash, and number of changes.
+    Returns the branch name, commit hash, number of changes, and last commit message.
     If it is not a Git repository, it returns an empty dictionary.
 
     Args:
@@ -136,12 +187,13 @@ def get_git_info(cwd: str) -> dict[str, Any]:
         - branch: Current branch name (str)
         - commit: Current commit hash (str, full hash)
         - changes: Number of changed files (int, staged + unstaged)
+        - last_commit: Last commit message (str, subject only)
 
         Empty dictionary {} if it is not a Git repository or the query fails.
 
     Examples:
         >>> get_git_info("/path/to/git/repo")
-        {'branch': 'main', 'commit': 'abc123...', 'changes': 3}
+        {'branch': 'main', 'commit': 'abc123...', 'changes': 3, 'last_commit': 'Fix bug'}
         >>> get_git_info("/path/to/non-git")
         {}
 
@@ -149,11 +201,13 @@ def get_git_info(cwd: str) -> dict[str, Any]:
         - Timeout: 2 seconds for each Git command
         - Security: Safe execution with subprocess.run(shell=False)
         - Error handling: Returns an empty dictionary in case of all exceptions
+        - Commit message limited to 50 characters for display purposes
 
     TDD History:
         - RED: 3 items scenario test (Git repo, non-Git, error)
         - GREEN: Implementation of subprocess-based Git command execution
         - REFACTOR: Add timeout (2 seconds), strengthen exception handling, remove duplicates with helper function
+        - UPDATE: Added last_commit message field for SessionStart display
     """
     try:
         # Check if it's a git repository
@@ -165,10 +219,16 @@ def get_git_info(cwd: str) -> dict[str, Any]:
         status_output = _run_git_command(["status", "--short"], cwd)
         changes = len([line for line in status_output.splitlines() if line])
 
+        # Get last commit message (subject only, limited to 50 chars)
+        last_commit = _run_git_command(["log", "-1", "--format=%s"], cwd)
+        if len(last_commit) > 50:
+            last_commit = last_commit[:47] + "..."
+
         return {
             "branch": branch,
             "commit": commit,
             "changes": changes,
+            "last_commit": last_commit,
         }
 
     except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
@@ -276,9 +336,81 @@ def get_project_language(cwd: str) -> str:
     return detect_language(cwd)
 
 
+def get_package_version_info() -> dict[str, Any]:
+    """Check MoAI-ADK current and latest version from PyPI
+
+    Compares the installed version with the latest version available on PyPI.
+    Returns version information for SessionStart hook to display update recommendations.
+
+    Returns:
+        dict with keys:
+            - "current": Current installed version
+            - "latest": Latest version available on PyPI
+            - "update_available": Boolean indicating if update is available
+            - "upgrade_command": Recommended upgrade command (if update available)
+
+    Note:
+        - Has 1-second timeout to avoid blocking SessionStart
+        - Returns graceful fallback if PyPI check fails
+        - Handles version parsing gracefully
+    """
+    from importlib.metadata import version, PackageNotFoundError
+    import urllib.request
+    import urllib.error
+
+    result = {
+        "current": "unknown",
+        "latest": "unknown",
+        "update_available": False,
+        "upgrade_command": ""
+    }
+
+    # Get current version
+    try:
+        result["current"] = version("moai-adk")
+    except PackageNotFoundError:
+        result["current"] = "dev"
+        return result
+
+    # Get latest version from PyPI (with 1-second timeout)
+    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")
+    except (urllib.error.URLError, TimeoutError, Exception):
+        # Network error or timeout - return with unknown latest version
+        return result
+
+    # Compare versions (simple comparison)
+    if result["current"] != "unknown" and result["latest"] != "unknown":
+        try:
+            # Parse versions for comparison
+            current_parts = [int(x) for x in result["current"].split(".")]
+            latest_parts = [int(x) for x in result["latest"].split(".")]
+
+            # Pad shorter version with zeros
+            max_len = max(len(current_parts), len(latest_parts))
+            current_parts.extend([0] * (max_len - len(current_parts)))
+            latest_parts.extend([0] * (max_len - len(latest_parts)))
+
+            if latest_parts > current_parts:
+                result["update_available"] = True
+                result["upgrade_command"] = f"uv pip install --upgrade moai-adk>={result['latest']}"
+        except (ValueError, AttributeError):
+            # Version parsing failed - skip comparison
+            pass
+
+    return result
+
+
 __all__ = [
     "detect_language",
     "get_git_info",
     "count_specs",
     "get_project_language",
+    "get_package_version_info",
 ]