moai-adk 0.4.5__py3-none-any.whl → 0.20.1__py3-none-any.whl

moai_adk/core/config/__init__.py

@@ -0,0 +1,19 @@
+"""Configuration management for MoAI-ADK."""
+
+from moai_adk.core.config.migration import (
+    get_conversation_language,
+    get_conversation_language_name,
+    get_report_generation_config,
+    get_spec_git_workflow,
+    migrate_config_schema_v0_17_0,
+    migrate_config_to_nested_structure,
+)
+
+__all__ = [
+    "migrate_config_to_nested_structure",
+    "migrate_config_schema_v0_17_0",
+    "get_conversation_language",
+    "get_conversation_language_name",
+    "get_report_generation_config",
+    "get_spec_git_workflow",
+]

moai_adk/core/config/migration.py

@@ -0,0 +1,235 @@
+# @CODE:LANG-FIX-001:MIGRATION | SPEC: .moai/specs/SPEC-LANG-FIX-001/spec.md
+"""Configuration migration utilities for legacy flat config structure.
+
+Supports migration from legacy flat config.json structure to new nested language structure.
+"""
+
+from typing import Any
+
+
+def migrate_config_to_nested_structure(config: dict[str, Any]) -> dict[str, Any]:
+    """Migrate legacy flat config to nested language structure.
+
+    This function handles the transition from legacy flat config:
+        "conversation_language": "ko"
+        "locale": "ko"
+
+    To new nested structure:
+        "language": {
+            "conversation_language": "ko",
+            "conversation_language_name": "한국어"
+        }
+
+    Args:
+        config: Configuration dictionary that may have legacy structure.
+
+    Returns:
+        Configuration dictionary with nested language structure.
+    """
+    # If config already has nested language structure, return as-is
+    if "language" in config and isinstance(config["language"], dict):
+        return config
+
+    # If config has legacy flat structure, migrate it
+    if "conversation_language" in config and "language" not in config:
+        # Extract conversation language from legacy location
+        conversation_language = config.pop("conversation_language", "en")
+        config.pop("locale", None)  # Remove legacy locale field
+
+        # Map language codes to language names
+        language_names = {
+            "en": "English",
+            "ko": "한국어",
+            "ja": "日本語",
+            "zh": "中文",
+            "es": "Español",
+        }
+
+        language_name = language_names.get(conversation_language, "English")
+
+        # Create new nested language structure
+        config["language"] = {
+            "conversation_language": conversation_language,
+            "conversation_language_name": language_name,
+        }
+
+    return config
+
+
+def get_conversation_language(config: dict[str, Any]) -> str:
+    """Get conversation language from config with fallback handling.
+
+    Handles both legacy flat and new nested config structures.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        Language code (e.g., "ko", "en", "ja").
+    """
+    # First, try to get from nested structure (new format)
+    language_config = config.get("language", {})
+    if isinstance(language_config, dict):
+        result = language_config.get("conversation_language")
+        if result:
+            return result
+
+    # Fall back to legacy flat structure
+    result = config.get("conversation_language")
+    if result:
+        return result
+
+    # Default to English
+    return "en"
+
+
+def get_conversation_language_name(config: dict[str, Any]) -> str:
+    """Get conversation language name from config with fallback handling.
+
+    Handles both legacy flat and new nested config structures.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        Language name (e.g., "한국어", "English").
+    """
+    # First, try to get from nested structure (new format)
+    language_config = config.get("language", {})
+    if isinstance(language_config, dict):
+        result = language_config.get("conversation_language_name")
+        if result:
+            return result
+
+    # If we have the language code, try to map it
+    language_code = get_conversation_language(config)
+    language_names = {
+        "en": "English",
+        "ko": "한국어",
+        "ja": "日本語",
+        "zh": "中文",
+        "es": "Español",
+    }
+    return language_names.get(language_code, "English")
+
+
+def migrate_config_schema_v0_17_0(config: dict[str, Any]) -> dict[str, Any]:
+    """Migrate config schema for v0.16.0 → v0.17.0 (report generation feature).
+
+    Adds new sections:
+    - report_generation: Control automatic report generation
+    - Enhanced github: auto_delete_branches, spec_git_workflow settings
+
+    This function is backward-compatible and safe for existing configs.
+
+    Args:
+        config: Configuration dictionary (may be v0.16.0 or earlier).
+
+    Returns:
+        Configuration dictionary with v0.17.0 schema.
+    """
+    # 1. Add report_generation section if missing (defaults to enabled=true, auto_create=false)
+    if "report_generation" not in config:
+        config["report_generation"] = {
+            "enabled": True,
+            "auto_create": False,
+            "warn_user": True,
+            "user_choice": "Minimal",
+            "configured_at": None,  # Will be set when user configures
+            "allowed_locations": [
+                ".moai/docs/",
+                ".moai/reports/",
+                ".moai/analysis/",
+                ".moai/specs/SPEC-*/",
+            ],
+            "notes": (
+                "Control automatic report generation. 'enabled': turn on/off, "
+                "'auto_create': full (true) vs minimal (false) reports. "
+                "Helps reduce token usage."
+            ),
+        }
+
+    # 2. Enhance github section with new fields
+    if "github" not in config:
+        config["github"] = {}
+
+    github_config = config["github"]
+
+    # Add auto_delete_branches settings if missing
+    if "auto_delete_branches" not in github_config:
+        github_config["auto_delete_branches"] = None
+        github_config["auto_delete_branches_checked"] = False
+        github_config["auto_delete_branches_rationale"] = "Not configured"
+
+    # Add spec_git_workflow settings if missing
+    if "spec_git_workflow" not in github_config:
+        github_config["spec_git_workflow"] = "per_spec"
+        github_config["spec_git_workflow_configured"] = False
+        github_config["spec_git_workflow_rationale"] = (
+            "Ask per SPEC (flexible, user controls each workflow)"
+        )
+
+    # Add notes for new fields if missing
+    if "notes_new_fields" not in github_config:
+        github_config["notes_new_fields"] = (
+            "auto_delete_branches: whether to auto-delete feature branches after merge. "
+            "spec_git_workflow: 'feature_branch' (auto), 'develop_direct' (direct), "
+            "'per_spec' (ask per SPEC)"
+        )
+
+    return config
+
+
+def get_report_generation_config(config: dict[str, Any]) -> dict[str, Any]:
+    """Get report generation configuration with safe defaults.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        Report generation configuration with defaults.
+    """
+    default_config = {
+        "enabled": True,
+        "auto_create": False,
+        "warn_user": True,
+        "user_choice": "Minimal",
+        "configured_at": None,
+        "allowed_locations": [
+            ".moai/docs/",
+            ".moai/reports/",
+            ".moai/analysis/",
+            ".moai/specs/SPEC-*/",
+        ],
+    }
+
+    report_gen = config.get("report_generation", {})
+    if isinstance(report_gen, dict):
+        # Merge with defaults to ensure all keys exist
+        return {**default_config, **report_gen}
+
+    return default_config
+
+
+def get_spec_git_workflow(config: dict[str, Any]) -> str:
+    """Get SPEC git workflow setting with safe default.
+
+    Options:
+    - 'per_spec': Ask per SPEC (flexible, user controls)
+    - 'feature_branch': Auto-create branch for each SPEC
+    - 'develop_direct': Direct commits to develop
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        Workflow setting string.
+    """
+    github_config = config.get("github", {})
+    if isinstance(github_config, dict):
+        workflow = github_config.get("spec_git_workflow")
+        if workflow in ["per_spec", "feature_branch", "develop_direct"]:
+            return workflow
+
+    # Default: per_spec (ask user)
+    return "per_spec"

moai_adk/core/git/__init__.py

@@ -1,4 +1,4 @@
-# @CODE:CORE-GIT-001 | SPEC: SPEC-CORE-GIT-001.md | TEST: tests/unit/test_git.py
+# @CODE:CORE-GIT-INIT-001 | SPEC: SPEC-CORE-GIT-001.md | TEST: tests/unit/test_git.py
 """
 Git management module.
 

moai_adk/core/git/branch.py

@@ -1,4 +1,4 @@
-# @CODE:CORE-GIT-001 | SPEC: SPEC-CORE-GIT-001/spec.md | TEST: tests/unit/test_git.py
+# @CODE:CORE-GIT-BRANCH-001 | SPEC: SPEC-CORE-GIT-001/spec.md | TEST: tests/unit/test_git.py
 """
 Branch naming utilities.
 

moai_adk/core/git/commit.py

@@ -1,4 +1,4 @@
-# @CODE:CORE-GIT-001 | SPEC: SPEC-CORE-GIT-001.md | TEST: tests/unit/test_git.py
+# @CODE:CORE-GIT-COMMIT-001 | SPEC: SPEC-CORE-GIT-001.md | TEST: tests/unit/test_git.py
 """
 Commit message formatting utilities.
 

moai_adk/core/git/manager.py

@@ -1,4 +1,4 @@
-# @CODE:CORE-GIT-001 | SPEC: SPEC-CORE-GIT-001/spec.md | TEST: tests/unit/test_git.py
+# @CODE:CORE-GIT-MANAGER-001 | SPEC: SPEC-CORE-GIT-001/spec.md | TEST: tests/unit/test_git.py
 """
 Git repository management built on GitPython.
 

moai_adk/core/issue_creator.py

@@ -0,0 +1,313 @@
+"""
+GitHub Issue Creator for MoAI-ADK quick issue reporting.
+
+Enables users to quickly create GitHub Issues with standardized templates
+using `/alfred:9-feedback` interactive dialog.
+
+@TAG:ISSUE-CREATOR-001 - GitHub issue creation system
+@TAG:QUICK-REPORTING-001 - Quick issue reporting functionality
+"""
+
+import subprocess
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class IssueType(Enum):
+    """Supported GitHub issue types."""
+    BUG = "bug"
+    FEATURE = "feature"
+    IMPROVEMENT = "improvement"
+    QUESTION = "question"
+
+
+class IssuePriority(Enum):
+    """Issue priority levels."""
+    CRITICAL = "critical"
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+
+
+@dataclass
+class IssueConfig:
+    """Configuration for issue creation."""
+    issue_type: IssueType
+    title: str
+    description: str
+    priority: IssuePriority = IssuePriority.MEDIUM
+    category: Optional[str] = None
+    assignees: Optional[List[str]] = None
+    custom_labels: Optional[List[str]] = None
+
+
+class GitHubIssueCreator:
+    """
+    Creates GitHub Issues using the `gh` CLI.
+
+    Supports:
+    - Multiple issue types (bug, feature, improvement, question)
+    - Priority levels and categories
+    - Standard templates for each type
+    - Label automation
+    - Priority emoji indicators
+    """
+
+    # Label mapping for issue types
+    LABEL_MAP = {
+        IssueType.BUG: ["bug", "reported"],
+        IssueType.FEATURE: ["feature-request", "enhancement"],
+        IssueType.IMPROVEMENT: ["improvement", "enhancement"],
+        IssueType.QUESTION: ["question", "help wanted"],  # Fixed: "help-wanted" → "help wanted" (GitHub standard)
+    }
+
+    # Priority emoji
+    PRIORITY_EMOJI = {
+        IssuePriority.CRITICAL: "🔴",
+        IssuePriority.HIGH: "🟠",
+        IssuePriority.MEDIUM: "🟡",
+        IssuePriority.LOW: "🟢",
+    }
+
+    # Issue type emoji
+    TYPE_EMOJI = {
+        IssueType.BUG: "🐛",
+        IssueType.FEATURE: "✨",
+        IssueType.IMPROVEMENT: "⚡",
+        IssueType.QUESTION: "❓",
+    }
+
+    def __init__(self, github_token: Optional[str] = None):
+        """
+        Initialize the GitHub Issue Creator.
+
+        Args:
+            github_token: GitHub API token. If not provided, uses GITHUB_TOKEN env var.
+        """
+        self.github_token = github_token
+        self._check_gh_cli()
+
+    def _check_gh_cli(self) -> None:
+        """
+        Check if `gh` CLI is installed and accessible.
+
+        Raises:
+            RuntimeError: If `gh` CLI is not found or not authenticated.
+        """
+        try:
+            result = subprocess.run(
+                ["gh", "auth", "status"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode != 0:
+                raise RuntimeError(
+                    "GitHub CLI (gh) is not authenticated. "
+                    "Run `gh auth login` to authenticate."
+                )
+        except FileNotFoundError:
+            raise RuntimeError(
+                "GitHub CLI (gh) is not installed. "
+                "Please install it: https://cli.github.com"
+            )
+
+    def create_issue(self, config: IssueConfig) -> Dict[str, Any]:
+        """
+        Create a GitHub issue with the given configuration.
+
+        Args:
+            config: Issue configuration
+
+        Returns:
+            Dictionary containing issue creation result:
+            {
+                "success": bool,
+                "issue_number": int,
+                "issue_url": str,
+                "message": str
+            }
+
+        Raises:
+            RuntimeError: If issue creation fails
+        """
+        # Build title with emoji and priority
+        emoji = self.TYPE_EMOJI.get(config.issue_type, "📋")
+        priority_emoji = self.PRIORITY_EMOJI.get(config.priority, "")
+        full_title = f"{emoji} [{config.issue_type.value.upper()}] {config.title}"
+        if priority_emoji:
+            full_title = f"{priority_emoji} {full_title}"
+
+        # Build body with template
+        body = self._build_body(config)
+
+        # Collect labels
+        labels = self.LABEL_MAP.get(config.issue_type, []).copy()
+        if config.priority:
+            labels.append(config.priority.value)  # Fixed: removed "priority-" prefix (use direct label names)
+        if config.category:
+            labels.append(f"category-{config.category.lower().replace(' ', '-')}")
+        if config.custom_labels:
+            labels.extend(config.custom_labels)
+
+        # Build gh command
+        gh_command = [
+            "gh", "issue", "create",
+            "--title", full_title,
+            "--body", body,
+        ]
+
+        # Add labels
+        if labels:
+            gh_command.extend(["--label", ",".join(set(labels))])
+
+        # Add assignees if provided
+        if config.assignees:
+            gh_command.extend(["--assignee", ",".join(config.assignees)])
+
+        try:
+            result = subprocess.run(
+                gh_command,
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+
+            if result.returncode != 0:
+                error_msg = result.stderr or result.stdout
+                raise RuntimeError(f"Failed to create GitHub issue: {error_msg}")
+
+            # Parse issue URL from output
+            issue_url = result.stdout.strip()
+            issue_number = self._extract_issue_number(issue_url)
+
+            return {
+                "success": True,
+                "issue_number": issue_number,
+                "issue_url": issue_url,
+                "message": f"✅ GitHub Issue #{issue_number} created successfully",
+                "title": full_title,
+                "labels": labels,
+            }
+
+        except subprocess.TimeoutExpired:
+            raise RuntimeError("GitHub issue creation timed out")
+        except Exception as e:
+            raise RuntimeError(f"Error creating GitHub issue: {e}")
+
+    def _build_body(self, config: IssueConfig) -> str:
+        """
+        Build the issue body based on issue type.
+
+        Args:
+            config: Issue configuration
+
+        Returns:
+            Formatted issue body
+        """
+        body = config.description
+
+        # Add metadata footer
+        footer = "\n\n---\n\n"
+        footer += f"**Type**: {config.issue_type.value}  \n"
+        footer += f"**Priority**: {config.priority.value}  \n"
+        if config.category:
+            footer += f"**Category**: {config.category}  \n"
+        footer += "**Created via**: `/alfred:9-feedback`"
+
+        return body + footer
+
+    @staticmethod
+    def _extract_issue_number(url: str) -> int:
+        """
+        Extract issue number from GitHub URL.
+
+        Args:
+            url: GitHub issue URL
+
+        Returns:
+            Issue number
+
+        Raises:
+            ValueError: If unable to extract issue number
+        """
+        try:
+            # URL format: https://github.com/owner/repo/issues/123
+            return int(url.strip().split("/")[-1])
+        except (ValueError, IndexError):
+            raise ValueError(f"Unable to extract issue number from URL: {url}")
+
+    def format_result(self, result: Dict[str, Any]) -> str:
+        """
+        Format the issue creation result for display.
+
+        Args:
+            result: Issue creation result
+
+        Returns:
+            Formatted result string
+        """
+        if result["success"]:
+            output = f"{result['message']}\n"
+            output += f"📋 Title: {result['title']}\n"
+            output += f"🔗 URL: {result['issue_url']}\n"
+            if result.get("labels"):
+                output += f"🏷️  Labels: {', '.join(result['labels'])}\n"
+            return output
+        else:
+            return f"❌ Failed to create issue: {result.get('message', 'Unknown error')}"
+
+
+class IssueCreatorFactory:
+    """
+    Factory for creating issue creators with predefined configurations.
+    """
+
+    @staticmethod
+    def create_bug_issue(title: str, description: str, priority: IssuePriority = IssuePriority.HIGH) -> IssueConfig:
+        """Create a bug report issue configuration."""
+        return IssueConfig(
+            issue_type=IssueType.BUG,
+            title=title,
+            description=description,
+            priority=priority,
+            category="Bug Report",
+        )
+
+    @staticmethod
+    def create_feature_issue(
+        title: str, description: str, priority: IssuePriority = IssuePriority.MEDIUM
+    ) -> IssueConfig:
+        """Create a feature request issue configuration."""
+        return IssueConfig(
+            issue_type=IssueType.FEATURE,
+            title=title,
+            description=description,
+            priority=priority,
+            category="Feature Request",
+        )
+
+    @staticmethod
+    def create_improvement_issue(
+        title: str, description: str, priority: IssuePriority = IssuePriority.MEDIUM
+    ) -> IssueConfig:
+        """Create an improvement issue configuration."""
+        return IssueConfig(
+            issue_type=IssueType.IMPROVEMENT,
+            title=title,
+            description=description,
+            priority=priority,
+            category="Improvement",
+        )
+
+    @staticmethod
+    def create_question_issue(title: str, description: str, priority: IssuePriority = IssuePriority.LOW) -> IssueConfig:
+        """Create a question/discussion issue configuration."""
+        return IssueConfig(
+            issue_type=IssueType.QUESTION,
+            title=title,
+            description=description,
+            priority=priority,
+            category="Question",
+        )

moai_adk/core/mcp/setup.py

@@ -0,0 +1,56 @@
+# MCP Setup - Simplified version for automatic template copying
+
+import json
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+class MCPSetupManager:
+    """Simplified MCP Setup Manager - copies template configuration"""
+
+    def __init__(self, project_path: Path):
+        self.project_path = project_path
+
+    def copy_template_mcp_config(self) -> bool:
+        """Copy MCP configuration from package template"""
+        try:
+            # Get the package template path
+            import moai_adk
+            package_path = Path(moai_adk.__file__).parent
+            template_mcp_path = package_path / "templates" / ".mcp.json"
+
+            if template_mcp_path.exists():
+                # Copy template to project
+                project_mcp_path = self.project_path / ".mcp.json"
+
+                # Read template
+                with open(template_mcp_path, 'r') as f:
+                    mcp_config = json.load(f)
+
+                # Write to project
+                with open(project_mcp_path, 'w') as f:
+                    json.dump(mcp_config, f, indent=2)
+
+                server_names = list(mcp_config.get('mcpServers', {}).keys())
+                console.print("✅ MCP configuration copied from template")
+                console.print(f"📋 Configured servers: {', '.join(server_names)}")
+                return True
+            else:
+                console.print("❌ Template MCP configuration not found")
+                return False
+
+        except Exception as e:
+            console.print(f"❌ Failed to copy MCP configuration: {e}")
+            return False
+
+    def setup_mcp_servers(self, selected_servers: list[str]) -> bool:
+        """Complete MCP server setup process - simplified template copy"""
+        if not selected_servers:
+            console.print("ℹ️  No MCP servers selected")
+            return True
+
+        console.print("🔧 Setting up MCP servers...")
+        return self.copy_template_mcp_config()