jettypod 3.0.1

package/docs/jettypod-system-overview.md

@@ -0,0 +1,409 @@
+# JettyPod System Overview
+*A Product Manager's Guide to Understanding JettyPod*
+
+## What is JettyPod?
+
+JettyPod is an intelligent development assistant that adapts its behavior based on what you're trying to accomplish and the current state of your project. Think of it as a smart copilot that understands context and adjusts its approach accordingly.
+
+---
+
+## Core Concept: Context-Aware Development
+
+The system continuously analyzes three key factors:
+1. **What you're trying to do** (your intent)
+2. **Where your project is** (maturity stage)
+3. **What situation you're in** (environmental signals)
+
+Based on these factors, JettyPod automatically switches between different working modes to give you the most appropriate assistance.
+
+---
+
+## The Four Working Modes
+
+### 🚀 Speed Mode
+**When:** Early projects, tight deadlines, prototyping
+**Behavior:** Focuses on getting things working quickly
+- Provides ready-to-use code patterns
+- Skips extensive documentation
+- Optimizes for rapid iteration
+- Auto-completes common patterns (forms, APIs, dashboards)
+
+### 🔍 Discovery Mode  
+**When:** Exploring options, uncertain requirements, evaluating approaches
+**Behavior:** Presents multiple options with trade-offs
+- Always shows 3 different approaches (Simple/Balanced/Advanced)
+- Lists pros and cons for each option
+- Provides time estimates
+- Creates working prototypes you can test
+- Helps you make informed decisions
+
+### 🏭 Production Mode
+**When:** Mature projects, has CI/CD, public-facing code
+**Behavior:** Emphasizes quality and safety
+- Enforces coding standards strictly
+- Requires comprehensive testing
+- Includes security considerations
+- Documents everything thoroughly
+- Follows best practices meticulously
+
+### 🚨 Recovery Mode
+**When:** Production issues, emergency fixes, critical bugs
+**Behavior:** Emergency response protocol
+- Focuses on immediate fixes
+- Provides rollback strategies
+- Minimizes risk
+- Creates temporary patches when needed
+- Documents what broke and why
+
+---
+
+## How JettyPod Detects Context
+
+### 1. Use Cases - What You're Trying to Do
+JettyPod recognizes six primary use cases that drive everything else:
+
+#### **Starting** 🌱
+- Triggered by: "new project", "initialize", "set up"
+- What it means: Beginning from scratch
+- Typical mode: Speed (unless uncertain → Discovery)
+
+#### **Building** 🔨
+- Triggered by: "let's build", "add feature", "implement", "create"
+- What it means: Adding new functionality
+- Typical mode: Speed (early stage) or Production (mature stage)
+
+#### **Refactoring** 🔧
+- Triggered by: "refactor", "clean up", "reorganize", "improve"
+- What it means: Improving existing code without changing behavior
+- Typical mode: Discovery (mature projects) or Speed (small projects)
+
+#### **Testing** 🧪
+- Triggered by: "write tests", "add tests", "test coverage"
+- What it means: Adding test coverage
+- Typical mode: Production (mature) or Speed (early)
+
+#### **Debugging** 🐛
+- Triggered by: "fix bug", "debug", "error", "not working", "broken"
+- What it means: Something is wrong and needs fixing
+- Typical mode: Recovery (production) or Speed (development)
+
+#### **Deployment** 🚀
+- Triggered by: "deploy", "ship", "release", "go live"
+- What it means: Preparing for production release
+- Typical mode: Production (always careful with deployments)
+
+#### **Exploring** 🔍
+- Triggered by: "show me options", "what are my choices", "not sure", "help me decide"
+- What it means: Need to explore alternatives
+- Typical mode: Discovery (always shows options)
+
+### 2. Project Maturity Stages
+JettyPod analyzes your codebase to determine its stage:
+
+1. **Empty** → No code yet
+2. **Starting** → < 10 files, just beginning
+3. **Growing** → 10-50 files, taking shape
+4. **Mature** → 50-200 files, established patterns
+5. **Production** → Has tests, CI/CD, monitoring
+
+### 3. Environmental Signals
+The system looks for contextual clues:
+
+- **Git branch names:**
+  - `hotfix/*` → Something's broken (Recovery mode)
+  - `feature/*` → Building new features (Speed/Discovery)
+  - `main/master` → Production code (Production mode)
+
+- **Time patterns:**
+  - Late night debugging (11 PM - 3 AM) → Likely urgent
+  - Weekend work → Either hobby or emergency
+
+- **Recent activity:**
+  - Many error fixes in commits → Need careful approach
+  - "WIP" commits → Still exploring
+  - Rapid commits → Under pressure
+
+- **Keywords in requests:**
+  - "urgent", "ASAP", "deadline" → Time pressure
+  - "production down", "emergency" → Crisis mode
+  - "not sure", "help me decide" → Need guidance
+
+---
+
+## The Use Case → Mode Mapping
+
+The system uses a sophisticated mapping between use cases and modes:
+
+### Primary Mapping Logic:
+```
+Use Case + Context = Mode Selection
+
+Starting + Uncertainty → Discovery Mode
+Starting + Clear vision → Speed Mode
+
+Building + Early stage → Speed Mode  
+Building + Mature project → Production Mode
+Building + Deadline → Speed Mode
+
+Refactoring + Small project → Speed Mode
+Refactoring + Large project → Discovery Mode
+
+Testing + Production stage → Production Mode
+Testing + Early stage → Speed Mode
+
+Debugging + Production → Recovery Mode
+Debugging + Development → Speed Mode
+Debugging + Late night → Recovery Mode
+
+Deployment + Any stage → Production Mode
+
+Exploring + Any context → Discovery Mode
+```
+
+### The Decision Flow:
+
+```
+1. Detect the use case from user input
+   → "Let's build a dashboard" → Building use case
+
+2. Check for emergency overrides
+   → "Production is down!" → Force Recovery Mode
+
+3. Check for contextual modifiers
+   → Deadline pressure + Building → Speed Mode
+   → Hotfix branch + Debugging → Recovery Mode
+   → Late night + Debugging → Recovery Mode
+
+4. Consider project maturity
+   → Building + Mature project → Production Mode
+   → Building + New project → Speed Mode
+
+5. Apply environmental signals
+   → High error frequency → Upgrade to Production/Recovery
+   → WIP commits → Consider Discovery
+   → Main branch → Lean toward Production
+```
+
+---
+
+## Coding Standards System
+
+### What are Standards?
+Standards are rules and patterns your team follows. JettyPod tracks and enforces these automatically.
+
+### How Standards Work:
+1. **Definition:** You define what patterns to follow (naming, structure, style)
+2. **Bundling:** Standards are grouped into bundles by topic (UI, API, Testing)
+3. **Filtering:** Only relevant standards appear based on project stage
+4. **Enforcement:** JettyPod checks code against standards in real-time
+5. **Learning:** The system learns your patterns over time
+
+### Stage-Based Filtering:
+- **Starting projects** → Only see essential standards
+- **Growing projects** → Add structure and organization standards  
+- **Mature projects** → Full standards including optimization
+- **Production** → All standards plus security and monitoring
+
+---
+
+## The CLAUDE.md File
+
+This is JettyPod's "instruction manual" - a dynamic document that updates based on context.
+
+### What it contains:
+1. **Current mode and why** it was selected
+2. **Active standards** for the project
+3. **Mode-specific behaviors** and patterns
+4. **Project context** and stage
+5. **Use case detection rules**
+
+### How it updates:
+- When you switch modes → Instructions change
+- When project grows → Standards evolve
+- When you change context → Behaviors adapt
+
+---
+
+## Practical Examples
+
+### Example 1: Use Case Detection → Mode Selection
+```
+You say: "Let's build a user dashboard"
+JettyPod detects: 
+  - Use case: Building (from "let's build")
+  - Project stage: Early (10 files)
+  - Context: No deadline mentioned
+Result: Speed Mode activated
+Behavior: Provides ready-made dashboard template, skips extensive docs
+```
+
+### Example 2: Context Overrides Use Case
+```
+You say: "Fix this bug"
+JettyPod detects:
+  - Use case: Debugging (from "fix bug")
+  - Project stage: Production (has CI/CD)
+  - Context: On main branch
+  - Keywords: "critical" detected
+Result: Recovery Mode (not Speed Mode)
+Behavior: Emergency response, immediate fix prioritized
+```
+
+### Example 3: Exploring Use Case
+```
+You say: "Show me options for authentication"
+JettyPod detects:
+  - Use case: Exploring (from "show me options")
+  - Project stage: Growing (50 files)
+  - Context: Uncertainty expressed
+Result: Discovery Mode activated
+Behavior: Shows 3 approaches (Simple OAuth, Full JWT, Enterprise SSO)
+```
+
+### Example 4: Multiple Signals Combine
+```
+Scenario: "Debug this issue" at 2 AM on hotfix branch
+JettyPod detects:
+  - Use case: Debugging
+  - Git branch: hotfix/* (emergency signal)
+  - Time: 2 AM (urgency signal)
+  - Recent commits: Multiple "fix:" messages
+Result: Recovery Mode with 95% confidence
+Behavior: Emergency protocols, quick fixes, rollback ready
+```
+
+### Example 5: Use Case Evolution
+```
+Journey of a feature:
+1. "I want to add search" → Exploring use case → Discovery Mode
+   (Shows 3 options: basic filter, full-text, elasticsearch)
+
+2. "Let's build the full-text option" → Building use case → Speed Mode
+   (Rapid implementation of chosen approach)
+
+3. "Add tests for search" → Testing use case → Production Mode
+   (Comprehensive test coverage required)
+
+4. "Deploy search feature" → Deployment use case → Production Mode
+   (Careful deployment with monitoring)
+```
+
+---
+
+## Key Benefits
+
+### For Product Development:
+1. **Adaptive assistance** - Gets the right help at the right time
+2. **Reduced decision fatigue** - Mode selection is automatic
+3. **Quality when needed** - Production mode for critical code
+4. **Speed when possible** - Rapid prototyping in early stages
+
+### For Team Consistency:
+1. **Enforced standards** - Automatic code quality checks
+2. **Progressive enhancement** - Standards grow with project
+3. **Context preservation** - Team knowledge captured in system
+4. **Smart defaults** - Best practices built-in
+
+### For Risk Management:
+1. **Emergency handling** - Recovery mode for crises
+2. **Quality gates** - Production mode for releases
+3. **Exploration safety** - Discovery mode for unknowns
+4. **Automatic detection** - Catches issues from context
+
+---
+
+## How to Influence Mode Selection
+
+While JettyPod is automatic, you can guide it:
+
+### Direct Commands:
+- `jettypod speed` - Force Speed Mode
+- `jettypod discovery` - Force Discovery Mode
+- `jettypod production` - Force Production Mode
+- `jettypod recovery` - Force Recovery Mode
+
+### Indirect Signals:
+- Use branch naming conventions (feature/*, hotfix/*)
+- Include keywords in requests ("urgent", "explore", "production")
+- Maintain project structure (tests, CI/CD indicate maturity)
+- Time your work appropriately (late night signals urgency)
+
+### Auto Commands:
+- `jettypod auto "let's build a payment system"` - Analyzes intent and switches mode
+- `jettypod auto "show me options for search"` - Triggers Discovery Mode
+- `jettypod auto "emergency fix needed"` - Triggers Recovery Mode
+
+---
+
+## Success Metrics
+
+JettyPod optimizes different metrics based on mode:
+
+| Mode | Primary Metric | Secondary Metrics |
+|------|---------------|-------------------|
+| Speed | Time to working code | Lines written, features completed |
+| Discovery | Decision quality | Options evaluated, trade-offs understood |
+| Production | Code reliability | Test coverage, standards compliance |
+| Recovery | Time to resolution | Stability restored, root cause found |
+
+---
+
+## Common Patterns
+
+### The Prototype → Production Journey
+1. Start in Speed Mode (rapid prototype)
+2. Switch to Discovery Mode (explore scaling options)
+3. Move to Production Mode (implement properly)
+4. Use Recovery Mode only when issues arise
+
+### The Exploration → Decision Flow
+1. Trigger Discovery Mode ("show me options")
+2. Review three approaches with trade-offs
+3. Select approach based on constraints
+4. Switch to appropriate mode for implementation
+
+### The Emergency Response
+1. System detects crisis (or you declare emergency)
+2. Recovery Mode activates automatically
+3. Quick fix applied with documentation
+4. Post-mortem triggers Discovery Mode for proper fix
+
+---
+
+## FAQ for Product Managers
+
+**Q: How does this differ from GitHub Copilot?**
+A: Copilot suggests code. JettyPod understands project context and adapts its entire behavior - from how it writes code to what standards it enforces.
+
+**Q: Can it work with existing codebases?**
+A: Yes. JettyPod analyzes your existing code to determine project stage and detects patterns to follow.
+
+**Q: How does it know what standards to enforce?**
+A: It comes with sensible defaults but learns from your codebase. You can also explicitly define standards.
+
+**Q: What if it picks the wrong mode?**
+A: You can always override with manual mode selection. The system also learns from corrections.
+
+**Q: How does it handle technical debt?**
+A: In Speed Mode, it allows quick solutions but tracks them. In Production Mode, it enforces proper implementation.
+
+**Q: Can multiple developers use it?**
+A: Yes. Standards and modes are stored in the project, ensuring consistency across the team.
+
+---
+
+## Summary
+
+JettyPod is like having an experienced developer who:
+- Knows when to move fast vs. when to be careful
+- Understands your project's maturity and needs
+- Adapts to emergency situations automatically
+- Helps explore options when you're uncertain
+- Enforces quality standards appropriately
+- Learns from your project patterns
+
+The key innovation is **context-aware adaptation** - the system changes its entire approach based on what you're doing, where your project is, and what situation you're in.
+
+---
+
+*For technical implementation details, see the engineering documentation.*

package/features/auto-generate-production-chores.feature

@@ -0,0 +1,14 @@
+Feature: Auto-generate production chores on external transition
+  When transitioning to external, automatically create production chores for all stable features
+
+  Approach: Silent Auto-Generation
+
+Scenario: User transitions project to external with stable features
+  Given I have a project with 3 features in stable mode
+  And the project state is "internal"
+  When I transition the project to external
+  Then the project state is set to "external"
+  And a "Feature Production Readiness" epic is created
+  And 3 production chores are created for each stable feature
+  And the chores are grouped under the epic
+  And I see a summary of created chores