context-first-cli 1.8.2 → 2.0.0

package/dist/templates/commands/en/products/refine.md

@@ -0,0 +1,222 @@
+# Requirements Refinement
+
+This command refines a collected issue, transforming it into clear and validated requirements.
+
+## ⚠️ IMPORTANT: This Command DOES NOT Implement Code
+
+**This command is ONLY for requirements refinement:**
+- ✅ Refine and validate requirements
+- ✅ Update issue in the task manager via MCP
+- ✅ **READ** files from main repositories (read-only)
+- ❌ **DO NOT implement code**
+- ❌ **DO NOT edit code files**
+- ❌ **DO NOT checkout branches in main repositories**
+- ❌ **DO NOT make commits**
+
+**Next step**: `/spec [ISSUE-ID]` to create the complete specification (PRD).
+
+---
+
+## 📋 Prerequisites
+
+- Issue already collected via `/collect`
+- Project context will be loaded automatically (see "Load MetaSpecs" section below)
+
+## 🎯 Objective
+
+Refine the collected issue, clarifying:
+- Exact scope (what is included and what is not)
+- Clear acceptance criteria
+- Impact on each repository
+- Technical dependencies
+- Risks and constraints
+
+## 📝 Refinement Process
+
+### 1. Load Issue
+
+**PRIORITY 1: Use MCP (Model Context Protocol)**
+
+- Read `ai.properties.md` from the orchestrator to identify the `task_management_system`
+- Use the appropriate MCP to fetch the issue:
+  - `task_management_system=jira`: Use Jira MCP
+  - `task_management_system=linear`: Use Linear MCP
+  - `task_management_system=github`: Use GitHub MCP
+- Load all issue data (title, description, labels, etc.)
+
+**FALLBACK: If MCP is unavailable or fails**
+
+- Read `./.sessions/<ISSUE-ID>/collect.md`
+- If the file does not exist, inform the user of the error
+
+### 2. Load MetaSpecs
+
+**Automatically locate MetaSpecs**:
+1. Read `context-manifest.json` from the orchestrator
+2. Find the repository with `"role": "metaspecs"`
+3. Read `ai.properties.md` to get the `base_path`
+4. The metaspecs are located at: `{base_path}/{metaspecs-repo-id}/`
+5. Read relevant `index.md` files to understand:
+   - System architecture
+   - Design patterns
+   - Technical constraints
+   - Project conventions
+
+### 3. Scope Analysis
+
+Clearly define:
+
+**What IS in scope**:
+- Specific functionalities to be implemented
+- Repositories that will be modified
+- Necessary integrations
+
+**What IS NOT in scope**:
+- Related functionalities deferred for later
+- Future optimizations
+- "Nice to have" features
+
+### 4. Acceptance Criteria
+
+Define measurable and testable criteria:
+
+```markdown
+## Acceptance Criteria
+
+### Functional
+- [ ] [Criterion 1 - specific and testable]
+- [ ] [Criterion 2 - specific and testable]
+
+### Technical
+- [ ] [Technical criterion 1]
+- [ ] [Technical criterion 2]
+
+### Quality
+- [ ] Unit tests implemented
+- [ ] Integration tests implemented
+- [ ] Documentation updated
+```
+
+### 5. Impact Analysis
+
+For each affected repository:
+
+```markdown
+## Impact by Repository
+
+### <repo-1>
+- **Affected components**: [list]
+- **Type of change**: New feature / Modification / Refactoring
+- **Estimated complexity**: Low / Medium / High
+- **Risks**: [specific risks]
+
+### <repo-2>
+- **Affected components**: [list]
+- **Type of change**: New feature / Modification / Refactoring
+- **Estimated complexity**: Low / Medium / High
+- **Risks**: [specific risks]
+```
+
+### 6. Dependencies and Constraints
+
+Identify:
+- Dependencies between repositories
+- Dependencies on other features/issues
+- Technical constraints
+- Business constraints
+- Known blockers
+
+### 7. Initial Estimate
+
+Provide effort estimate:
+- **Small**: < 1 day
+- **Medium**: 1-3 days
+- **Large**: 3-5 days
+- **Very Large**: > 5 days (consider breaking into smaller issues)
+
+### 8. Pending Questions
+
+List questions that still need answers before starting implementation.
+
+## 📄 Saving the Refinement
+
+**PRIORITY 1: Update via MCP**
+
+- Use the task manager MCP to update the issue
+- Add acceptance criteria as a comment or custom field
+- Update labels/tags if necessary (e.g., "refined", "ready-for-spec")
+- Add estimate if supported by the task manager
+- Inform the user: "✅ Issue [ID] updated with refinement"
+
+**FALLBACK: Create .md file only if MCP fails**
+
+If MCP is unavailable or fails, create/update `./.sessions/<ISSUE-ID>/refine.md`:
+
+```markdown
+# [Issue Title] - Refinement
+
+## Scope
+
+### Included
+- [Item 1]
+- [Item 2]
+
+### Excluded
+- [Item 1]
+- [Item 2]
+
+## Acceptance Criteria
+[As per section 3 above]
+
+## Impact by Repository
+[As per section 4 above]
+
+## Dependencies
+- [Dependency 1]
+- [Dependency 2]
+
+## Constraints
+- [Constraint 1]
+- [Constraint 2]
+
+## Estimate
+[Small/Medium/Large/Very Large] - [Justification]
+
+## Pending Questions
+1. [Question 1]
+2. [Question 2]
+
+## Identified Risks
+- [Risk 1 and mitigation]
+- [Risk 2 and mitigation]
+```
+
+Inform the user: "⚠️ Refinement saved locally in .sessions/ (task manager not available)"
+
+## 🔍 Validation
+
+Validate the refinement against:
+- Product strategy (if documented)
+- Technical architecture (if documented)
+- Team capacity
+- Roadmap priorities
+
+---
+
+**Provided arguments**:
+
+```
+#$ARGUMENTS
+```
+
+---
+
+## 🎯 Next Step
+
+After approved refinement:
+
+```bash
+/spec [ISSUE-ID]
+```
+
+This command will create the complete feature specification (PRD).

package/dist/templates/commands/en/products/spec.md

@@ -0,0 +1,267 @@
+# Specification Creation (PRD)
+
+This command creates the complete specification (Product Requirements Document) for the feature.
+
+## ⚠️ IMPORTANT: This Command DOES NOT Implement Code
+
+**This command is ONLY for requirements documentation:**
+- ✅ Create PRD (Product Requirements Document)
+- ✅ Update issue in task manager via MCP
+- ✅ **READ** files from main repositories (read-only)
+- ❌ **DO NOT implement code**
+- ❌ **DO NOT edit code files**
+- ❌ **DO NOT checkout branches in main repositories**
+- ❌ **DO NOT commit**
+
+**Next step**: `/start` to begin development.
+
+---
+
+## 📋 Prerequisites
+
+- Issue refined via `/refine`
+- Approval to proceed with the feature
+
+## 📚 Load MetaSpecs
+
+**Automatically locate MetaSpecs**:
+1. Read `context-manifest.json` from the orchestrator
+2. Find the repository with `"role": "metaspecs"`
+3. Read `ai.properties.md` to get the `base_path`
+4. The metaspecs are located at: `{base_path}/{metaspecs-repo-id}/`
+5. Read the relevant `index.md` files to ensure compliance with:
+   - System architecture
+   - Design patterns
+   - Technical constraints
+   - Project conventions
+
+## 🎯 Objective
+
+Create a complete PRD that will serve as the single source of truth for implementation.
+
+## 📝 PRD Structure
+
+### 1. Overview
+
+```markdown
+# [Feature Title]
+
+## Context
+[Why are we building this? What problem does it solve?]
+
+## Objective
+[What do we want to achieve with this feature?]
+
+## Success Metrics
+- [Metric 1]: [How to measure]
+- [Metric 2]: [How to measure]
+```
+
+### 2. Functional Requirements
+
+```markdown
+## Functional Requirements
+
+### RF-01: [Requirement Name]
+**Description**: [Detailed description]
+**Priority**: Must Have / Should Have / Could Have
+**Repositories**: [affected repos]
+
+### RF-02: [Requirement Name]
+**Description**: [Detailed description]
+**Priority**: Must Have / Should Have / Could Have
+**Repositories**: [affected repos]
+```
+
+### 3. Non-Functional Requirements
+
+```markdown
+## Non-Functional Requirements
+
+### Performance
+- [Performance requirement]
+
+### Security
+- [Security requirement]
+
+### Accessibility
+- [Accessibility requirement]
+
+### Scalability
+- [Scalability requirement]
+```
+
+### 4. User Flows
+
+```markdown
+## User Flows
+
+### Main Flow
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+### Alternative Flows
+**Scenario**: [Scenario name]
+1. [Step 1]
+2. [Step 2]
+
+### Error Handling
+**Error**: [Error type]
+**Behavior**: [How the system should react]
+```
+
+### 5. Technical Specification
+
+```markdown
+## Technical Specification
+
+### Architecture
+
+#### <repo-1>
+- **New components**: [list]
+- **Modified components**: [list]
+- **APIs**: [new/modified endpoints]
+
+#### <repo-2>
+- **New components**: [list]
+- **Modified components**: [list]
+- **APIs**: [new/modified endpoints]
+
+### Integrations
+- **Between repos**: [how repos communicate]
+- **External**: [external APIs, if any]
+
+### Data Model
+[Describe changes to the data model, if any]
+```
+
+### 6. Acceptance Criteria
+
+```markdown
+## Acceptance Criteria
+
+### Functional
+- [ ] [Specific and testable criterion]
+- [ ] [Specific and testable criterion]
+
+### Technical
+- [ ] Unit tests with coverage >= X%
+- [ ] Integration tests implemented
+- [ ] Performance within requirements
+- [ ] Documentation updated
+
+### Quality
+- [ ] Code review approved
+- [ ] No regressions
+- [ ] Accessibility validated
+```
+
+### 7. Out of Scope
+
+```markdown
+## Out of Scope
+
+Features that WILL NOT be implemented in this version:
+- [Item 1]
+- [Item 2]
+
+Justification: [Why these are deferred]
+```
+
+### 8. Risks and Mitigations
+
+```markdown
+## Risks and Mitigations
+
+### Risk 1: [Description]
+- **Probability**: High / Medium / Low
+- **Impact**: High / Medium / Low
+- **Mitigation**: [How to mitigate]
+
+### Risk 2: [Description]
+- **Probability**: High / Medium / Low
+- **Impact**: High / Medium / Low
+- **Mitigation**: [How to mitigate]
+```
+
+### 9. Dependencies
+
+```markdown
+## Dependencies
+
+### Technical
+- [Technical dependency 1]
+- [Technical dependency 2]
+
+### Business
+- [Business dependency 1]
+- [Business dependency 2]
+
+### Blockers
+- [Blocker 1 and plan to resolve]
+```
+
+### 10. Test Plan
+
+```markdown
+## Test Plan
+
+### Unit Tests
+- [Area 1 to be tested]
+- [Area 2 to be tested]
+
+### Integration Tests
+- [Scenario 1]
+- [Scenario 2]
+
+### Manual Tests
+- [Scenario 1]
+- [Scenario 2]
+```
+
+## 📄 Saving the PRD
+
+**PRIORITY 1: Use MCP (Model Context Protocol)**
+
+- Read `ai.properties.md` from the orchestrator to identify the `task_management_system`
+- Use the appropriate MCP to update the issue with the PRD:
+  - Add the complete PRD as a comment on the issue
+  - Or attach as a file (if the task manager supports it)
+  - Update status/labels (e.g., "spec-ready", "ready-for-dev")
+- Inform the user: "✅ PRD added to issue [ID]"
+
+**FALLBACK: Create .md file only if MCP fails**
+
+If MCP is unavailable or fails:
+- Save to `./.sessions/<ISSUE-ID>/prd.md`
+- Inform the user: "⚠️ PRD saved locally in .sessions/ (task manager not available)"
+
+## 🔍 Review and Approval
+
+Before finishing:
+1. Review the PRD with stakeholders
+2. Validate against metaspecs (if available)
+3. Obtain approval to start implementation
+4. **Via MCP**: Update the issue in the task manager with status "Ready for Development"
+5. **Fallback**: Document approval in `./.sessions/<ISSUE-ID>/prd.md`
+
+---
+
+**Provided arguments**:
+
+```
+#$ARGUMENTS
+```
+
+---
+
+## 🎯 Next Step
+
+After PRD approval:
+
+```bash
+/start
+```
+
+This command will start feature development.

package/dist/templates/commands/en/quality/metrics.md

@@ -0,0 +1,240 @@
+# Quality Metrics
+
+This command collects and analyzes quality metrics of the code and the development process.
+
+## 🎯 Objective
+
+Measure and document the quality of the implementation through objective metrics:
+- Test coverage
+- Code complexity
+- Technical debt
+- Performance
+- Compliance with standards
+
+## 📋 Prerequisites
+
+- Implementation completed (after `/work`)
+- Tests implemented
+- Build working
+
+## 📊 Metrics to Collect
+
+### 1. Test Coverage
+
+For each modified repository:
+
+```bash
+cd <repositório>
+
+# Run tests with coverage
+npm run test:coverage  # or equivalent command
+
+# Capture results
+```
+
+Document:
+```markdown
+## Test Coverage
+
+### <repo-1>
+- **Total Coverage**: X%
+- **Statements**: X%
+- **Branches**: X%
+- **Functions**: X%
+- **Lines**: X%
+- **Uncovered Files**: [list]
+
+### <repo-2>
+[Same format]
+```
+
+### 2. Code Complexity
+
+Analyze the cyclomatic complexity of the modified files:
+
+```markdown
+## Code Complexity
+
+### Files with High Complexity
+- **arquivo1.ts**: Complexity 15 (recommended: < 10)
+- **arquivo2.ts**: Complexity 12
+
+### Recommendations
+- [Refactoring suggestion 1]
+- [Refactoring suggestion 2]
+```
+
+### 3. Code Quality
+
+```bash
+# Run linting
+npm run lint
+
+# Check formatting
+npm run format:check
+
+# Static analysis (if available)
+npm run analyze
+```
+
+Document:
+```markdown
+## Code Quality
+
+### Linting
+- **Errors**: 0
+- **Warnings**: X
+- **Justified Warnings**: [list with justifications]
+
+### Formatting
+- **Status**: ✅ Compliant / ⚠️ Adjustments needed
+
+### Static Analysis
+- **Critical Issues**: 0
+- **Medium Issues**: X
+- **Low Issues**: Y
+```
+
+### 4. Performance
+
+If applicable, measure performance:
+
+```markdown
+## Performance
+
+### Benchmarks
+- **Operation X**: Yms (baseline: Zms)
+- **Operation Y**: Yms (baseline: Zms)
+
+### Applied Optimizations
+- [Optimization 1 and impact]
+- [Optimization 2 and impact]
+
+### Identified Bottlenecks
+- [Bottleneck 1 and mitigation plan]
+```
+
+### 5. Size and Impact
+
+```markdown
+## Size and Impact
+
+### Lines of Code
+- **Added**: +X lines
+- **Removed**: -Y lines
+- **Modified**: Z lines
+
+### Files
+- **New**: X files
+- **Modified**: Y files
+- **Removed**: Z files
+
+### Dependencies
+- **New dependencies**: [list]
+- **Bundle size**: +X KB
+```
+
+### 6. Technical Debt
+
+Identify technical debt introduced or resolved:
+
+```markdown
+## Technical Debt
+
+### Introduced Debt
+- **Item 1**: [Description and justification]
+  - Severity: High / Medium / Low
+  - Resolution plan: [when and how to resolve]
+
+### Resolved Debt
+- **Item 1**: [What was resolved]
+  - Impact: [improvement achieved]
+```
+
+## 📄 Metrics Report
+
+Create `./.sessions/<ISSUE-ID>/metrics.md`:
+
+```markdown
+# Metrics Report - [ISSUE-ID]
+
+**Date**: [date/time]
+**Repositories**: [list]
+
+## Executive Summary
+
+- **Test Coverage**: X% (target: Y%)
+- **Code Quality**: ✅ / ⚠️ / ❌
+- **Performance**: ✅ / ⚠️ / ❌
+- **Technical Debt**: Low / Medium / High
+
+## Detailed Metrics
+
+[Include all sections above]
+
+## Comparison with Baseline
+
+| Metric | Before | After | Variation |
+|--------|--------|-------|-----------|
+| Coverage | X% | Y% | +Z% |
+| Average Complexity | X | Y | +Z |
+| Bundle Size | X KB | Y KB | +Z KB |
+
+## Recommended Actions
+
+1. [Action 1 - high priority]
+2. [Action 2 - medium priority]
+3. [Action 3 - low priority]
+
+## Approval for Merge
+
+- [ ] Test coverage >= target
+- [ ] No critical quality issues
+- [ ] Performance within requirements
+- [ ] Technical debt documented and approved
+```
+
+## 🎯 Quality Goals
+
+If the project has goals defined in metaspecs, validate:
+
+```markdown
+## Validation against Goals
+
+### Project Goals
+- **Minimum coverage**: 80%
+- **Maximum complexity**: 10
+- **Performance**: < 100ms
+
+### Status
+- Coverage: ✅ 85% (target: 80%)
+- Complexity: ⚠️ 12 (target: 10) - Justified
+- Performance: ✅ 85ms (target: 100ms)
+```
+
+## 🚨 Alerts
+
+If any metric is out of acceptable range:
+1. 🛑 **DOCUMENT** the problem
+2. 💬 **ALERT** the user
+3. 🔧 **PROPOSE** corrective actions
+4. ⏸️ **CONSIDER** blocking the merge until resolved
+
+---
+
+**Provided arguments**:
+
+```
+#$ARGUMENTS
+```
+
+---
+
+## 🎯 Result
+
+After running this command, you will have:
+- Complete metrics report
+- Comparison with baseline and goals
+- Identification of quality issues
+- Recommended actions
+- Objective basis for merge approval