devflow-kit 0.9.0 → 1.0.0

package/src/claude/commands/devflow/code-review.md

@@ -1,237 +0,0 @@
----
-description: Comprehensive branch review using specialized sub-agents for PR readiness
-allowed-tools: Task, Bash, Read, Grep, Glob
----
-
-## Your Task
-
-Orchestrate specialized audit sub-agents to review the current branch, then synthesize findings into PR comments and tech debt tracking.
-
----
-
-## Phase 1: Setup
-
-```bash
-# Get current branch for directory naming
-CURRENT_BRANCH=$(git branch --show-current)
-BRANCH_SLUG=$(echo "${CURRENT_BRANCH:-standalone}" | sed 's/\//-/g')
-
-# Coordination variables (shared across all sub-agents)
-TIMESTAMP=$(date +%Y-%m-%d_%H%M)
-AUDIT_BASE_DIR=".docs/audits/${BRANCH_SLUG}"
-mkdir -p "$AUDIT_BASE_DIR"
-
-# Detect project type for conditional audits
-HAS_TYPESCRIPT=false
-[ -f "tsconfig.json" ] && HAS_TYPESCRIPT=true
-
-HAS_DB_CHANGES=false
-git diff --name-only HEAD~10..HEAD 2>/dev/null | grep -qiE '(migration|schema|\.sql|prisma|drizzle|knex)' && HAS_DB_CHANGES=true
-
-echo "=== CODE REVIEW ==="
-echo "📁 Reports: $AUDIT_BASE_DIR"
-echo "⏱️  Timestamp: $TIMESTAMP"
-echo "📦 TypeScript: $HAS_TYPESCRIPT"
-echo "🗄️  Database: $HAS_DB_CHANGES"
-```
-
----
-
-## Phase 2: Run Audit Sub-Agents (Parallel)
-
-Launch ALL applicable audit sub-agents in a **single message** using multiple Task tool calls for parallel execution.
-
-**IMPORTANT:** You MUST launch these as parallel Task calls in ONE message.
-
-**Always Launch (7 core audits):**
-
-1. **audit-security**
-   ```
-   Analyze branch for security issues. Compare against base branch.
-   Save report to: ${AUDIT_BASE_DIR}/security-report.${TIMESTAMP}.md
-   ```
-
-2. **audit-performance**
-   ```
-   Analyze branch for performance issues. Compare against base branch.
-   Save report to: ${AUDIT_BASE_DIR}/performance-report.${TIMESTAMP}.md
-   ```
-
-3. **audit-architecture**
-   ```
-   Analyze branch for architecture issues. Compare against base branch.
-   Save report to: ${AUDIT_BASE_DIR}/architecture-report.${TIMESTAMP}.md
-   ```
-
-4. **audit-tests**
-   ```
-   Analyze branch for test coverage and quality issues. Compare against base branch.
-   Save report to: ${AUDIT_BASE_DIR}/tests-report.${TIMESTAMP}.md
-   ```
-
-5. **audit-complexity**
-   ```
-   Analyze branch for code complexity issues. Compare against base branch.
-   Save report to: ${AUDIT_BASE_DIR}/complexity-report.${TIMESTAMP}.md
-   ```
-
-6. **audit-dependencies**
-   ```
-   Analyze branch for dependency issues. Compare against base branch.
-   Save report to: ${AUDIT_BASE_DIR}/dependencies-report.${TIMESTAMP}.md
-   ```
-
-7. **audit-documentation**
-   ```
-   Analyze branch for documentation issues. Compare against base branch.
-   Save report to: ${AUDIT_BASE_DIR}/documentation-report.${TIMESTAMP}.md
-   ```
-
-**Conditional Audits:**
-
-8. **audit-typescript** (if HAS_TYPESCRIPT=true)
-   ```
-   Analyze branch for TypeScript issues. Compare against base branch.
-   Save report to: ${AUDIT_BASE_DIR}/typescript-report.${TIMESTAMP}.md
-   ```
-
-9. **audit-database** (if HAS_DB_CHANGES=true)
-   ```
-   Analyze branch for database issues. Compare against base branch.
-   Save report to: ${AUDIT_BASE_DIR}/database-report.${TIMESTAMP}.md
-   ```
-
----
-
-## Phase 3: Synthesis (After Audits Complete)
-
-**WAIT for all Phase 2 audits to complete before proceeding.**
-
-After all audit sub-agents have finished, launch THREE synthesis sub-agents in **parallel**:
-
-### 3.1 code-review sub-agent (Summary Report)
-
-```
-Generate code review summary for branch ${CURRENT_BRANCH}.
-
-Context:
-- Branch: ${CURRENT_BRANCH}
-- Base: ${BASE_BRANCH}
-- Audit Directory: ${AUDIT_BASE_DIR}
-- Timestamp: ${TIMESTAMP}
-
-Tasks:
-1. Read all audit reports from ${AUDIT_BASE_DIR}/*-report.${TIMESTAMP}.md
-2. Extract and categorize all issues (🔴/⚠️/ℹ️)
-3. Generate summary report at ${AUDIT_BASE_DIR}/review-summary.${TIMESTAMP}.md
-4. Determine merge recommendation
-
-Report back: Merge recommendation and issue counts
-```
-
-### 3.2 pr-comments sub-agent (PR Comments)
-
-```
-Create PR comments for code review findings on branch ${CURRENT_BRANCH}.
-
-Context:
-- Branch: ${CURRENT_BRANCH}
-- Audit Directory: ${AUDIT_BASE_DIR}
-- Timestamp: ${TIMESTAMP}
-
-Tasks:
-1. Read all audit reports from ${AUDIT_BASE_DIR}/*-report.${TIMESTAMP}.md
-2. Ensure PR exists (create draft if missing)
-3. Create individual comments for all 🔴 blocking issues
-4. Create individual comments for all ⚠️ should-fix issues
-5. Include suggested fixes with code examples
-6. Show pros/cons table when multiple approaches exist
-7. Add Claude Code attribution to each comment
-
-Report back: PR number and count of comments created
-```
-
-### 3.3 tech-debt sub-agent (Tech Debt Management)
-
-```
-Manage tech debt for code review on branch ${CURRENT_BRANCH}.
-
-Context:
-- Branch: ${CURRENT_BRANCH}
-- Audit Directory: ${AUDIT_BASE_DIR}
-- Timestamp: ${TIMESTAMP}
-
-Tasks:
-1. Read all audit reports from ${AUDIT_BASE_DIR}/*-report.${TIMESTAMP}.md
-2. Find or create Tech Debt Backlog issue
-3. Check if archive needed (approaching 60k char limit)
-4. Add new ℹ️ pre-existing issues (deduplicated)
-5. Check existing items - remove those that are fixed
-6. Update issue with changes
-
-Report back: Issue number, items added, items removed
-```
-
-**IMPORTANT:** Launch all THREE synthesis sub-agents in a SINGLE message for parallel execution.
-
----
-
-## Phase 4: Present Results
-
-After ALL synthesis sub-agents complete, consolidate their reports and display final summary:
-
-```markdown
-🔍 CODE REVIEW COMPLETE
-
-**Branch**: ${CURRENT_BRANCH}
-**Audits**: {count} specialized audits completed
-
----
-
-## 🚦 Merge Status: {RECOMMENDATION from code-review agent}
-
----
-
-## 📊 Issues Found
-
-| Category | Count | Action |
-|----------|-------|--------|
-| 🔴 Blocking | {count} | Must fix before merge |
-| ⚠️ Should Fix | {count} | Fix while you're here |
-| ℹ️ Pre-existing | {count} | Managed in tech debt |
-
----
-
-## 📝 Artifacts Created
-
-- **Summary**: `${AUDIT_BASE_DIR}/review-summary.${TIMESTAMP}.md`
-- **PR Comments**: {count} comments on PR #{number from pr-comments agent}
-- **Tech Debt**: Issue #{number from tech-debt agent}
-  - Added: {count} new items
-  - Removed: {count} fixed items
-
----
-
-## 🎯 Next Steps
-
-{If BLOCK MERGE:}
-1. Review PR comments for fix suggestions
-2. Address 🔴 blocking issues
-3. Re-run `/code-review` to verify
-
-{If APPROVED:}
-1. Review ⚠️ suggestions (optional)
-2. Create commits: `/commit`
-3. Create PR: `/pull-request`
-```
-
----
-
-## Orchestration Rules
-
-1. **Phase 2 is parallel** - Launch ALL audit sub-agents in a single message
-2. **Phase 3 is parallel** - Launch ALL synthesis sub-agents in a single message (after Phase 2)
-3. **Don't read reports yourself** - Sub-agents handle all file reading
-4. **Don't create artifacts yourself** - Each sub-agent creates its own outputs
-5. **Pass context accurately** - Ensure AUDIT_BASE_DIR and TIMESTAMP reach all sub-agents
-6. **Consolidate results** - Combine reports from all three synthesis agents for final output

package/src/claude/commands/devflow/commit.md

@@ -1,17 +0,0 @@
----
-allowed-tools: Task
-description: Create intelligent atomic commits with safety checks and clean git history
----
-
-## Your task
-
-Launch the `commit` sub-agent to analyze changes, detect safety issues, group into atomic commits, and **execute them immediately**.
-
-The agent will:
-1. Analyze uncommitted changes
-2. Run safety checks (abort if secrets/dangerous files found)
-3. Group into logical atomic commits
-4. **Execute commits without asking for confirmation**
-5. Report what was committed
-
-Trust the agent's judgment. It will only abort for genuine safety issues (secrets, credentials).

package/src/claude/commands/devflow/debug.md

@@ -1,56 +0,0 @@
----
-allowed-tools: Task
-description: Systematic debugging workflow with issue tracking - use '/debug [issue description]'
----
-
-## Your task
-
-Launch the `debug` sub-agent to conduct systematic debugging for: `$ARGUMENTS`
-
-If no arguments provided, prompt the user for the issue description.
-
-### Debugging Process
-
-The debug agent will:
-
-1. **Capture the Problem** - Create debug session tracking with unique session ID
-2. **Document the Issue** - Create comprehensive debug log in `.docs/debug/`
-3. **Smart Investigation** - Detect issue type (error/performance/test/build) and adapt strategy
-4. **Generate Hypotheses** - Create targeted, testable hypotheses based on issue type
-5. **Systematic Testing** - Test each hypothesis methodically and document findings
-6. **Root Cause Analysis** - Identify precise root cause with file and line references
-7. **Implement Fix** - Design, implement, and verify the solution
-8. **Prevention Strategy** - Document how to prevent similar issues
-9. **Update Knowledge Base** - Add to searchable `.docs/debug/KNOWLEDGE_BASE.md`
-
-### Next: Synthesize Results
-
-After the sub-agent completes, present a concise summary to the user:
-
-```markdown
-🔍 DEBUG SESSION COMPLETE: $ARGUMENTS
-
-## 🎯 ROOT CAUSE
-{Precise description with file:line}
-
-## ✅ SOLUTION APPLIED
-{Description of fix}
-
-## 📝 VERIFICATION
-{Test results showing fix works}
-
-## 🛡️ PREVENTION
-{How to prevent similar issues}
-
-## 📄 DOCUMENTATION
-- Debug log: `.docs/debug/{SESSION_ID}.md`
-- Knowledge base: `.docs/debug/KNOWLEDGE_BASE.md`
-
-📄 Full debugging details available from sub-agent output above
-```
-
-💡 **Usage Examples**:
-- `/debug "TypeError: Cannot read property 'name' of undefined"`
-- `/debug tests failing after npm update`
-- `/debug app crashes on startup`
-- `/debug slow performance in search feature`

package/src/claude/commands/devflow/design.md

@@ -1,82 +0,0 @@
----
-allowed-tools: Task
-description: Create detailed implementation design with integration points and edge cases - use '/design [feature description]'
----
-
-## Your task
-
-Launch the `design` sub-agent to create a detailed implementation design for: `$ARGUMENTS`
-
-If no arguments provided, use the previous discussion context to infer the feature, or prompt the user for the feature to design.
-
-### Design Process
-
-The design agent will:
-
-1. **Analyze Existing Patterns** - Study code style, architecture, and reusable components
-2. **Map Integration Points** - Identify all places new feature touches existing code
-3. **Handle Edge Cases** - Surface non-obvious scenarios and error conditions
-4. **Avoid Duplication** - Find existing code to reuse instead of recreating
-5. **Create Implementation Plan** - Step-by-step guide with file references
-
-### Next: Present Implementation Design
-
-After the sub-agent completes, present a concise summary to the user:
-
-```markdown
-🎨 DESIGN COMPLETE: $ARGUMENTS
-
-## 📐 IMPLEMENTATION OVERVIEW
-
-{High-level summary of the design}
-
-## 🔗 INTEGRATION POINTS
-
-{Where this connects to existing code}
-- {module/file}: {what needs updating}
-- {module/file}: {what needs updating}
-
-## 🎯 CORE COMPONENTS
-
-{New code to create}
-1. {component}: {purpose and location}
-2. {component}: {purpose and location}
-
-## ⚠️ EDGE CASES HANDLED
-
-{Non-obvious scenarios to account for}
-- {scenario}: {how to handle}
-- {scenario}: {how to handle}
-
-## ♻️ CODE REUSE OPPORTUNITIES
-
-{Existing code to leverage}
-- {file:function}: {what it does, how to use}
-
-## 📝 IMPLEMENTATION STEPS
-
-{Ordered sequence to implement}
-1. {step with file references}
-2. {step with file references}
-
-## 🧪 TESTING STRATEGY
-
-{How to test this implementation}
-
-📄 Full design document available from sub-agent output above
-```
-
-💡 **Usage Examples**:
-- `/design user authentication with JWT`
-- `/design file upload with validation`
-- `/design real-time sync engine`
-- `/design search with filters and pagination`
-
-**When to use `/brainstorm` vs `/design`**:
-- **Brainstorm** = "What approach should we take?" (architecture decisions)
-- **Design** = "How should we implement it?" (detailed implementation plan)
-
-**Typical workflow**:
-1. `/brainstorm` - Explore approaches and make design decisions
-2. `/design` - Create detailed implementation plan based on chosen approach
-3. `/implement` - Execute the plan with continuous user interaction