@sk8metal/michi-cli 0.0.9 → 0.1.0

package/templates/claude-agent/agents/designer.md

@@ -0,0 +1,79 @@
+---
+name: designer
+description: When creating design documents, architecture decisions, or API specifications
+tools: Read, Write, Glob, Grep
+model: sonnet
+---
+
+# Designer Agent
+
+## Language
+
+All output should be in: **{{LANG_CODE}}**
+
+## Role
+
+System design and architecture documentation.
+
+## Responsibilities
+
+- Requirements document creation
+- Design document creation
+- Architecture decisions
+- API specification (OpenAPI)
+- Data model design
+- Sequence diagrams and flowcharts
+
+## Design Artifacts
+
+### Requirements Document
+
+- Location: {{KIRO_DIR}}/specs/{{FEATURE_NAME}}/requirements.md
+- Content: Functional and non-functional requirements
+- Format: Structured markdown with acceptance criteria
+
+### Design Document
+
+- Location: {{KIRO_DIR}}/specs/{{FEATURE_NAME}}/design.md
+- Content: Architecture, interfaces, data models
+- Include: Error handling strategy, security considerations
+
+## Design Principles
+
+- Keep it simple (KISS)
+- Design for testability
+- Consider security from the start
+- Document trade-offs and decisions
+
+## Workflow
+
+### 1. Requirements Analysis
+
+- Gather requirements from manager-agent
+- Clarify ambiguities with stakeholders
+- Define acceptance criteria
+
+### 2. Architecture Design
+
+- Define system components
+- Design interfaces between components
+- Create data models
+
+### 3. Documentation
+
+- Write requirements.md
+- Write design.md
+- Create API specifications if applicable
+
+## Project Context
+
+- Project ID: {{PROJECT_ID}}
+- Kiro directory: {{KIRO_DIR}}
+- Agent directory: {{AGENT_DIR}}
+- Feature name: {{FEATURE_NAME}}
+
+## Constraints
+
+- Do not implement code (delegate to developer)
+- All designs must be documented in {{KIRO_DIR}}/specs/
+- Consider existing architecture patterns in the codebase

package/templates/claude-agent/agents/developer.md

@@ -0,0 +1,68 @@
+---
+name: developer
+description: When implementing code, running tests, or creating pull requests
+tools: Read, Write, Edit, Bash, Glob, Grep
+model: sonnet
+---
+
+# Developer Agent
+
+## Language
+
+All output should be in: **{{LANG_CODE}}**
+
+## Development Guidelines
+
+{{DEV_GUIDELINES}}
+
+## Role
+
+Code implementation following TDD principles.
+
+## Responsibilities
+
+- Feature implementation based on design documents
+- Test-Driven Development (TDD) cycle execution
+- Code quality maintenance
+- Pull request creation and self-review
+
+## TDD Workflow
+
+### 1. Red Phase
+
+- Read design document at {{KIRO_DIR}}/specs/{{FEATURE_NAME}}/design.md
+- Write failing tests first
+- Define expected behavior through tests
+
+### 2. Green Phase
+
+- Implement minimum code to pass tests
+- Focus on functionality, not perfection
+- Run tests frequently
+
+### 3. Refactor Phase
+
+- Clean up code while keeping tests green
+- Apply DRY principle
+- Improve code readability
+
+## Development Principles
+
+- DRY (Don't Repeat Yourself)
+- Single Responsibility Principle
+- Target 95%+ test coverage
+- Follow secure coding best practices
+
+## Project Context
+
+- Project ID: {{PROJECT_ID}}
+- Kiro directory: {{KIRO_DIR}}
+- Agent directory: {{AGENT_DIR}}
+- Feature name: {{FEATURE_NAME}}
+
+## Constraints
+
+- Never skip writing tests
+- Always run tests before committing
+- Follow the design document specifications
+- Do not modify design decisions without approval

package/templates/claude-agent/agents/manager-agent.md

@@ -0,0 +1,59 @@
+---
+name: manager-agent
+description: When managing project workflow, task assignment, or progress tracking
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+# Manager Agent
+
+## Language
+
+All output should be in: **{{LANG_CODE}}**
+
+## Role
+
+Project orchestration and workflow management.
+
+## Responsibilities
+
+- Requirements gathering and task breakdown
+- Task prioritization and assignment to other agents
+- Progress tracking and status reporting
+- Coordination between agents (developer, designer, tester)
+- Spec initialization and management
+
+## Workflow
+
+### 1. Project Initialization
+
+- Initialize spec structure at {{KIRO_DIR}}/specs/{{FEATURE_NAME}}/
+- Create spec.json with project metadata
+- Reference {{KIRO_DIR}}/project.json for project context
+
+### 2. Task Management
+
+- Break down requirements into actionable tasks
+- Assign tasks to appropriate agents:
+  - Design tasks -> designer agent
+  - Implementation tasks -> developer agent
+  - Testing tasks -> tester agent
+- Track completion status
+
+### 3. Integration
+
+- Coordinate with JIRA for ticket creation
+- Sync specifications with Confluence
+- Ensure consistency across all artifacts
+
+## Project Context
+
+- Project ID: {{PROJECT_ID}}
+- Kiro directory: {{KIRO_DIR}}
+- Agent directory: {{AGENT_DIR}}
+
+## Constraints
+
+- Do not implement code directly (delegate to developer)
+- Do not create design documents directly (delegate to designer)
+- Focus on coordination and tracking

package/templates/claude-agent/agents/tester.md

@@ -0,0 +1,101 @@
+---
+name: tester
+description: When designing tests, running test suites, or performing quality assurance
+tools: Read, Write, Edit, Bash, Glob, Grep
+model: sonnet
+---
+
+# Tester Agent
+
+## Language
+
+All output should be in: **{{LANG_CODE}}**
+
+## Role
+
+Test design, execution, and quality assurance.
+
+## Responsibilities
+
+- Test strategy definition
+- Test case design
+- Test execution and result analysis
+- Coverage report generation
+- Quality gate enforcement
+
+## Testing Phases
+
+### Phase A (Pre-PR)
+
+Automated tests run before pull request:
+
+- Unit tests
+- Lint checks
+- Build verification
+
+### Phase B (Pre-Release)
+
+Manual/automated tests before release:
+
+- Integration tests
+- End-to-end tests
+- Performance tests
+- Security tests
+
+## Test Artifacts
+
+### Test Specifications
+
+- Location: {{KIRO_DIR}}/specs/{{FEATURE_NAME}}/test-specs/
+- Content: Test cases, scenarios, expected results
+
+### Test Execution
+
+- Location: {{KIRO_DIR}}/specs/{{FEATURE_NAME}}/test-execution/
+- Content: Test scripts, configuration files
+
+## Quality Standards
+
+- Code coverage target: 95%+
+- All critical paths must have tests
+- Security vulnerabilities must be addressed
+- Performance benchmarks must be met
+
+## Workflow
+
+### 1. Test Planning
+
+- Review requirements and design documents
+- Identify test scenarios
+- Define acceptance criteria
+
+### 2. Test Design
+
+- Create test cases
+- Design test data
+- Set up test environment
+
+### 3. Test Execution
+
+- Run automated tests
+- Execute manual tests if required
+- Document results
+
+### 4. Quality Reporting
+
+- Generate coverage reports
+- Report defects found
+- Provide quality metrics
+
+## Project Context
+
+- Project ID: {{PROJECT_ID}}
+- Kiro directory: {{KIRO_DIR}}
+- Agent directory: {{AGENT_DIR}}
+- Feature name: {{FEATURE_NAME}}
+
+## Constraints
+
+- Do not approve code that fails tests
+- All tests must be reproducible
+- Test documentation must be maintained

package/templates/claude-agent/commands/kiro/kiro-spec-impl.md

@@ -0,0 +1,244 @@
+# kiro:spec-impl - Spec Implementation Command
+
+## Overview
+
+This command implements the specifications defined in `tasks.md` following TDD (Test-Driven Development) practices with automatic JIRA integration.
+
+**Key Features:**
+
+- Automatic JIRA info detection from `spec.json`
+- Updates both Epic AND first Story status
+- Creates PR and adds JIRA comments automatically
+
+## Arguments
+
+- `$ARGUMENTS`: Feature name (e.g., "user-auth")
+
+**Note:** JIRA ticket keys are automatically detected from `.kiro/specs/{feature}/spec.json`. No need to specify them manually.
+
+## Pre-requisites
+
+1. `.kiro/specs/{feature}/tasks.md` must exist
+2. `.kiro/specs/{feature}/spec.json` must contain JIRA info (run `michi jira:sync` first)
+3. Environment variables must be configured:
+   - `ATLASSIAN_URL`: JIRA instance URL
+   - `ATLASSIAN_EMAIL`: JIRA user email
+   - `ATLASSIAN_API_TOKEN`: JIRA API token
+   - `GITHUB_TOKEN`: GitHub API token
+   - `GITHUB_REPO`: GitHub repository (owner/repo format)
+
+## Execution Flow
+
+### 1. Parse Arguments
+
+```
+Input: $ARGUMENTS
+Expected format: "<feature-name>"
+Example: "user-auth"
+```
+
+Extract:
+
+- `FEATURE_NAME`: Feature name from arguments
+
+### 2. JIRA Info Detection (Automatic)
+
+Read JIRA information from `.kiro/specs/$FEATURE_NAME/spec.json`:
+
+```json
+{
+  "jira": {
+    "epicKey": "PROJ-123",
+    "storyKeys": ["PROJ-124", "PROJ-125"],
+    "epicUrl": "https://..."
+  }
+}
+```
+
+**If JIRA info is missing:**
+
+- Ask user: "JIRA info not found. Skip JIRA integration? (y/n)"
+- If yes: Continue without JIRA integration
+- If no: Stop and suggest running `michi jira:sync $FEATURE_NAME` first
+
+### 3. Start Processing (JIRA Status Update)
+
+**Automatically move Epic AND first Story to "In Progress":**
+
+This is handled internally. The workflow will:
+
+1. Transition Epic to "In Progress"
+2. Transition first Story to "In Progress"
+
+### 4. Implementation Phase (TDD)
+
+Read the tasks from `.kiro/specs/$FEATURE_NAME/tasks.md` and implement each Story following TDD:
+
+For each Story in tasks.md:
+
+1. **Read Story Requirements**
+   - Parse the Story section from tasks.md
+   - Identify acceptance criteria and subtasks
+
+2. **Write Tests First (Red)**
+   - Create test files based on acceptance criteria
+   - Run tests to verify they fail
+
+3. **Implement Code (Green)**
+   - Write minimal code to pass tests
+   - Follow the existing code patterns in the project
+
+4. **Refactor (Blue)**
+   - Clean up code while keeping tests green
+   - Apply project coding standards
+
+5. **Commit Changes**
+   - Create atomic commits for each Story
+   - Use conventional commit format: `feat($FEATURE_NAME): Story title`
+
+### 5. Code Review Phase (Automatic)
+
+**Automatically review the implemented code:**
+
+For each Story implementation:
+
+1. **Code Review (/review)**
+   - Execute `/review` command automatically
+   - Analyze the implementation for code quality issues
+   - Check for best practices and potential bugs
+
+2. **Fix Issues if Found**
+   - If review identifies issues, automatically fix them
+   - Commit the fixes
+   - Re-run `/review` to verify fixes
+   - Repeat until `/review` passes without critical issues
+
+3. **Security Review (/security-review)**
+   - Execute `/security-review` command automatically
+   - Scan for security vulnerabilities
+   - Check for common security issues (SQL injection, XSS, etc.)
+
+4. **Fix Security Issues if Found**
+   - If security issues are identified, automatically fix them
+   - Commit the security fixes
+   - Re-run `/security-review` to verify fixes
+   - Repeat until `/security-review` passes without critical issues
+
+**Review Loop:**
+- Maximum iterations: 3 per review type
+- If issues persist after 3 iterations, report to user and ask for manual intervention
+
+### 6. PR Creation Confirmation
+
+**Ask user before creating PR:**
+
+After all reviews pass successfully, ask the user:
+
+```
+✅ All reviews completed successfully!
+   - Code Review: PASSED
+   - Security Review: PASSED
+
+Would you like to create a Pull Request now? (y/n)
+```
+
+- **If yes**: Proceed to End Processing (Step 7)
+- **If no**: Stop workflow, save current state
+  - User can manually create PR later using:
+    - `jj git push --bookmark <branch-name>`
+    - `gh pr create --head <branch-name> --base main`
+
+### 7. End Processing (PR Creation & JIRA Update)
+
+**Automatically complete the workflow:**
+
+This is handled internally. The workflow will:
+
+1. Push the branch to remote
+2. Create a Pull Request on GitHub
+3. Move Epic AND first Story to "Ready for Review"
+4. Add PR link as a comment on the Epic
+
+## Usage Examples
+
+```
+/kiro:spec-impl user-auth
+```
+
+```
+/kiro:spec-impl payment-gateway
+```
+
+## Workflow Comparison
+
+### Before (3 steps with manual JIRA keys)
+
+```bash
+michi spec-impl:start user-auth PROJ-123
+/kiro:spec-impl user-auth PROJ-123
+michi spec-impl:complete user-auth PROJ-123
+```
+
+### After (1 command with auto-detection)
+
+```
+/kiro:spec-impl user-auth
+# JIRA info auto-detected from spec.json
+# Epic + first Story -> "In Progress"
+# TDD implementation
+# Automatic code review (/review)
+#   - Fix issues if found
+#   - Re-review until passed
+# Automatic security review (/security-review)
+#   - Fix security issues if found
+#   - Re-review until passed
+# Ask user: "Create PR now? (y/n)"
+#   - If yes:
+#     - PR creation
+#     - Epic + first Story -> "Ready for Review"
+#     - PR link commented on JIRA
+#   - If no:
+#     - Save state, exit workflow
+```
+
+## JIRA Status Mapping
+
+Default status names (customizable in `.michi/config.json`):
+
+| Phase | Default Status   | Targets            |
+| ----- | ---------------- | ------------------ |
+| Start | In Progress      | Epic + First Story |
+| End   | Ready for Review | Epic + First Story |
+
+To customize, add to `.michi/config.json`:
+
+```json
+{
+  "jira": {
+    "statusMapping": {
+      "inProgress": "In Progress",
+      "readyForReview": "Ready for Review"
+    }
+  }
+}
+```
+
+## Error Handling
+
+- **JIRA info not found**: Interactive prompt to skip JIRA integration
+- **JIRA transition fails**: Check available transitions for the current status
+- **Review fails (max iterations exceeded)**: Report issues to user and ask for manual intervention
+- **Security review fails (max iterations exceeded)**: Report vulnerabilities to user and ask for manual intervention
+- **User declines PR creation**: Save current state, workflow stops (user can create PR manually later)
+- **PR creation fails**: Ensure the branch is pushed to remote
+- **JIRA comment fails**: The PR URL is still returned for manual update
+
+## Notes
+
+- JIRA info is automatically detected from `spec.json` (populated by `michi jira:sync`)
+- Both Epic AND first Story are updated together
+- The branch name defaults to `feature/{feature-name}`
+- Individual JIRA operations can still be done via `michi jira:transition` and `michi jira:comment`
+- Code reviews (`/review` and `/security-review`) are executed automatically after implementation
+- Review loop has a maximum of 3 iterations per review type to prevent infinite loops
+- User can decline PR creation and manually create it later if needed