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

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

@@ -0,0 +1,330 @@
+---
+description: "Submit feedback or report issues"
+argument-hint: "[issue|suggestion|question]"
+type: local
+allowed-tools: Read, Write, Edit, Bash, Grep, Glob, TodoWrite, AskUserQuestion
+model: sonnet
+---
+
+## Pre-execution Context
+
+!git status --porcelain
+!git branch --show-current
+!git log --oneline -1
+
+## Essential Files
+
+@.moai/config/config.yaml
+
+---
+
+# MoAI-ADK Step 9: Feedback Loop
+
+> Architecture: Commands → Agents → Skills. This command orchestrates ONLY through `Task()` tool.
+> Delegation Model: Feedback collection delegated to `manager-quality` agent.
+
+Workflow Integration: This command implements the feedback loop of the MoAI workflow, allowing users to report issues or suggestions directly from the CLI.
+
+---
+
+## Command Purpose
+
+Collect user feedback, bug reports, or feature suggestions and create GitHub issues automatically.
+
+Run on: `$ARGUMENTS` (Feedback type)
+
+---
+
+## Execution Philosophy
+
+/moai:9-feedback performs feedback collection through agent delegation:
+
+Execution Flow:
+
+- User Command: /moai:9-feedback [type]
+- Phase 1: Task with subagent_type "manager-quality"
+  - Analyze feedback type
+  - Collect details via AskUserQuestion
+  - Create GitHub Issue via Skill
+- Output: Issue created with link
+
+### Key Principle: Full Delegation Pattern
+
+This command exclusively uses these tools:
+
+- [HARD] Task() for agent delegation
+  WHY: Task orchestration ensures feedback collection responsibility lies with specialized agents
+  IMPACT: Direct tool usage bypasses quality assurance and agent expertise
+
+- [HARD] AskUserQuestion() for user interaction AT COMMAND LEVEL ONLY
+  WHY: Subagents via Task() are stateless and cannot interact with users directly
+  IMPACT: Expecting agents to use AskUserQuestion causes workflow failures
+  CORRECT: Command collects feedback type and details, passes to agent as parameters
+
+- [HARD] Delegate all Bash operations to manager-quality agent
+  WHY: Agent context ensures proper error handling and feedback capture
+  IMPACT: Direct Bash execution loses feedback traceability and error context
+
+---
+
+## Associated Agents and Skills
+
+Associated Agents for Feedback Collection:
+
+- manager-quality: Feedback collection and GitHub issue creation
+
+---
+
+## Agent Invocation Patterns (CLAUDE.md Compliance)
+
+This command uses agent execution patterns defined in CLAUDE.md (lines 96-120).
+
+### Sequential Phase-Based Chaining PASS
+
+Command implements simple sequential execution through 2 phases:
+
+Phase Flow:
+
+- Phase 1: Feedback Collection (manager-quality analyzes type and collects details)
+- Phase 2: GitHub Issue Creation (manager-quality creates issue with collected information)
+
+Each phase receives outputs from previous phase as context.
+
+WHY: Sequential execution ensures complete feedback capture before submission
+
+- Phase 2 requires validated feedback details from Phase 1
+- Issue creation requires all user input to be collected
+
+IMPACT: Skipping Phase 1 would create incomplete GitHub issues
+
+### Parallel Execution FAIL
+
+Not applicable - simple linear workflow
+
+WHY: Feedback workflow has minimal complexity
+
+- Only one agent (manager-quality) handles entire process
+- Single feedback submission at a time
+- No independent operations to parallelize
+
+IMPACT: Parallel execution unnecessary for single-agent linear workflow
+
+### Resumable Agent Support FAIL
+
+Not applicable - command completes in single execution
+
+WHY: Feedback submission is fast atomic operation
+
+- Typical execution completes in under 30 seconds
+- GitHub API calls are atomic and fast
+- No long-running processes requiring checkpoints
+
+IMPACT: Resume pattern unnecessary for simple feedback workflows
+
+---
+
+Refer to CLAUDE.md "Agent Chaining Patterns" (lines 96-120) for complete pattern architecture.
+
+---
+
+## Execution Process
+
+### Step 1: Delegate to Quality Gate Agent
+
+Use the manager-quality subagent to collect and submit user feedback:
+
+Task: Collect user feedback and create a GitHub issue.
+
+Context:
+
+- Feedback Type: $ARGUMENTS (default to 'issue' if empty)
+- Conversation Language: {{CONVERSATION_LANGUAGE}}
+
+Instructions:
+
+1. Determine Feedback Type:
+
+   [HARD] Resolve feedback type from $ARGUMENTS if provided
+   WHY: Pre-specified type accelerates feedback collection
+   IMPACT: Skipping argument check forces unnecessary user interaction
+
+   [HARD] Prompt user to select type when $ARGUMENTS is empty
+   WHY: Interactive selection ensures proper categorization
+   IMPACT: Assuming default type may misclassify feedback
+
+   Supported Feedback Types:
+   - Bug Report: Technical issues or errors
+   - Feature Request: Suggestions for improvements
+   - Question/Other: Clarifications or general feedback
+
+2. Collect Details:
+
+   [HARD] Solicit feedback title from user
+   WHY: Title establishes feedback summary for issue search and triage
+   IMPACT: Missing title reduces issue discoverability
+
+   [HARD] Solicit detailed description from user
+   WHY: Description provides context for developers to understand and respond
+   IMPACT: Vague descriptions create follow-up communication overhead
+
+   [SOFT] Solicit priority level from user (Low/Medium/High)
+   WHY: Priority directs team resource allocation
+   IMPACT: Missing priority defaults to normal urgency
+
+3. Create GitHub Issue:
+
+   [HARD] Execute GitHub CLI (gh issue create) command with collected feedback
+   WHY: GitHub integration ensures feedback enters official issue tracking system
+   IMPACT: Untracked feedback is lost to follow-up and implementation
+
+   [HARD] Apply appropriate labels based on feedback type
+   WHY: Labels enable automated triage and dashboard organization
+   IMPACT: Untagged issues are invisible to responsible team members
+
+   [SOFT] Format issue body using consistent template
+   WHY: Standardized templates improve issue clarity and consistency
+   IMPACT: Inconsistent formatting wastes developer time parsing issues
+
+4. Report Result:
+   [HARD] Provide user with created issue URL
+   WHY: Direct issue link enables immediate user access and tracking
+   IMPACT: Missing link requires users to manually search for their feedback
+
+   [HARD] Confirm successful feedback submission to user
+   WHY: Confirmation provides closure and acknowledgment of user contribution
+   IMPACT: Silent completion leaves user uncertain about feedback status
+
+Language and Accessibility:
+
+- [HARD] Use conversation_language for all user-facing interactions
+  WHY: User language ensures comprehension and accessibility
+  IMPACT: Wrong language creates friction and reduces usability
+
+- [HARD] Provide text-based options in AskUserQuestion (exclude emojis)
+  WHY: Text options ensure consistency across all platforms and locales
+  IMPACT: Emoji options are platform-dependent and may not display correctly
+
+---
+
+## Summary: Execution Verification Checklist
+
+Before considering command execution complete, verify all requirements:
+
+- [HARD] Agent Invoked: manager-quality agent executed with feedback details
+  Verification: Confirm agent Task() call with feedback context
+  Acceptance Criteria: Agent response confirms feedback reception
+
+- [HARD] Feedback Collected: User provided title, description, and type
+  Verification: Confirm all required fields captured
+  Acceptance Criteria: No empty or null feedback fields
+
+- [HARD] Issue Created: GitHub issue successfully submitted to repository
+  Verification: Confirm gh issue create command executed successfully
+  Acceptance Criteria: GitHub API response contains issue ID and URL
+
+- [HARD] Link Provided: User received direct URL to created issue
+  Verification: Confirm issue URL displayed in user response
+  Acceptance Criteria: User can click URL and access their feedback immediately
+
+---
+
+## Quick Reference
+
+Scenario: Report bug
+
+- Entry Point: /moai:9-feedback issue
+- Expected Outcome: GitHub issue created with bug label
+
+Scenario: Request feature
+
+- Entry Point: /moai:9-feedback suggestion
+- Expected Outcome: GitHub issue created with enhancement label
+
+Scenario: Ask question
+
+- Entry Point: /moai:9-feedback question
+- Expected Outcome: GitHub issue created with question label
+
+Scenario: General feedback
+
+- Entry Point: /moai:9-feedback
+- Expected Outcome: Interactive feedback collection
+
+Associated Agent:
+
+- `manager-quality` - Feedback manager and GitHub issue creator
+
+Feedback Types:
+
+- Bug Report: Technical issues or errors
+- Feature Request: Suggestions for improvements
+- Question: Clarifications or help needed
+- Other: General feedback
+
+Version: 1.0.0 (Agent-Delegated Pattern)
+Last Updated: 2025-11-25
+Architecture: Commands → Agents → Skills (Complete delegation)
+
+---
+
+## Output Format
+
+Structure agent responses with semantic sections for clarity and consistency:
+
+Response Structure:
+
+The agent response must include these sections:
+
+Feedback Summary:
+Concise recap of feedback type, title, and key points submitted
+
+GitHub Integration:
+Confirmation that feedback was submitted to GitHub with issue URL and ID
+
+User Language:
+Response provided in user's conversation_language configuration
+
+Next Actions:
+Clear options for user to continue workflow or submit additional feedback
+
+WHY: Semantic structure ensures consistent response quality and user experience
+IMPACT: Unstructured responses create ambiguity and require user clarification
+
+---
+
+## Post-Submission User Direction
+
+After successful feedback submission, present user with next action options:
+
+[HARD] Display post-submission summary to user
+WHY: Summary confirms successful completion and provides issue reference
+IMPACT: Missing summary leaves user uncertain about submission status
+
+[SOFT] Offer user next step choices via AskUserQuestion
+WHY: Guided choices help users continue productive workflows
+IMPACT: Abrupt completion requires user to determine next actions
+
+Next Step Options:
+
+- Continue Development: Return to current development workflow
+- Submit Additional Feedback: Report another issue or suggestion
+- View Issue: Open created GitHub issue in browser
+
+Requirements:
+
+- [HARD] Use conversation_language for all post-submission messaging
+  WHY: Consistent language maintains user context
+  IMPACT: Language switching disorients users
+
+- [HARD] Express all options as text labels without emoji characters
+  WHY: Text-only labels ensure universal platform compatibility
+  IMPACT: Emojis may fail to display across different systems
+
+---
+
+## EXECUTION DIRECTIVE
+
+You must NOW execute the command following the "Execution Process" described above.
+
+1. Use the manager-quality subagent.
+2. Do NOT just describe what you will do. DO IT.

moai_adk/templates/.claude/commands/moai/alfred.md

@@ -0,0 +1,339 @@
+---
+description: "Agentic AI automation - From SPEC to code with autonomous loop"
+argument-hint: '"task description" [--loop] [--max N] [--seq] | resume SPEC-XXX'
+type: utility
+allowed-tools: Task, AskUserQuestion, TodoWrite, Bash, Read, Write, Edit, Glob, Grep
+model: inherit
+---
+
+## Pre-execution Context
+
+!git status --porcelain
+!git branch --show-current
+
+## Essential Files
+
+@.moai/config/sections/ralph.yaml
+@.moai/config/sections/git-strategy.yaml
+@.moai/config/sections/quality.yaml
+@.moai/config/sections/llm.yaml
+
+---
+
+# /moai:alfred - Agentic AI Autonomous Automation
+
+## Core Principle: Fully Autonomous Automation
+
+User provides a goal, AI autonomously plans, executes, and completes.
+
+```
+USER: "Add authentication feature"
+  ↓
+AI: Explore → Plan → Implement → Verify → Repeat
+  ↓
+AI: All issues resolved
+  ↓
+AI: <moai>DONE</moai>
+```
+
+## Command Purpose
+
+Autonomously execute the full MoAI workflow:
+
+1. **Parallel Exploration** (Explore + Research simultaneously)
+2. **SPEC Generation** (after user approval)
+3. **TDD Implementation** (auto iterative fixing)
+4. **Documentation Sync**
+5. **Completion Marker Detection** (`<moai>DONE</moai>`)
+
+Feature Description: $ARGUMENTS
+
+## Quick Start
+
+```bash
+# Default autonomous execution (parallel exploration)
+/moai:alfred "Add JWT authentication"
+
+# Enable auto loop (max 50 iterations)
+/moai:alfred "JWT auth" --loop --max 50
+
+# Sequential exploration + auto loop
+/moai:alfred "JWT auth" --loop --sequential
+
+# Resume previous work
+/moai:alfred resume SPEC-AUTH-001
+```
+
+## Command Options
+
+| Option | Alias | Description | Default |
+|--------|-------|-------------|---------|
+| `--loop` | - | Enable auto iterative fixing | ralph.yaml |
+| `--max N` | --max-iterations | Maximum iteration count | 100 |
+| `--sequential` | --seq | Sequential exploration (for debugging) | Parallel |
+| `--branch` | - | Auto-create feature branch | git-strategy |
+| `--pr` | - | Auto-create PR | git-strategy |
+| `--resume SPEC` | - | Resume previous work | - |
+
+## Completion Promise
+
+AI must add a marker when work is complete:
+
+```markdown
+## Complete
+
+All implementation complete, tests passing, docs updated. <moai>DONE</moai>
+```
+
+**Marker Types**:
+- `<moai>DONE</moai>` - Task complete
+- `<moai>COMPLETE</moai>` - Full completion
+- `<moai:done />` - XML format
+
+## Agentic Autonomous Flow
+
+```
+START: /moai:alfred "task description"
+
+PHASE 0: Parallel Exploration (autonomous)
+  ┌── Explore Agent: Codebase analysis
+  ├── Research Agent: Documentation/issue search
+  └── Quality Agent: Current state diagnosis
+  ↓
+Integration → Execution plan generation
+
+PHASE 1: SPEC Generation
+  └── Written in EARS format
+  ↓
+User Approval
+  ↓
+PHASE 2: TDD Implementation (autonomous loop)
+  │
+  └── WHILE (issues_exist AND iteration < max):
+       ├── Diagnostics (LSP + Tests + Coverage)
+       ├── TODO generation
+       ├── Fix execution
+       ├── Verification
+       └── Completion marker detected? → BREAK
+  ↓
+PHASE 3: Documentation Sync
+  └── Add marker: <moai>DONE</moai>
+  ↓
+COMPLETE
+```
+
+### Phase 0: Parallel Exploration Implementation
+
+By default, execute three exploration agents simultaneously for optimal performance:
+
+Step 1 - Launch Parallel Agent Tasks:
+
+In a single response, invoke all three Task tools simultaneously (Claude Code executes them in parallel automatically):
+
+1. Explore Agent:
+   - subagent_type: Explore
+   - description: Codebase analysis for task context
+   - prompt: Include user task description, request relevant files, architecture patterns, existing implementations
+
+2. Research Agent:
+   - subagent_type: Explore (with WebSearch/WebFetch focus)
+   - description: External documentation and best practices research
+   - prompt: Include user task description, request API docs, library documentation, similar implementations
+
+3. Quality Agent:
+   - subagent_type: manager-quality
+   - description: Current project quality assessment
+   - prompt: Request test coverage status, lint status, technical debt assessment
+
+All three Task calls in the same response triggers automatic parallel execution (up to 10 concurrent).
+
+Step 2 - Collect and Integrate Results:
+
+After all three agents complete:
+
+1. Collect outputs from each agent response
+2. Extract key findings:
+   - From Explore: Relevant files, architecture patterns, existing code to reference
+   - From Research: External knowledge, best practices, API patterns
+   - From Quality: Current test coverage, code quality baseline, known issues
+
+3. Synthesize into unified exploration report
+
+Step 3 - Generate Execution Plan:
+
+Based on integrated findings:
+
+1. Identify implementation approach
+2. List files to create/modify
+3. Define test strategy
+4. Estimate scope and complexity
+
+Step 4 - User Approval Checkpoint:
+
+Present integrated findings and proposed plan to user via AskUserQuestion:
+- Options: Proceed to SPEC creation, Modify approach, Cancel
+
+Error Handling:
+
+If any agent fails:
+- Continue with results from successful agents
+- Note missing information in plan
+- Offer to retry failed agent or proceed with partial information
+
+WHY: Parallel exploration reduces Phase 0 time from 45-90 seconds to 15-30 seconds (2-3x speedup)
+IMPACT: Faster initial context gathering without sacrificing comprehensiveness
+
+## TODO-Obsessive Rule
+
+[HARD] TodoWrite Tool Mandatory Usage:
+
+1. Immediate Creation: When issues are discovered, call TodoWrite tool to add items with pending status
+2. Immediate Progress: Before starting work, call TodoWrite tool to change item to in_progress
+3. Immediate Completion: After completing work, call TodoWrite tool to change item to completed
+4. Prohibited: Output TODO lists as text (MUST use TodoWrite tool)
+5. Completion Condition: All TODOs completed OR completion marker detected
+
+WHY: Using TodoWrite tool allows users to track progress in real-time.
+
+## Output Format
+
+### Running
+
+```markdown
+## Alfred: Phase 2 (Loop 3/100)
+
+### TODO Status
+- [x] Implement JWT token generation
+- [x] Implement login endpoint
+- [ ] Token validation middleware ← in progress
+
+### Issues
+- ERROR: src/auth.py:45 - undefined 'jwt_decode'
+- WARNING: tests/test_auth.py:12 - unused 'result'
+
+Fixing...
+```
+
+### Complete
+
+```markdown
+## Alfred: COMPLETE
+
+### Summary
+- SPEC: SPEC-AUTH-001
+- Files: 8 files modified
+- Tests: 25/25 passing
+- Coverage: 88%
+- Loops: 7 iterations
+
+### Changes
++ JWT token generation
++ Login endpoint
++ Token validation middleware
++ Unit tests (12 cases)
++ API documentation
+
+<moai>DONE</moai>
+```
+
+## LLM Mode
+
+Auto-routing based on `llm.yaml` settings:
+
+| Mode | Plan Phase | Run Phase |
+|------|------------|-----------|
+| opus-only | Claude (current) | Claude (current) |
+| hybrid | Claude (current) | GLM (worktree) |
+| glm-only | GLM (worktree) | GLM (worktree) |
+
+## Expert Delegation (Single Domain)
+
+Single domain tasks are delegated directly to expert agents:
+
+```bash
+# Alfred auto-determines
+/moai:alfred "SQL query optimization"
+
+# → Delegates directly to expert-performance agent
+# → Immediate implementation without SPEC
+```
+
+## Quick Reference
+
+```bash
+# Autonomous execution (default parallel)
+/moai:alfred "task"
+
+# Auto loop + sequential
+/moai:alfred "task" --loop --sequential
+
+# Specify max iterations
+/moai:alfred "task" --loop --max 50
+
+# Branch + PR
+/moai:alfred "task" --branch --pr
+
+# Resume
+/moai:alfred resume SPEC-XXX
+```
+
+---
+
+## EXECUTION DIRECTIVE
+
+1. Parse $ARGUMENTS (extract --loop, --max, --sequential, --branch, --pr, --resume flags)
+
+2. IF --resume flag with SPEC ID: Load existing SPEC and continue from last state
+
+3. Detect LLM mode from llm.yaml (opus-only, hybrid, glm-only)
+
+4. Execute Phase 0 - Parallel Exploration:
+
+   IF --sequential flag is specified:
+
+   4a. Run Explore, then Research, then Quality sequentially
+
+   ELSE (default parallel mode):
+
+   4b. In a single response, invoke three Task tools simultaneously:
+       - Task 1 (Explore): Codebase analysis with subagent_type="Explore"
+       - Task 2 (Research): Documentation research with subagent_type="Explore" and WebSearch focus
+       - Task 3 (Quality): Quality assessment with subagent_type="manager-quality"
+
+   4c. Collect and integrate results from all three agents
+
+   4d. Generate unified exploration report and execution plan
+
+5. Routing decision:
+   - IF single-domain task (e.g., "SQL optimization"): Delegate directly to expert agent, skip SPEC
+   - IF multi-domain task: Proceed to full workflow with SPEC generation
+
+6. [HARD] Call TodoWrite tool to add discovered tasks with pending status
+
+7. User confirmation via AskUserQuestion (Proceed, Modify, Cancel)
+
+8. Execute Phase 1 - SPEC Generation:
+   - Use manager-spec subagent to create EARS-format SPEC document
+
+9. Execute Phase 2 - TDD Implementation Loop:
+
+   IF --loop flag OR ralph.yaml loop.enabled is true:
+
+   9a. WHILE (issues exist AND iteration less than max):
+       - [HARD] Before each task, call TodoWrite to change item to in_progress
+       - Execute diagnostics (parallel if enabled)
+       - Fix discovered issues
+       - [HARD] After each fix, call TodoWrite to change item to completed
+       - Check for completion marker
+       - IF marker found: Break loop
+
+10. Execute Phase 3 - Documentation Sync:
+    - Use manager-docs subagent to synchronize documentation
+
+11. Terminate with completion marker: Add marker when all tasks complete successfully
+
+---
+
+Version: 3.1.0
+Last Updated: 2026-01-11
+Core: Agentic AI Autonomous Automation