pmp-gywd 3.3.0

package/get-your-work-done/core/profile-schema.json

@@ -0,0 +1,257 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "GYWD Developer Profile Schema",
+  "description": "Schema for the Developer Digital Twin",
+  "type": "object",
+  "properties": {
+    "version": {
+      "type": "string",
+      "const": "2.0.0"
+    },
+    "metadata": {
+      "type": "object",
+      "properties": {
+        "developer": { "type": "string" },
+        "created_at": { "type": "string", "format": "date-time" },
+        "last_updated": { "type": "string", "format": "date-time" },
+        "data_sources": {
+          "type": "array",
+          "items": {
+            "enum": ["git_history", "code_patterns", "explicit_input", "behavior_observation"]
+          }
+        }
+      }
+    },
+    "cognitive": {
+      "type": "object",
+      "description": "Cognitive fingerprint - how the developer thinks",
+      "properties": {
+        "problem_approach": {
+          "type": "object",
+          "properties": {
+            "style": {
+              "enum": ["top_down", "bottom_up", "middle_out", "mixed"],
+              "description": "How they typically approach problems"
+            },
+            "confidence": { "type": "number" }
+          }
+        },
+        "abstraction_preference": {
+          "type": "object",
+          "properties": {
+            "level": {
+              "enum": ["concrete", "abstract", "balanced"],
+              "description": "Preference for concrete vs abstract thinking"
+            },
+            "confidence": { "type": "number" }
+          }
+        },
+        "detail_orientation": {
+          "type": "object",
+          "properties": {
+            "level": {
+              "enum": ["big_picture", "detail_focused", "balanced"],
+              "description": "Focus on details vs big picture"
+            },
+            "confidence": { "type": "number" }
+          }
+        },
+        "risk_tolerance": {
+          "type": "object",
+          "properties": {
+            "level": {
+              "enum": ["conservative", "moderate", "aggressive"],
+              "description": "Willingness to take technical risks"
+            },
+            "confidence": { "type": "number" }
+          }
+        },
+        "learning_style": {
+          "type": "object",
+          "properties": {
+            "preference": {
+              "enum": ["documentation", "examples", "experimentation", "discussion"],
+              "description": "How they prefer to learn new things"
+            },
+            "confidence": { "type": "number" }
+          }
+        }
+      }
+    },
+    "expertise": {
+      "type": "object",
+      "description": "Expertise topology - what they know well",
+      "properties": {
+        "languages": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": { "type": "string" },
+              "proficiency": { "enum": ["novice", "intermediate", "advanced", "expert"] },
+              "lines_written": { "type": "integer" },
+              "confidence": { "type": "number" }
+            }
+          }
+        },
+        "frameworks": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": { "type": "string" },
+              "proficiency": { "enum": ["novice", "intermediate", "advanced", "expert"] },
+              "usage_count": { "type": "integer" },
+              "confidence": { "type": "number" }
+            }
+          }
+        },
+        "domains": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": { "type": "string" },
+              "depth": { "enum": ["surface", "working", "deep", "expert"] },
+              "evidence": { "type": "array", "items": { "type": "string" } },
+              "confidence": { "type": "number" }
+            }
+          }
+        },
+        "architectural_patterns": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "pattern": { "type": "string" },
+              "familiarity": { "enum": ["aware", "used", "proficient", "expert"] },
+              "times_applied": { "type": "integer" }
+            }
+          }
+        }
+      }
+    },
+    "preferences": {
+      "type": "object",
+      "description": "Style and workflow preferences",
+      "properties": {
+        "code_style": {
+          "type": "object",
+          "properties": {
+            "naming_convention": {
+              "enum": ["camelCase", "snake_case", "PascalCase", "mixed"],
+              "description": "Preferred naming convention"
+            },
+            "comment_density": {
+              "enum": ["minimal", "moderate", "heavy"],
+              "description": "How much they comment code"
+            },
+            "function_size": {
+              "enum": ["small", "medium", "large"],
+              "description": "Typical function length preference"
+            },
+            "abstraction_eagerness": {
+              "enum": ["early", "when_needed", "late"],
+              "description": "When they create abstractions"
+            }
+          }
+        },
+        "workflow": {
+          "type": "object",
+          "properties": {
+            "commit_frequency": {
+              "enum": ["frequent_small", "moderate", "large_batches"],
+              "description": "How often they commit"
+            },
+            "test_approach": {
+              "enum": ["tdd", "test_after", "minimal_testing"],
+              "description": "Testing approach"
+            },
+            "documentation_timing": {
+              "enum": ["upfront", "as_you_go", "after_implementation"],
+              "description": "When they write docs"
+            },
+            "review_preference": {
+              "enum": ["self_review", "peer_review", "automated_only"],
+              "description": "Code review preferences"
+            }
+          }
+        },
+        "communication": {
+          "type": "object",
+          "properties": {
+            "detail_level": {
+              "enum": ["brief", "moderate", "detailed"],
+              "description": "How much detail they want in explanations"
+            },
+            "format_preference": {
+              "enum": ["prose", "bullets", "code_examples", "mixed"],
+              "description": "Preferred output format"
+            },
+            "interruption_tolerance": {
+              "enum": ["low", "medium", "high"],
+              "description": "Tolerance for confirmations/questions"
+            }
+          }
+        }
+      }
+    },
+    "work_patterns": {
+      "type": "object",
+      "description": "Temporal and behavioral patterns",
+      "properties": {
+        "active_hours": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "day": { "enum": ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"] },
+              "peak_hours": { "type": "array", "items": { "type": "integer", "minimum": 0, "maximum": 23 } }
+            }
+          }
+        },
+        "session_length": {
+          "type": "object",
+          "properties": {
+            "typical_minutes": { "type": "integer" },
+            "variation": { "enum": ["consistent", "variable", "highly_variable"] }
+          }
+        },
+        "focus_areas": {
+          "type": "array",
+          "description": "Code areas they work on most",
+          "items": {
+            "type": "object",
+            "properties": {
+              "area": { "type": "string" },
+              "percentage": { "type": "number" },
+              "commit_count": { "type": "integer" }
+            }
+          }
+        }
+      }
+    },
+    "decision_patterns": {
+      "type": "object",
+      "description": "How they make technical decisions",
+      "properties": {
+        "typical_considerations": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "What they typically consider when deciding"
+        },
+        "priority_order": {
+          "type": "array",
+          "items": {
+            "enum": ["performance", "maintainability", "simplicity", "correctness", "security", "cost", "time_to_market"]
+          },
+          "description": "Priority ordering of concerns"
+        },
+        "change_tolerance": {
+          "enum": ["resistant", "cautious", "open", "eager"],
+          "description": "Openness to changing existing code"
+        }
+      }
+    }
+  }
+}

package/get-your-work-done/references/adaptive-decomposition.md

@@ -0,0 +1,175 @@
+# Adaptive Task Decomposition Reference
+
+## Overview
+
+Adaptive task decomposition automatically adjusts task granularity based on detected complexity. Simple tasks stay simple; complex tasks get broken down further.
+
+## Complexity Detection
+
+### Complexity Indicators
+
+| Indicator | Weight | Description |
+|-----------|--------|-------------|
+| External dependencies | +3 | APIs, databases, third-party services |
+| State management | +2 | Complex state flows, side effects |
+| Async operations | +2 | Promises, callbacks, event handling |
+| Multiple files | +1/file | Cross-file changes beyond 3 |
+| Novel patterns | +2 | No existing pattern in codebase |
+| Security-sensitive | +3 | Auth, encryption, permissions |
+| Performance-critical | +2 | Must meet specific benchmarks |
+| Data migrations | +4 | Schema changes, data transforms |
+
+### Complexity Scoring
+
+| Score | Level | Task Size | Decomposition |
+|-------|-------|-----------|---------------|
+| 0-3 | Low | Small | Keep as single task |
+| 4-6 | Medium | Standard | 2-3 subtasks |
+| 7-10 | High | Large | 4-6 subtasks |
+| 11+ | Very High | Epic | Split into separate plan |
+
+## Decomposition Rules
+
+### When to Decompose
+
+1. **Task exceeds complexity threshold (7+)**
+   ```
+   Original: "Implement user authentication"
+   Complexity: 12 (High)
+
+   Decomposed:
+   - T1.1: Create user model and schema
+   - T1.2: Implement password hashing
+   - T1.3: Create JWT token service
+   - T1.4: Build login endpoint
+   - T1.5: Build registration endpoint
+   - T1.6: Add authentication middleware
+   ```
+
+2. **Task has unclear verification**
+   ```
+   Original: "Make the app faster"
+   Issue: No clear done state
+
+   Decomposed:
+   - T1.1: Profile current performance (baseline)
+   - T1.2: Identify top 3 bottlenecks
+   - T1.3: Optimize bottleneck #1
+   - T1.4: Optimize bottleneck #2
+   - T1.5: Optimize bottleneck #3
+   - T1.6: Verify improvement vs baseline
+   ```
+
+3. **Task spans multiple domains**
+   ```
+   Original: "Add payment processing"
+   Domains: API, Database, UI, External Service
+
+   Decomposed:
+   - T1.1: Database schema for transactions
+   - T1.2: Stripe API integration
+   - T1.3: Payment endpoint
+   - T1.4: Transaction history UI
+   - T1.5: Webhook handling
+   ```
+
+### When NOT to Decompose
+
+1. **Simple CRUD operations** (complexity < 4)
+2. **Configuration changes**
+3. **Documentation updates**
+4. **Style/formatting fixes**
+5. **Single-file changes with clear scope**
+
+## Integration with plan-phase
+
+### Automatic Detection
+
+During `/gywd:plan-phase`, each task is scored:
+
+```markdown
+## Phase 3: Payment Integration
+
+### Initial Tasks (Before Decomposition)
+
+1. Add payment processing (complexity: 14) → DECOMPOSE
+2. Update user model for billing (complexity: 4) → KEEP
+3. Add Stripe webhook handling (complexity: 8) → DECOMPOSE
+4. Update tests (complexity: 3) → KEEP
+
+### After Adaptive Decomposition
+
+1.1 Create transaction database schema [3]
+1.2 Implement Stripe client wrapper [4]
+1.3 Create payment intent endpoint [5]
+1.4 Handle successful payment [4]
+1.5 Handle failed payment [4]
+1.6 Create payment history endpoint [3]
+
+2. Update user model for billing [4]
+
+3.1 Create webhook endpoint [4]
+3.2 Verify webhook signatures [3]
+3.3 Handle payment_intent.succeeded [3]
+3.4 Handle payment_intent.failed [3]
+
+4. Update tests [3]
+```
+
+### User Override
+
+Users can control decomposition:
+
+```bash
+# Force decomposition
+/gywd:plan-phase 3 --decompose-all
+
+# Prevent decomposition
+/gywd:plan-phase 3 --no-decompose
+
+# Set custom threshold
+/gywd:plan-phase 3 --complexity-threshold 10
+```
+
+### Memory Integration
+
+Decomposition patterns are learned:
+
+```markdown
+## MEMORY.md
+
+### Patterns
+
+- Payment tasks always decompose into: schema → client → endpoints → webhooks
+- Auth tasks split by: model → crypto → endpoints → middleware
+- API tasks split by: endpoint type (GET/POST/PUT/DELETE)
+```
+
+## Output Format
+
+When a plan uses adaptive decomposition:
+
+```markdown
+## Decomposition Summary
+
+This plan used adaptive task decomposition.
+
+| Original Task | Complexity | Result |
+|--------------|------------|--------|
+| Payment processing | 14 | Split into 6 subtasks |
+| Update user model | 4 | Kept as-is |
+| Webhook handling | 8 | Split into 4 subtasks |
+| Update tests | 3 | Kept as-is |
+
+**Original tasks:** 4
+**After decomposition:** 12
+**Average complexity:** 3.5 (down from 7.2)
+```
+
+## Benefits
+
+1. **Predictable execution** - Each task is right-sized
+2. **Better commits** - One feature per commit
+3. **Easier review** - Smaller, focused changes
+4. **Progress visibility** - More granular tracking
+5. **Reduced risk** - Problems caught earlier