moai-adk 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

moai_adk/core/issue_creator.py

@@ -59,7 +59,7 @@ class GitHubIssueCreator:
         IssueType.BUG: ["bug", "reported"],
         IssueType.FEATURE: ["feature-request", "enhancement"],
         IssueType.IMPROVEMENT: ["improvement", "enhancement"],
-        IssueType.QUESTION: ["question", "help-wanted"],
+        IssueType.QUESTION: ["question", "help wanted"],  # Fixed: "help-wanted" → "help wanted" (GitHub standard)
     }
 
     # Priority emoji
@@ -145,7 +145,7 @@ class GitHubIssueCreator:
         # Collect labels
         labels = self.LABEL_MAP.get(config.issue_type, []).copy()
         if config.priority:
-            labels.append(f"priority-{config.priority.value}")
+            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:

moai_adk/core/project/detector.py

@@ -16,7 +16,18 @@ class LanguageDetector:
     """
 
     LANGUAGE_PATTERNS = {
-        # Ruby moved to top for priority (Rails detection over generic frameworks)
+        # @CODE:LDE-PRIORITY-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+        # Priority order (highest to lowest):
+        # 1. Rust, 2. Dart, 3. Swift, 4. Kotlin, 5. C#, 6. Java, 7. Ruby, 8. PHP
+        # 9. Go, 10. Python, 11. TypeScript, 12. JavaScript, 13. C++, 14. C, 15. Shell
+
+        "rust": ["*.rs", "Cargo.toml"],
+        "dart": ["*.dart", "pubspec.yaml"],
+        "swift": ["*.swift", "Package.swift"],
+        "kotlin": ["*.kt", "build.gradle.kts"],
+        "csharp": ["*.cs", "*.csproj"],
+        "java": ["*.java", "pom.xml", "build.gradle"],
+        # Ruby moved for priority (Rails detection)
         # @CODE:LANG-DETECT-RUBY-001 | SPEC: Issue #51 Language Detection Fix
         "ruby": [
             "*.rb",
@@ -26,7 +37,7 @@ class LanguageDetector:
             "app/controllers/",       # Rails: controller directory
             "Rakefile"                # Rails/Ruby: task file
         ],
-        # PHP moved to second for priority (Laravel detection after Rails)
+        # PHP after Ruby (Laravel detection)
         "php": [
             "*.php",
             "composer.json",
@@ -34,23 +45,18 @@ class LanguageDetector:
             "app/",                   # Laravel: application directory
             "bootstrap/laravel.php"   # Laravel: bootstrap file
         ],
+        "go": ["*.go", "go.mod"],
         "python": ["*.py", "pyproject.toml", "requirements.txt", "setup.py"],
         "typescript": ["*.ts", "tsconfig.json"],
         "javascript": ["*.js", "package.json"],
-        "java": ["*.java", "pom.xml", "build.gradle"],
-        "go": ["*.go", "go.mod"],
-        "rust": ["*.rs", "Cargo.toml"],
-        "dart": ["*.dart", "pubspec.yaml"],
-        "swift": ["*.swift", "Package.swift"],
-        "kotlin": ["*.kt", "build.gradle.kts"],
-        "csharp": ["*.cs", "*.csproj"],
+        "cpp": ["*.cpp", "CMakeLists.txt"],
+        "c": ["*.c", "Makefile"],
+        "shell": ["*.sh", "*.bash"],
+        # Additional languages (lower priority)
         "elixir": ["*.ex", "mix.exs"],
         "scala": ["*.scala", "build.sbt"],
         "clojure": ["*.clj", "project.clj"],
         "haskell": ["*.hs", "*.cabal"],
-        "c": ["*.c", "Makefile"],
-        "cpp": ["*.cpp", "CMakeLists.txt"],
-        "shell": ["*.sh", "*.bash"],
         "lua": ["*.lua"],
     }
 
@@ -112,6 +118,183 @@ class LanguageDetector:
 
         return False
 
+    def get_workflow_template_path(self, language: str) -> str:
+        """Get the GitHub Actions workflow template path for a language.
+
+        @CODE:LDE-WORKFLOW-PATH-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+
+        Args:
+            language: Programming language name (lowercase).
+
+        Returns:
+            Workflow template file path relative to templates directory.
+
+        Raises:
+            ValueError: If language is not supported for workflows.
+        """
+        workflow_mapping = {
+            "python": ".github/workflows/python-tag-validation.yml",
+            "javascript": ".github/workflows/javascript-tag-validation.yml",
+            "typescript": ".github/workflows/typescript-tag-validation.yml",
+            "go": ".github/workflows/go-tag-validation.yml",
+            "ruby": ".github/workflows/ruby-tag-validation.yml",
+            "php": ".github/workflows/php-tag-validation.yml",
+            "java": ".github/workflows/java-tag-validation.yml",
+            "rust": ".github/workflows/rust-tag-validation.yml",
+            "dart": ".github/workflows/dart-tag-validation.yml",
+            "swift": ".github/workflows/swift-tag-validation.yml",
+            "kotlin": ".github/workflows/kotlin-tag-validation.yml",
+            "csharp": ".github/workflows/csharp-tag-validation.yml",
+            "c": ".github/workflows/c-tag-validation.yml",
+            "cpp": ".github/workflows/cpp-tag-validation.yml",
+            "shell": ".github/workflows/shell-tag-validation.yml",
+        }
+
+        if language.lower() not in workflow_mapping:
+            raise ValueError(
+                f"No workflow template available for language: {language}. "
+                f"Supported languages: {', '.join(workflow_mapping.keys())}"
+            )
+
+        return workflow_mapping[language.lower()]
+
+    def detect_package_manager(self, path: str | Path = ".") -> str | None:
+        """Detect the package manager for the detected language.
+
+        @CODE:LDE-PKG-MGR-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+
+        Args:
+            path: Directory to inspect.
+
+        Returns:
+            Package manager name or None if not detected.
+        """
+        path = Path(path)
+
+        # Ruby
+        if (path / "Gemfile").exists():
+            return "bundle"
+
+        # PHP
+        if (path / "composer.json").exists():
+            return "composer"
+
+        # Java/Kotlin
+        if (path / "pom.xml").exists():
+            return "maven"
+        if (path / "build.gradle").exists() or (path / "build.gradle.kts").exists():
+            return "gradle"
+
+        # Rust
+        if (path / "Cargo.toml").exists():
+            return "cargo"
+
+        # Dart/Flutter
+        if (path / "pubspec.yaml").exists():
+            return "dart_pub"
+
+        # Swift
+        if (path / "Package.swift").exists():
+            return "spm"
+
+        # C#
+        if list(path.glob("*.csproj")) or list(path.glob("*.sln")):
+            return "dotnet"
+
+        # Python
+        if (path / "pyproject.toml").exists():
+            return "pip"
+
+        # JavaScript/TypeScript (check in priority order)
+        if (path / "package.json").exists():
+            # Check for package managers in priority order
+            if (path / "bun.lockb").exists():
+                return "bun"
+            elif (path / "pnpm-lock.yaml").exists():
+                return "pnpm"
+            elif (path / "yarn.lock").exists():
+                return "yarn"
+            elif (path / "package-lock.json").exists():
+                return "npm"
+            else:
+                # Default to npm for package.json without lock files
+                return "npm"
+
+        # Go
+        if (path / "go.mod").exists():
+            return "go_modules"
+
+        return None
+
+    def detect_build_tool(self, path: str | Path = ".", language: str | None = None) -> str | None:
+        """Detect the build tool for the detected language.
+
+        @CODE:LDE-BUILD-TOOL-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+
+        Args:
+            path: Directory to inspect.
+            language: Optional language hint for disambiguation.
+
+        Returns:
+            Build tool name or None if not detected.
+        """
+        path = Path(path)
+
+        # C/C++
+        if (path / "CMakeLists.txt").exists():
+            return "cmake"
+        if (path / "Makefile").exists():
+            return "make"
+
+        # Java/Kotlin
+        if language in ["java", "kotlin"]:
+            if (path / "pom.xml").exists():
+                return "maven"
+            if (path / "build.gradle").exists() or (path / "build.gradle.kts").exists():
+                return "gradle"
+
+        # Rust
+        if (path / "Cargo.toml").exists():
+            return "cargo"
+
+        # Swift
+        if (path / "Package.swift").exists():
+            return "spm"
+        if list(path.glob("*.xcodeproj")) or list(path.glob("*.xcworkspace")):
+            return "xcode"
+
+        # C#
+        if list(path.glob("*.csproj")) or list(path.glob("*.sln")):
+            return "dotnet"
+
+        return None
+
+    def get_supported_languages_for_workflows(self) -> list[str]:
+        """Get the list of languages with dedicated CI/CD workflow support.
+
+        @CODE:LDE-SUPPORTED-LANGS-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+
+        Returns:
+            List of supported language names (15 total).
+        """
+        return [
+            "python",
+            "javascript",
+            "typescript",
+            "go",
+            "ruby",
+            "php",
+            "java",
+            "rust",
+            "dart",
+            "swift",
+            "kotlin",
+            "csharp",
+            "c",
+            "cpp",
+            "shell",
+        ]
+
 
 def detect_project_language(path: str | Path = ".") -> str | None:
     """Detect the project language (helper).

moai_adk/core/tags/ci_validator.py

@@ -290,7 +290,7 @@ class CIValidator(PreCommitValidator):
                 tag = error.tag
                 message = error.message
                 locations = ', '.join([
-                    f"`{f}:{l}`" for f, l in error.locations[:3]
+                    f"`{f}:{line}`" for f, line in error.locations[:3]
                 ])
                 if len(error.locations) > 3:
                     locations += f" (+{len(error.locations) - 3} more)"

moai_adk/core/tags/pre_commit_validator.py

@@ -26,7 +26,7 @@ class ValidationError:
     locations: List[Tuple[str, int]] = field(default_factory=list)
 
     def __str__(self) -> str:
-        loc_str = ", ".join([f"{f}:{l}" for f, l in self.locations])
+        loc_str = ", ".join([f"{f}:{line}" for f, line in self.locations])
         return f"{self.message}: {self.tag} at {loc_str}"
 
 

moai_adk/core/tags/validator.py

@@ -85,7 +85,7 @@ class ValidationIssue:
             "tag": self.tag,
             "message": self.message,
             "locations": [
-                {"file": f, "line": l} for f, l in self.locations
+                {"file": f, "line": line} for f, line in self.locations
             ],
             "suggestion": self.suggestion
         }

moai_adk/templates/.claude/agents/alfred/cc-manager.md

@@ -0,0 +1,316 @@
+---
+name: cc-manager
+description: "Use when: When you need to create and optimize Claude Code command/agent/configuration files"
+tools: Read, Write, Edit, MultiEdit, Glob, Bash, WebFetch
+model: sonnet
+---
+
+# Claude Code Manager - Control Tower (v3.0.0)
+> Operational orchestration agent for Claude Code standardization. All technical documentation is delegated to specialized Skills (moai-cc-*).
+
+**Primary Role**: Validate, create, and maintain Claude Code files with consistent standards. Delegate knowledge to Skills.
+
+---
+
+## 🔗 Knowledge Delegation (Critical: v3.0.0)
+
+**As of v3.0.0, all Claude Code knowledge is in specialized Skills:**
+
+| Request | Route To |
+|---------|----------|
+| Architecture decisions | `Skill("moai-cc-guide")` + workflows/ |
+| Hooks setup | `Skill("moai-cc-hooks")` |
+| Agent creation | `Skill("moai-cc-agents")` |
+| Command design | `Skill("moai-cc-commands")` |
+| Skill building | `Skill("moai-cc-skills")` |
+| settings.json config | `Skill("moai-cc-settings")` |
+| MCP/Plugin setup | `Skill("moai-cc-mcp-plugins")` |
+| CLAUDE.md authoring | `Skill("moai-cc-claude-md")` |
+| Memory optimization | `Skill("moai-cc-memory")` |
+
+**cc-manager's job**: Validate, create files, run verifications. NOT teach or explain.
+
+---
+
+## 🌍 Language Handling
+
+**IMPORTANT**: You will receive prompts in the user's **configured conversation_language**.
+
+Alfred passes the user's language directly to you via `Task()` calls.
+
+**Language Guidelines**:
+
+1. **Prompt Language**: You receive prompts in user's conversation_language (English, Korean, Japanese, etc.)
+
+2. **Output Language**: Generate configuration guides and validation reports in user's conversation_language
+
+3. **Always in English** (regardless of conversation_language):
+   - Claude Code configuration files (.md, .json, YAML - technical infrastructure)
+   - Skill names in invocations: `Skill("moai-cc-agents")`
+   - File paths and directory names
+   - YAML keys and JSON configuration structure
+
+4. **Explicit Skill Invocation**:
+   - Always use explicit syntax: `Skill("skill-name")`
+   - Do NOT rely on keyword matching or auto-triggering
+   - Skill names are always English
+
+**Example**:
+- You receive (Korean): "새 에이전트를 만들어주세요"
+- You invoke: Skill("moai-cc-agents"), Skill("moai-cc-guide")
+- You generate English agent.md file (technical infrastructure)
+- You provide Korean guidance and validation reports to user
+
+---
+
+## 🧰 Skill Activation
+
+**Automatic** (always load):
+- `Skill("moai-foundation-specs")` - SPEC structure validation
+- `Skill("moai-cc-guide")` - Decision trees & architecture
+
+**Conditional** (based on request):
+- `Skill("moai-alfred-language-detection")` - Detect project language
+- `Skill("moai-alfred-tag-scanning")` - Validate TAG chains
+- `Skill("moai-foundation-tags")` - TAG policy
+- `Skill("moai-foundation-trust")` - TRUST 5 validation
+- `Skill("moai-alfred-git-workflow")` - Git strategy impact
+- Domain skills (CLI/Data Science/Database/etc) - When relevant
+- Language skills (23 available) - Based on detected language
+- `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` - User clarification
+
+---
+
+## 🎯 Core Responsibilities
+
+✅ **cc-manager DOES**:
+- Validate YAML frontmatter & file structure
+- Check naming conventions (kebab-case, ID patterns)
+- Enforce minimum permissions (principle of least privilege)
+- Create files from templates
+- Run batch verification across `.claude/` directory
+- Suggest specific, actionable fixes
+- Maintain version tracking & standards documentation
+
+❌ **cc-manager DOES NOT**:
+- Explain Hooks/Agents/Commands syntax (→ Skills)
+- Teach Claude Code best practices (→ Skills)
+- Make architecture decisions (→ moai-cc-guide Skill)
+- Provide troubleshooting guides (→ Skills)
+- Document MCP configuration (→ moai-cc-mcp-plugins Skill)
+
+---
+
+## 📋 Standard Templates
+
+### Command File Structure
+
+**Location**: `.claude/commands/`
+
+**Required YAML**:
+- `name` (kebab-case)
+- `description` (one-line)
+- `argument-hint` (array)
+- `tools` (list, min privileges)
+- `model` (haiku/sonnet)
+
+**Reference**: `Skill("moai-cc-commands")` SKILL.md
+
+---
+
+### Agent File Structure
+
+**Location**: `.claude/agents/`
+
+**Required YAML**:
+- `name` (kebab-case)
+- `description` (must include "Use PROACTIVELY for")
+- `tools` (min privileges, no `Bash(*)`)
+- `model` (sonnet/haiku)
+
+**Key Rule**: description includes "Use PROACTIVELY for [trigger conditions]"
+
+**Reference**: `Skill("moai-cc-agents")` SKILL.md
+
+---
+
+### Skill File Structure
+
+**Location**: `.claude/skills/`
+
+**Required YAML**:
+- `name` (kebab-case)
+- `description` (clear one-line)
+- `model` (haiku/sonnet)
+
+**Structure**:
+- SKILL.md (main content)
+- reference.md (optional, detailed docs)
+- examples.md (optional, code examples)
+
+**Reference**: `Skill("moai-cc-skills")` SKILL.md
+
+---
+
+## 🔍 Verification Checklist (Quick)
+
+### All Files
+- [ ] YAML frontmatter valid & complete
+- [ ] Kebab-case naming (my-agent, my-command, my-skill)
+- [ ] No hardcoded secrets/tokens
+
+### Commands
+- [ ] `description` is one-line, clear purpose
+- [ ] `tools` has minimum required only
+- [ ] Agent orchestration documented
+
+### Agents
+- [ ] `description` includes "Use PROACTIVELY for"
+- [ ] `tools` specific patterns (not `Bash(*)`)
+- [ ] Proactive triggers clearly defined
+
+### Skills
+- [ ] Supporting files (reference.md, examples.md) included if relevant
+- [ ] Progressive Disclosure structure
+- [ ] "Works Well With" section added
+
+### settings.json
+- [ ] No syntax errors: `cat .claude/settings.json | jq .`
+- [ ] permissions section complete
+- [ ] Dangerous tools denied (rm -rf, sudo, etc)
+- [ ] No `.env` readable
+
+---
+
+## 🚀 Quick Workflows
+
+### Create New Command
+```bash
+@agent-cc-manager "Create command: /my-command
+- Purpose: [describe]
+- Arguments: [list]
+- Agents involved: [names]"
+```
+**Then**: Reference `Skill("moai-cc-commands")` for detailed guidance
+
+### Create New Agent
+```bash
+@agent-cc-manager "Create agent: my-analyzer
+- Specialty: [describe]
+- Proactive triggers: [when to use]
+- Tool requirements: [what it needs]"
+```
+**Then**: Reference `Skill("moai-cc-agents")` for patterns
+
+### Verify All Standards
+```bash
+@agent-cc-manager "Run full standards verification across .claude/"
+```
+**Result**: Report of violations + fixes
+
+### Setup Project Claude Code
+```bash
+@agent-cc-manager "Initialize Claude Code for MoAI-ADK project"
+```
+**Then**: Reference `Skill("moai-cc-guide")` → workflows/alfred-0-project-setup.md
+
+---
+
+## 🔧 Common Issues (Quick Fixes)
+
+**YAML syntax error**
+→ Validate: `head -5 .claude/agents/my-agent.md`
+
+**Tool permission denied**
+→ Check: `cat .claude/settings.json | jq '.permissions'`
+
+**Agent not recognized**
+→ Verify: YAML frontmatter + kebab-case name + file in `.claude/agents/`
+
+**Skill not loading**
+→ Verify: YAML + `ls -la .claude/skills/my-skill/` + restart Claude Code
+
+**Hook not running**
+→ Check: Absolute path in settings.json + `chmod +x hook.sh` + JSON valid
+
+**Detailed troubleshooting**: `Skill("moai-cc-guide")` → README.md FAQ section
+
+---
+
+## 📖 When to Delegate to Skills
+
+| Scenario | Skill | Why |
+|----------|-------|-----|
+| "How do I...?" | moai-cc-* (specific) | All how-to guidance in Skills |
+| "What's the pattern?" | moai-cc-* (specific) | All patterns in Skills |
+| "Is this valid?" | Relevant cc-manager skill | Cc-manager validates |
+| "Fix this error" | moai-cc-* (specific) | Skills provide solutions |
+| "Choose architecture" | moai-cc-guide | Only guide has decision tree |
+
+---
+
+## 💡 Philosophy
+
+**v3.0.0 Design**: Separation of concerns
+- **Skills** = Pure knowledge (HOW to use Claude Code)
+- **cc-manager** = Operational orchestration (Apply standards)
+- **moai-cc-guide** = Architecture decisions (WHAT to use)
+
+**Result**:
+- ✅ DRY - No duplicate knowledge
+- ✅ Maintainable - Each component has one job
+- ✅ Scalable - New Skills don't bloat cc-manager
+- ✅ Progressive Disclosure - Load only what you need
+
+---
+
+## 📞 User Interactions
+
+**Ask cc-manager for**:
+- File creation ("Create agent...")
+- Validation ("Verify this...")
+- Fixes ("Fix the standards...")
+
+**Ask Skills for**:
+- Guidance ("How do I...")
+- Patterns ("Show me...")
+- Decisions ("Should I...")
+
+**Ask moai-cc-guide for**:
+- Architecture ("Agents vs Commands...")
+- Workflows ("/alfred:* integration...")
+- Roadmaps ("What's next...")
+
+---
+
+## ✨ Example: New Skill
+
+```bash
+# Request to cc-manager
+@agent-cc-manager "Create skill: ears-pattern
+- Purpose: EARS syntax teaching
+- Model: haiku
+- Location: .claude/skills/ears-pattern/"
+
+# cc-manager validates, creates file, checks standards
+
+# User references skill:
+Skill("ears-pattern")  # Now available in commands/agents
+```
+
+---
+
+## 🔄 Autorun Conditions
+
+- **SessionStart**: Detect project + offer initial setup
+- **File creation**: Validate YAML + check standards
+- **Verification request**: Batch-check all `.claude/` files
+- **Update detection**: Alert if cc-manager itself is updated
+
+---
+
+**Last Updated**: 2025-10-23
+**Version**: 3.0.0 (Refactored for Skills delegation)
+**Philosophy**: Lean operational agent + Rich knowledge in Skills
+
+For comprehensive guidance, reference the 9 specialized Skills in `.claude/skills/moai-cc-*/`.