cursor-devops-commands 1.0.0

package/commands/git/decision-record.md

@@ -0,0 +1,302 @@
+---
+description: Create Architecture Decision Records (ADRs) for technical decisions
+category: Documentation
+aliases: [adr, decision, record]
+---
+
+# Decision Record - Capture Architectural Decisions
+
+Capture important technical and architectural decisions as Architecture Decision Records (ADRs).
+
+**This is the biggest missing piece** — turns tribal knowledge into institutional memory.
+
+## Usage
+
+```
+/decision-record {TITLE}
+/decision-record {TITLE} --context="{TICKET_OR_PR}"
+/decision-record --list                    # List all decisions
+/decision-record --search="{KEYWORD}"      # Search decisions
+```
+
+## Examples
+
+```
+/decision-record "Use React Query for data fetching"
+/decision-record "Split ProtectionPackageCard into sub-components" --context="TICKET-123"
+/decision-record "Migrate from styled-components to CSS modules" --context="PR#23100"
+```
+
+## Why This Matters
+
+Without decision records:
+
+-   ❌ Repeated debates on the same topics
+-   ❌ Inconsistent enforcement
+-   ❌ Loss of architectural intent
+-   ❌ "Why was this done?" questions forever
+
+With decision records:
+
+-   ✅ Single source of truth
+-   ✅ Onboarding accelerated
+-   ✅ Consistent enforcement
+-   ✅ Architectural alignment
+
+## What This Creates
+
+Creates a file at: `/docs/decisions/ADR-{NUMBER}-{slug}.md`
+
+```markdown
+# ADR-042: Use React Query for Data Fetching
+
+## Status
+
+Accepted | Proposed | Deprecated | Superseded by ADR-XXX
+
+## Date
+
+2024-12-23
+
+## Context
+
+What is the issue that we're seeing that is motivating this decision?
+
+## Decision
+
+What is the change that we're proposing and/or doing?
+
+## Consequences
+
+What becomes easier or more difficult to do because of this change?
+
+## Alternatives Considered
+
+What other options were evaluated?
+
+## Evidence
+
+Links to PRs, metrics, incidents, or discussions that informed this decision.
+```
+
+## Decision Record Format
+
+```
+════════════════════════════════════════════════════════════════
+  DECISION RECORD: {TITLE}
+════════════════════════════════════════════════════════════════
+
+📋 CONTEXT
+  Triggered by: {ticket/PR/discussion}
+  Problem: {what issue we're solving}
+  Scope: {what areas this affects}
+
+🤔 OPTIONS CONSIDERED
+
+  Option A: {description}
+    ✅ Pros: {benefits}
+    ❌ Cons: {drawbacks}
+    📊 Evidence: {data/examples}
+
+  Option B: {description}
+    ✅ Pros: {benefits}
+    ❌ Cons: {drawbacks}
+    📊 Evidence: {data/examples}
+
+  Option C: {description}
+    ✅ Pros: {benefits}
+    ❌ Cons: {drawbacks}
+    📊 Evidence: {data/examples}
+
+✅ DECISION
+  Chosen: Option {X}
+  Rationale: {why this option}
+
+⚖️ TRADEOFFS
+  We accept:
+    - {tradeoff_1}
+    - {tradeoff_2}
+  In exchange for:
+    - {benefit_1}
+    - {benefit_2}
+
+📈 SUCCESS CRITERIA
+  - {metric_1}
+  - {metric_2}
+
+🔗 REFERENCES
+  - Jira: {ticket}
+  - PR: #{number}
+  - Confluence: {link}
+  - Incident: {if applicable}
+
+════════════════════════════════════════════════════════════════
+```
+
+## Common Decision Categories
+
+### Architecture Decisions
+
+-   State management approach
+-   Data fetching patterns
+-   Component structure
+-   Module boundaries
+-   API design
+
+### Technology Decisions
+
+-   Library choices
+-   Build tool changes
+-   Testing frameworks
+-   Styling approaches
+
+### Process Decisions
+
+-   Code review standards
+-   PR size limits
+-   Branch strategy
+-   Release process
+
+### Migration Decisions
+
+-   Deprecation plans
+-   Upgrade paths
+-   Breaking changes
+
+## AI Execution
+
+When user runs `/decision-record {TITLE}`:
+
+### Step 1: Gather Context
+
+```
+I'll help you document this decision.
+
+1. What problem or question prompted this decision?
+2. What options did you consider?
+3. What did you decide and why?
+4. What are the tradeoffs?
+```
+
+### Step 2: Generate ADR
+
+```bash
+# Determine next ADR number
+NEXT_NUM=$(ls docs/decisions/ADR-*.md 2>/dev/null | wc -l | xargs -I{} expr {} + 1)
+
+# Create ADR file
+touch docs/decisions/ADR-${NEXT_NUM}-{slug}.md
+```
+
+### Step 3: Link to Context
+
+```bash
+# If Jira ticket provided
+jira issue comment add {TICKET} "📝 Decision recorded: ADR-${NEXT_NUM}"
+
+# If PR provided
+gh pr comment {PR} --body "📝 Decision recorded: ADR-${NEXT_NUM}"
+```
+
+### Step 4: Confirm
+
+```
+════════════════════════════════════════════════════════════════
+  ✅ DECISION RECORDED
+════════════════════════════════════════════════════════════════
+
+📄 File: docs/decisions/ADR-042-use-react-query-for-data-fetching.md
+🔗 Linked to: TICKET-123, PR #23043
+
+This decision is now:
+  - Searchable in the codebase
+  - Referenced in project docs
+  - Available for future discussions
+
+View all decisions: /decision-record --list
+```
+
+## Decision Lifecycle
+
+```
+┌──────────┐     ┌──────────┐     ┌──────────┐     ┌────────────┐
+│ Proposed │ ──▶ │ Accepted │ ──▶ │ Active   │ ──▶ │ Deprecated │
+└──────────┘     └──────────┘     └──────────┘     └────────────┘
+                                        │
+                                        ▼
+                                  ┌────────────────┐
+                                  │ Superseded by  │
+                                  │ ADR-XXX        │
+                                  └────────────────┘
+```
+
+## Searching Decisions
+
+```
+/decision-record --search="state management"
+```
+
+Output:
+
+```
+════════════════════════════════════════════════════════════════
+  DECISIONS MATCHING: "state management"
+════════════════════════════════════════════════════════════════
+
+1. ADR-015: Use Context for shared component state (Active)
+   Date: 2024-03-15
+   Scope: Component-level state
+
+2. ADR-023: Use React Query for server state (Active)
+   Date: 2024-06-20
+   Scope: API data caching
+
+3. ADR-008: Redux for global app state (Deprecated)
+   Date: 2023-09-10
+   Superseded by: ADR-023
+
+View details: /decision-record --view=ADR-023
+```
+
+## Quick Decision Template
+
+For informal decisions that don't need full ADR:
+
+```
+/decision-record "Use OXTypography for all text" --quick
+```
+
+Creates a lightweight record:
+
+```markdown
+# Quick Decision: Use OXTypography for all text
+
+**Date:** 2024-12-23
+**Decided by:** @team-lead
+**Reason:** Consistency with design system, automatic theme support
+**Enforcement:** Code review, linting rule
+```
+
+## Integration with Other Commands
+
+| Command                     | Integration                                               |
+| --------------------------- | --------------------------------------------------------- |
+| `/full-flow`                | Prompts for decision record if significant pattern change |
+| `/refactor-new`             | Links to relevant ADRs before refactoring                 |
+| `/pr-review --architecture` | Checks alignment with ADRs                                |
+| `/pattern-drift`            | Flags violations of recorded decisions                    |
+| `/learn-from-prs`           | Suggests new ADRs based on repeated patterns              |
+
+## Directory Structure
+
+```
+docs/
+└── decisions/
+    ├── README.md           # Index and guidelines
+    ├── ADR-001-*.md
+    ├── ADR-002-*.md
+    ├── ...
+    └── templates/
+        ├── full-adr.md
+        └── quick-decision.md
+```

package/commands/git/find-shared.md

@@ -0,0 +1,104 @@
+# Find Similar Code to Reuse
+
+## Overview
+
+Search the monorepo for similar code patterns, components, utilities, or logic that can be reused instead of reimplementing. Helps maintain DRY principles and identify opportunities for code sharing across apps and libraries.
+
+## Analyze Current Context
+
+### Understanding the Need
+
+-   [ ] What is the core functionality required?
+-   [ ] What problem does it solve?
+-   [ ] Are there similar features already implemented in other parts of the codebase?
+-   [ ] Is this UI component, business logic, utility function, or API client?
+
+### Search Priority by Type
+
+**For UI Components:**
+
+1. Check OXIDE design system first: `src/design-system/src/ui/components/`
+2. Check shared business components: `src/components/src/components/`
+3. Search domain libraries: `libraries/yourcompany/*/src/components/`
+4. Look in similar apps: `apps/*/src/components/`
+
+**For Utilities/Helpers:**
+
+1. Common utilities: `libraries/core/core-common/src/` (datetime, validation, encoding, helper)
+2. Browser utilities: `libraries/core/core-browser/src/` (storage, URL, device, hooks)
+3. Business utilities: `libraries/yourcompany/*/src/utils/` or `*/src/helpers/`
+
+**For API Clients:**
+
+1. Existing API libraries: `libraries/yourcompany/api-*/`
+2. Check naming pattern: `api-{service-name}`
+
+**For Hooks:**
+
+1. Common hooks: `libraries/core/core-common/src/hooks/`
+2. Browser hooks: `libraries/core/core-browser/src/hooks/`
+3. Business hooks: `libraries/yourcompany/*/src/hooks/`
+
+**For Types/Interfaces:**
+
+1. Common data models: `libraries/core/core-common/src/dataModels/`
+2. Domain types: `libraries/yourcompany/*/src/types/` or `*/src/dataModels/`
+
+**For Styling:**
+
+1. Design tokens: `src/design-system/src/utils/` (spacing, color, borderRadius, rem)
+2. Enums: `src/design-system/src/enums/` (OXBiggerThan, Kind)
+
+### Search Strategies
+
+**Semantic Search** (use codebase_search tool):
+
+-   "How does [similar feature] work?"
+-   "Where is [functionality] implemented?"
+-   "What components handle [use case]?"
+-   "Which utilities exist for [purpose]?"
+
+**Pattern Search** (use grep tool):
+
+-   Find similar function names
+-   Search for interface patterns
+-   Look for hook implementations
+-   Find component usage patterns
+
+### Decision Framework
+
+**✅ Reuse if:**
+
+-   Matches 80%+ of requirements
+-   Minimal modifications needed
+
+**🔧 Adapt if:**
+
+-   Matches 60-80% of requirements
+-   Can be extended without breaking changes
+-   Located in appropriate library
+
+**🆕 Create new if:**
+
+-   No similar implementation exists
+-   Existing code is deprecated or low quality
+-   Requirements differ significantly (>50%)
+-   Modifications would be too extensive
+
+**📦 Extract to library if:**
+
+-   Similar code exists in 2+ apps
+-   Functionality is generic and stable
+-   Can benefit other teams
+
+## Output Format
+
+Provide findings in this structure:
+
+### Found Similar Code
+
+**Location**: `path/to/file`
+**Match %**: 85%
+**Pros**: [List benefits]
+**Cons**: [List limitations]
+**Recommendation**: Reuse / Modify / Create New

package/commands/git/suggest-reviewers.md

@@ -0,0 +1,237 @@
+---
+description: Suggest optimal PR reviewers based on CODEOWNERS, expertise, and availability
+category: PR Management
+aliases: [reviewers, who-reviews]
+---
+
+# Suggest Reviewers - Smart Reviewer Selection
+
+Intelligently suggest optimal reviewers based on code ownership, expertise, and availability.
+
+## Usage
+
+```
+/suggest-reviewers
+/suggest-reviewers {PR_NUMBER}
+/suggest-reviewers --add  # Auto-add suggested reviewers
+```
+
+## How It Works
+
+### 1. Analyze Changed Files
+
+```bash
+# Get files changed in PR
+gh pr view {PR} --json files --jq '.files[].path'
+```
+
+### 2. Map to CODEOWNERS
+
+```bash
+# For each file, find owner
+for file in $(gh pr view {PR} --json files --jq '.files[].path'); do
+  grep "$file" .github/CODEOWNERS | awk '{print $NF}'
+done
+```
+
+### 3. Check Expertise (Git History)
+
+```bash
+# Find developers with most commits in affected files
+git log --format='%an' --since='6 months ago' -- {FILE} | sort | uniq -c | sort -rn
+```
+
+### 4. Check Availability
+
+```bash
+# Check reviewer workload (open review requests)
+gh api graphql -f query='
+  query {
+    user(login: "{USERNAME}") {
+      pullRequests(states: OPEN, first: 10) {
+        totalCount
+      }
+    }
+  }
+'
+```
+
+## Suggestion Output
+
+```
+════════════════════════════════════════════════════════════════
+  📋 REVIEWER SUGGESTIONS FOR PR #23043
+════════════════════════════════════════════════════════════════
+
+Files changed: 6 files across 3 teams
+
+════════════════════════════════════════════════════════════════
+  RECOMMENDED REVIEWERS
+════════════════════════════════════════════════════════════════
+
+🥇 PRIMARY (Required - CODEOWNER)
+┌─────────────────────────────────────────────────────────────┐
+│ @team-lead                                      │
+│ Team: @YourOrg/team-a                                     │
+│ Owns: src/features/checkout/* (4 files changed)                │
+│ Expertise: 45 commits in affected files                     │
+│ Workload: 2 pending reviews (✅ Available)                  │
+└─────────────────────────────────────────────────────────────┘
+
+🥈 SECONDARY (Recommended)
+┌─────────────────────────────────────────────────────────────┐
+│ @teammate-1                                                 │
+│ Team: @YourOrg/team-b                                │
+│ Owns: src/components/* (2 files)           │
+│ Expertise: 30 commits in affected files                     │
+│ Workload: 1 pending review (✅ Available)                   │
+└─────────────────────────────────────────────────────────────┘
+
+🥉 OPTIONAL (Good to have)
+┌─────────────────────────────────────────────────────────────┐
+│ @senior-dev                                                 │
+│ Team: @YourOrg/platform                               │
+│ Reason: Recent work on similar tooltip feature              │
+│ Expertise: 12 commits in affected patterns                  │
+│ Workload: 5 pending reviews (⚠️ Busy)                       │
+└─────────────────────────────────────────────────────────────┘
+
+════════════════════════════════════════════════════════════════
+  SKIP SUGGESTIONS
+════════════════════════════════════════════════════════════════
+
+❌ @busy-dev - 8 pending reviews (overloaded)
+❌ @vacation-dev - OOO until Jan 5
+❌ @new-dev - < 1 month on team (limited context)
+
+════════════════════════════════════════════════════════════════
+
+Add recommended reviewers? (y/n)
+  - Primary: @team-lead
+  - Secondary: @teammate-1
+```
+
+## Selection Criteria
+
+### Scoring System
+
+| Factor       | Weight | Description                     |
+| ------------ | ------ | ------------------------------- |
+| CODEOWNER    | 40%    | Required for files they own     |
+| Expertise    | 25%    | Commits in affected files (6mo) |
+| Recency      | 15%    | Recent work in area             |
+| Availability | 15%    | Pending review count            |
+| Team Balance | 5%     | Avoid overloading one person    |
+
+### Expertise Score
+
+```
+Commits in last 6 months:
+  50+ commits → Expert (score: 100)
+  20-49 commits → Proficient (score: 75)
+  5-19 commits → Familiar (score: 50)
+  1-4 commits → Aware (score: 25)
+  0 commits → Unknown (score: 0)
+```
+
+### Availability Score
+
+```
+Pending reviews:
+  0-2 reviews → Available (score: 100)
+  3-4 reviews → Moderate (score: 70)
+  5-6 reviews → Busy (score: 40)
+  7+ reviews → Overloaded (score: 10)
+```
+
+## Smart Features
+
+### 1. Cross-Team Coverage
+
+```
+Your PR affects multiple teams:
+  - @YourOrg/team-a (4 files)
+  - @YourOrg/team-b (2 files)
+
+Suggesting one reviewer from each team for complete coverage.
+```
+
+### 2. Related PR Context
+
+```
+Found related PRs by these developers:
+  - @teammate-1: PR #22900 (similar tooltip work)
+  - @senior-dev: PR #22800 (ProtectionPackageCard refactor)
+
+Consider adding for context continuity.
+```
+
+### 3. Review History
+
+```
+Previous reviewers for this component:
+  - @team-lead (reviewed 5 PRs)
+  - @teammate-1 (reviewed 3 PRs)
+
+Maintaining consistency with established reviewers.
+```
+
+### 4. Load Balancing
+
+```
+Team review distribution (this week):
+  @team-lead: 8 reviews
+  @teammate-1: 3 reviews
+  @teammate-2: 2 reviews
+
+Suggesting @teammate-2 to balance load.
+```
+
+## Commands Reference
+
+```bash
+# Add reviewers to PR
+gh pr edit {PR} --add-reviewer @user1,@user2
+
+# Check current reviewers
+gh pr view {PR} --json reviewRequests
+
+# Check user's pending reviews
+gh api /users/{USER}/received_events | jq '[.[] | select(.type=="PullRequestReviewEvent")] | length'
+```
+
+## Integration with /full-flow
+
+After PR creation:
+
+```
+════════════════════════════════════════════════════════════════
+  📤 PR CREATED: #23043
+════════════════════════════════════════════════════════════════
+
+Suggested reviewers based on files changed:
+  ✅ @team-lead (CODEOWNER, available)
+  ✅ @teammate-1 (expertise in area)
+
+Add these reviewers? (y/n)
+```
+
+## Auto-Add Mode
+
+```
+/suggest-reviewers --add
+```
+
+Automatically adds:
+
+-   All CODEOWNER reviewers (required)
+-   Top 1-2 expertise-based reviewers
+-   Skips overloaded reviewers
+
+## Learning
+
+I remember your preferences:
+
+-   "always add @team-lead" → Added to default list
+-   "never add @slow-reviewer" → Excluded from suggestions
+-   "prefer @fast-reviewer" → Boosted in scoring