pmp-gywd 3.3.0

package/commands/gywd/anticipate.md

@@ -0,0 +1,271 @@
+---
+name: GYWD:anticipate
+description: Predictive development - AI that knows what you'll need before you ask
+argument-hint: "[--for <context>] [--depth shallow|deep]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - Write
+---
+
+<objective>
+Proactively prepare context, patterns, and suggestions BEFORE you need them.
+
+Current AI is reactive: you ask, it responds.
+Predictive AI anticipates: it knows what you'll need next.
+
+Based on:
+- What you're currently working on
+- Patterns from your history
+- Common sequences in similar projects
+- Your personal development patterns
+</objective>
+
+<philosophy>
+From cognitive research: "Experts spend more time on 'define problem' phase and more often activate prior knowledge before searching."
+
+Experts anticipate. They gather context before they need it.
+AI should do the same.
+</philosophy>
+
+<prediction_types>
+## What We Anticipate
+
+### 1. Pattern Predictions
+**Signal**: You're building X
+**Anticipate**: Common patterns that follow X
+
+```
+Detected: Implementing user authentication
+Anticipated needs:
+├── Password hashing patterns
+├── JWT token structure
+├── Session management approaches
+├── Rate limiting for auth endpoints
+├── Password reset flow
+└── OAuth integration patterns
+
+Pre-loaded: Security best practices for auth
+Pre-loaded: Common vulnerabilities (OWASP auth)
+```
+
+### 2. File Predictions
+**Signal**: You're editing X
+**Anticipate**: Files that usually change with X
+
+```
+Detected: Editing src/models/user.ts
+Co-change patterns from history:
+├── src/services/userService.ts (95% co-change)
+├── src/api/users.ts (87% co-change)
+├── tests/user.test.ts (82% co-change)
+└── prisma/schema.prisma (45% co-change)
+
+Pre-loaded: These files are in context
+```
+
+### 3. Dependency Predictions
+**Signal**: You're adding library X
+**Anticipate**: Configuration, patterns, gotchas
+
+```
+Detected: Adding 'stripe' package
+Anticipated needs:
+├── Stripe API patterns for this stack
+├── Webhook handling setup
+├── Test mode vs live mode config
+├── Common Stripe errors and handling
+├── PCI compliance considerations
+└── Idempotency key patterns
+
+Pre-loaded: Stripe integration checklist
+```
+
+### 4. Problem Predictions
+**Signal**: Error patterns in current work
+**Anticipate**: Similar bugs from history
+
+```
+Detected: TypeScript error TS2322 in async function
+Similar bugs from your history:
+├── 2024-01-15: Same error, solution was Promise<T> return type
+├── 2024-02-03: Same error, solution was await missing
+└── 2023-11-20: Same error, solution was generic constraint
+
+Pre-loaded: Your past solutions to this error
+```
+
+### 5. Flow Predictions
+**Signal**: Entering deep work
+**Anticipate**: Don't interrupt, batch for later
+
+```
+Detected: Flow state (15+ min focused editing)
+Actions:
+├── Batching non-critical suggestions
+├── Suppressing optional notifications
+├── Preparing summary for when you pause
+└── Tracking questions you might have after
+
+On pause: Here's what accumulated while you were focused
+```
+</prediction_types>
+
+<process>
+## Anticipation Engine
+
+### 1. Context Detection
+
+Monitor for signals:
+```python
+signals = {
+    "file_edit": detect_file_edit_patterns(),
+    "search_query": detect_search_patterns(),
+    "error_occurrence": detect_error_patterns(),
+    "package_add": detect_dependency_changes(),
+    "time_of_day": get_time_patterns(),
+    "session_duration": get_focus_duration(),
+    "commit_patterns": get_recent_commit_context()
+}
+```
+
+### 2. Pattern Matching
+
+Match signals to predictions:
+```
+IF editing auth-related file AND morning session:
+    PREDICT: Security-focused work
+    ANTICIPATE: Auth patterns, security checklist
+
+IF TypeScript error AND similar to past error:
+    PREDICT: Known issue
+    ANTICIPATE: Past solutions
+
+IF new feature file AND tests don't exist:
+    PREDICT: Will need tests soon
+    ANTICIPATE: Test patterns for this file type
+```
+
+### 3. Pre-loading
+
+Based on predictions, pre-load:
+```
+context.preload({
+    patterns: relevant_code_patterns(),
+    decisions: related_decisions(),
+    history: similar_past_work(),
+    warnings: potential_pitfalls(),
+    suggestions: likely_next_steps()
+})
+```
+
+### 4. Delivery
+
+Deliver anticipations appropriately:
+- **Immediate**: Critical warnings (security issues)
+- **Available**: Ready when you ask (patterns in context)
+- **Batched**: Non-urgent (suggestions for later)
+- **Hidden**: Background prep (pre-indexed context)
+</process>
+
+<output_format>
+## When Running Manually
+
+```markdown
+## Anticipation Report
+
+**Context**: Working on payment integration
+**Confidence**: 85%
+
+### Ready for You
+
+**Patterns pre-loaded:**
+- Stripe payment intent flow
+- Webhook signature verification
+- Idempotency handling
+
+**Relevant decisions:**
+- DEC-015: "All payments use Result pattern"
+- DEC-023: "Log all payment state changes"
+
+**Similar past work:**
+- 2024-01: Subscription billing (same patterns)
+- Your solution: src/services/subscriptionPayment.ts
+
+### Potential Issues Ahead
+
+⚠️ **Webhook timing**: You'll likely hit race condition between
+   payment confirmation and order creation. See how you solved
+   this in orders.ts:142
+
+⚠️ **Test mode gotcha**: Stripe test webhooks have different
+   signatures. Past you spent 2 hours on this.
+
+### Suggested Next Steps
+
+Based on your typical flow:
+1. Create payment intent endpoint (you usually start here)
+2. Add webhook handler (you always forget this initially)
+3. Write integration tests (you defer but always need)
+```
+</output_format>
+
+<learning>
+## How Anticipate Learns
+
+### From Your Behavior
+- Which anticipations you used vs ignored
+- What you searched for after anticipations
+- What was missing from predictions
+
+### From Outcomes
+- Did anticipated patterns help?
+- Did warnings prevent issues?
+- Were suggestions relevant?
+
+### Feedback Loop
+```
+anticipation.record({
+    prediction: "Will need webhook handler",
+    actual: "Created webhook handler 10 min later",
+    useful: true
+})
+
+# Next time: Higher confidence for this prediction
+```
+</learning>
+
+<integration>
+## Auto-Anticipate Mode
+
+Enable in config.json:
+```json
+{
+  "anticipate": {
+    "enabled": true,
+    "auto_preload": true,
+    "flow_protection": true,
+    "learning": true
+  }
+}
+```
+
+When enabled:
+- Background anticipation runs continuously
+- Context is pre-loaded without explicit command
+- Flow state is protected automatically
+- System learns from your patterns
+</integration>
+
+<success_criteria>
+- [ ] Detects current work context accurately
+- [ ] Predicts likely next needs
+- [ ] Pre-loads relevant patterns and decisions
+- [ ] Respects flow state (doesn't interrupt)
+- [ ] Learns from behavior over time
+- [ ] Surfaces warnings proactively
+- [ ] Batches non-urgent suggestions
+</success_criteria>

package/commands/gywd/bootstrap.md

@@ -0,0 +1,336 @@
+---
+name: GYWD:bootstrap
+description: Initialize GYWD v2.0 core on any codebase - full decision intelligence
+argument-hint: "[--deep] [--quick]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - WebFetch
+---
+
+<objective>
+Bootstrap the complete GYWD v2.0 intelligence system on any codebase.
+
+This is the "one command to rule them all" - it:
+1. Maps the codebase structure
+2. Extracts the decision graph from history
+3. Builds the context intelligence model
+4. Creates the developer profile
+5. Initializes the learning system
+
+After bootstrap, GYWD understands your codebase at a decision level,
+not just a file level.
+</objective>
+
+<philosophy>
+v1.x required running multiple commands:
+- /gywd:map-codebase
+- /gywd:new-project
+- /gywd:create-roadmap
+- /gywd:extract-decisions
+
+v2.0 does it all intelligently with one command.
+</philosophy>
+
+<modes>
+## Bootstrap Modes
+
+### Quick Mode (--quick)
+- Shallow git history (last 100 commits)
+- Essential codebase mapping only
+- Skip detailed decision extraction
+- ~2 minutes
+
+### Standard Mode (default)
+- Full git history analysis
+- Complete codebase mapping
+- Full decision extraction
+- Developer profile initialization
+- ~5-10 minutes
+
+### Deep Mode (--deep)
+- Exhaustive history analysis
+- Cross-reference with issues/PRs if available
+- Multiple pass decision extraction
+- Adversarial validation of decisions
+- ~15-30 minutes
+</modes>
+
+<process>
+## Phase 1: Codebase Analysis
+
+Spawn parallel agents:
+
+```
+Agent 1: Structure Analysis
+├── Directory layout
+├── Entry points
+├── Module organization
+└── Key files identification
+
+Agent 2: Stack Detection
+├── Languages and frameworks
+├── Dependencies
+├── Build system
+└── Test setup
+
+Agent 3: Pattern Recognition
+├── Coding conventions
+├── Architectural patterns
+├── Common idioms
+└── Anti-patterns present
+```
+
+Output: `.planning/codebase/` populated
+
+## Phase 2: Decision Extraction
+
+```
+1. Parse git history
+   ├── Commit messages
+   ├── Merge commits (PRs)
+   └── Refactoring patterns
+
+2. Analyze documentation
+   ├── README files
+   ├── Architecture docs
+   ├── ADRs if present
+   └── Code comments
+
+3. Infer from code
+   ├── Consistent patterns → implicit decisions
+   ├── Unusual choices → explicit decisions likely
+   └── Tech stack choices → architectural decisions
+
+4. Build graph
+   ├── Link related decisions
+   ├── Identify decision chains
+   └── Detect conflicts
+```
+
+Output: `.planning/core/decisions.json` + `.planning/codebase/DECISIONS.md`
+
+## Phase 3: Context Model
+
+```
+1. Analyze file relationships
+   ├── Import/dependency graph
+   ├── Co-change patterns (files that change together)
+   └── Ownership patterns (who works on what)
+
+2. Build context predictions
+   ├── If working on X, likely need Y
+   ├── If error in A, check B
+   └── If adding feature like C, pattern is D
+
+3. Initialize context budget
+   ├── Estimate token usage per area
+   ├── Identify high-value context
+   └── Set compression strategies
+```
+
+Output: `.planning/core/context-model.json`
+
+## Phase 4: Developer Profile
+
+```
+1. Analyze git contributions
+   ├── Areas of focus
+   ├── Commit patterns
+   └── Time patterns
+
+2. Infer preferences
+   ├── Code style from samples
+   ├── Naming conventions used
+   └── Architectural preferences
+
+3. Create initial profile
+   ├── Expertise topology (inferred)
+   ├── Work patterns (from git)
+   └── Preferences (from code)
+```
+
+Output: `.planning/profile/`
+
+## Phase 5: Learning System Init
+
+```
+1. Create learning state
+   ├── Initialize feedback tracking
+   ├── Set up pattern recognition
+   └── Prepare adaptation mechanisms
+
+2. Baseline metrics
+   ├── Current decision confidence levels
+   ├── Context prediction accuracy baseline
+   └── Profile accuracy baseline
+```
+
+Output: `.planning/core/learning-state.json`
+
+## Phase 6: Project Setup
+
+```
+1. Create PROJECT.md if not exists
+   ├── Extract purpose from README
+   ├── Infer goals from code structure
+   └── Identify constraints from patterns
+
+2. Create ROADMAP.md if not exists
+   ├── Analyze recent work for current phase
+   ├── Infer upcoming work from TODOs
+   └── Identify technical debt as potential phases
+
+3. Create STATE.md
+   ├── Current position in inferred roadmap
+   ├── Recent decisions
+   └── Active areas
+```
+
+Output: `.planning/PROJECT.md`, `.planning/ROADMAP.md`, `.planning/STATE.md`
+</process>
+
+<output_format>
+## Bootstrap Report
+
+```markdown
+# GYWD v2.0 Bootstrap Complete
+
+**Codebase:** {name}
+**Mode:** {quick|standard|deep}
+**Duration:** {time}
+
+---
+
+## Codebase Understanding
+
+| Metric | Value |
+|--------|-------|
+| Files analyzed | 234 |
+| Lines of code | 45,000 |
+| Languages | TypeScript, Python |
+| Framework | Next.js, FastAPI |
+
+## Decision Graph
+
+| Metric | Value |
+|--------|-------|
+| Decisions extracted | 67 |
+| Explicit (documented) | 23 |
+| Inferred (from patterns) | 44 |
+| High confidence (>80%) | 34 |
+| Decision chains found | 8 |
+| Conflicts detected | 2 |
+
+## Context Intelligence
+
+| Metric | Value |
+|--------|-------|
+| File relationships mapped | 156 |
+| Co-change patterns found | 23 |
+| Context predictions ready | 45 |
+| Estimated context budget | 42% |
+
+## Developer Profile
+
+| Dimension | Status |
+|-----------|--------|
+| Expertise topology | Inferred from history |
+| Work patterns | Detected |
+| Preferences | Baseline created |
+| Ready for learning | Yes |
+
+---
+
+## Key Decisions Found
+
+### Architectural
+1. **DEC-001: Monorepo structure** [89%]
+2. **DEC-002: API-first design** [92%]
+3. **DEC-003: PostgreSQL over MongoDB** [76%]
+
+### Conventions
+1. **DEC-010: Functional React components** [95%]
+2. **DEC-011: Result pattern for errors** [88%]
+
+### Constraints
+1. **DEC-020: No ORM, raw SQL only** [72%]
+
+---
+
+## Conflicts Detected
+
+⚠️ **DEC-015 vs DEC-023**
+- DEC-015: "Always use async/await"
+- DEC-023: "Sync operations for simplicity in utils"
+- Resolution needed: Clarify scope boundaries
+
+---
+
+## What GYWD Now Understands
+
+✅ Why the code is structured this way
+✅ What decisions led to current patterns
+✅ Where conflicts and inconsistencies exist
+✅ How files relate to each other
+✅ What context is needed for what tasks
+✅ Your working patterns (initial baseline)
+
+---
+
+## Next Steps
+
+1. **Review conflicts:** `/gywd:why DEC-015` vs `/gywd:why DEC-023`
+2. **Explore decisions:** `/gywd:why <any file or pattern>`
+3. **Start working:** GYWD will provide decision-aware assistance
+4. **Plan new work:** `/gywd:plan-phase` now understands existing decisions
+
+---
+
+*GYWD v2.0 is ready. Your codebase is now understood at the decision level.*
+```
+</output_format>
+
+<error_handling>
+## Common Issues
+
+### No Git History
+```
+Warning: No git history found.
+- Decision extraction limited to documentation and code patterns
+- Confidence scores will be lower
+- Consider initializing git and making initial commit
+```
+
+### Large Repository
+```
+Note: Large repository detected (>100k files)
+- Using sampling strategy for initial analysis
+- Full analysis available with --deep flag
+- Bootstrap will take longer but be more accurate
+```
+
+### No Documentation
+```
+Note: Limited documentation found.
+- Relying heavily on code pattern inference
+- Decision confidence will be lower
+- Consider adding ARCHITECTURE.md or ADRs
+```
+</error_handling>
+
+<success_criteria>
+- [ ] Codebase structure fully mapped
+- [ ] Decision graph extracted and linked
+- [ ] Context model initialized
+- [ ] Developer profile created
+- [ ] Learning system ready
+- [ ] PROJECT.md exists (created or preserved)
+- [ ] STATE.md reflects current position
+- [ ] User can immediately use /gywd:why
+- [ ] All v1.x commands now decision-aware
+</success_criteria>