aidp 0.27.0 → 0.28.0

data/templates/planning/agile/generate_mvp_scope.md

@@ -0,0 +1,127 @@
+# Generate MVP Scope Definition
+
+You are a product manager defining the Minimum Viable Product (MVP) scope.
+
+## Input
+
+Read:
+
+- `.aidp/docs/PRD.md` - Product requirements document
+
+## Your Task
+
+Define the MVP scope by distinguishing must-have features from nice-to-have features, ensuring the MVP delivers core value while being achievable within constraints.
+
+## Interactive Priority Collection
+
+**Gather user priorities through TUI prompts:**
+
+1. What is the primary goal of this MVP?
+2. What is the main problem you're solving?
+3. Who are your target users?
+4. What is your target timeline for MVP launch?
+5. Do you have any resource or technical constraints?
+
+## MVP Scoping Principles
+
+**MVP Must-Haves:**
+
+- Features that deliver core value proposition
+- Features required to solve the main problem
+- Features necessary for minimal user workflows
+- Features that validate key assumptions
+
+**Nice-to-Have (Deferred):**
+
+- Enhancements that improve but aren't essential
+- Features that can be added based on user feedback
+- Polish and optimization that can wait
+- Features serving edge cases or secondary users
+
+**Out of Scope:**
+
+- Features not aligned with MVP goals
+- Complex features that can wait for validation
+- Features requiring significant unknowns
+- Advanced capabilities beyond core use cases
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Generators::MVPScopeGenerator`:
+
+1. Parse PRD using `Aidp::Planning::Parsers::DocumentParser`
+2. Collect user priorities interactively via TTY::Prompt
+3. Generate MVP scope using `MVPScopeGenerator.generate(prd:, user_priorities:)`
+4. Format as markdown using `format_as_markdown(mvp_scope)`
+5. Write to `.aidp/docs/MVP_SCOPE.md`
+
+**For other implementations**, create equivalent functionality that:
+
+1. Parses the PRD to extract all features
+2. Collects user priorities interactively
+3. Uses AI to analyze features and determine MVP viability
+4. Categorizes features as must-have, nice-to-have, or out-of-scope
+5. Provides rationale for categorization decisions
+6. Defines success criteria for MVP
+7. Identifies assumptions and risks
+
+## Output Structure
+
+Write to `.aidp/docs/MVP_SCOPE.md` with:
+
+### User Priorities
+
+List of priorities collected from user input
+
+### MVP Features (Must-Have)
+
+For each feature:
+
+- Name and description
+- Rationale for inclusion in MVP
+- Acceptance criteria
+
+### Deferred Features (Nice-to-Have)
+
+For each feature:
+
+- Name and description
+- Reason for deferral
+
+### Out of Scope
+
+List of explicitly excluded items
+
+### Success Criteria
+
+Measurable criteria for MVP success
+
+### Assumptions
+
+What we're assuming about users, technology, or market
+
+### Risks
+
+Potential issues and mitigation strategies
+
+## AI Analysis Guidelines
+
+Use AI Decision Engine to:
+
+- Analyze each feature's importance to core value prop
+- Assess complexity and effort required
+- Consider user impact and business value
+- Balance scope with timeline and resources
+- Identify dependencies and prerequisites
+
+Focus on delivering value quickly while managing risk and complexity.
+
+## Output
+
+Write complete MVP scope definition to `.aidp/docs/MVP_SCOPE.md` with:
+
+- Clear categorization of all features
+- Rationale for each decision
+- Specific, measurable success criteria
+- Realistic assumptions and identified risks
+- Generated timestamp and metadata

data/templates/planning/agile/generate_user_test_plan.md

@@ -0,0 +1,143 @@
+# Generate User Testing Plan
+
+You are a UX researcher creating a comprehensive user testing plan.
+
+## Input
+
+Read:
+
+- `.aidp/docs/MVP_SCOPE.md` - MVP scope definition with features to test
+
+## Your Task
+
+Create a detailed user testing plan that includes recruitment criteria, testing stages, survey questions, interview scripts, and success metrics to validate the MVP with real users.
+
+## User Testing Plan Components
+
+### 1. Target Users
+
+Define 2-3 user segments to test:
+
+- Segment characteristics
+- Why this segment is important
+- Recommended sample size per segment
+
+### 2. Recruitment
+
+- Screener questions to qualify participants
+- Recruitment channels (where to find users)
+- Incentives for participation
+- Timeline for recruitment
+
+### 3. Testing Stages
+
+Define 3-4 stages (e.g., Alpha, Beta, Launch):
+
+- Objective of each stage
+- Number of participants
+- Duration
+- Key activities
+- Success criteria
+
+### 4. Survey Questions
+
+Create comprehensive surveys:
+
+- **Likert Scale** (1-5): 5-7 questions about satisfaction, ease of use, value
+- **Multiple Choice**: 3-5 questions with specific options
+- **Open-Ended**: 3-5 questions for qualitative feedback
+
+### 5. Interview Script
+
+- Introduction explaining the research
+- 5-7 main questions with follow-ups
+- Closing thanking participants
+
+### 6. Success Metrics
+
+Quantitative and qualitative metrics:
+
+- Task completion rates
+- User satisfaction scores
+- Feature adoption metrics
+- Qualitative sentiment targets
+
+### 7. Timeline
+
+Phases with duration estimates:
+
+- Recruitment
+- Testing stages
+- Analysis and reporting
+
+## Question Design Principles
+
+**Good Survey Questions:**
+
+- Clear and unambiguous
+- One topic per question
+- Balanced response options
+- Appropriate for quantitative analysis
+
+**Good Interview Questions:**
+
+- Open-ended to encourage discussion
+- Non-leading
+- Focused on specific experiences
+- Include follow-up probes
+
+**Avoid:**
+
+- Double-barreled questions
+- Leading or biased phrasing
+- Jargon or technical terms
+- Questions that assume knowledge
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Generators::UserTestPlanGenerator`:
+
+1. Parse MVP scope using `Aidp::Planning::Parsers::DocumentParser`
+2. Generate test plan using `UserTestPlanGenerator.generate(mvp_scope:)`
+3. Format as markdown using `format_as_markdown(test_plan)`
+4. Write to `.aidp/docs/USER_TEST_PLAN.md`
+
+**For other implementations**, create equivalent functionality that:
+
+1. Parses MVP scope to understand features to test
+2. Uses AI to generate contextual testing questions based on features
+3. Creates persona-specific recruitment criteria
+4. Designs appropriate testing stages
+5. Generates survey questions (Likert, multiple choice, open-ended)
+6. Creates interview scripts with follow-ups
+7. Defines measurable success metrics
+
+## AI Analysis Guidelines
+
+Use AI Decision Engine to:
+
+- Generate questions specific to MVP features
+- Tailor recruitment criteria to target users
+- Design appropriate testing stages
+- Create unbiased, effective questions
+- Suggest realistic success metrics
+
+Make questions specific to the MVP features, not generic.
+
+## Output Structure
+
+Write to `.aidp/docs/USER_TEST_PLAN.md` with:
+
+- Overview of testing goals
+- Target user segments with characteristics
+- Recruitment criteria and screener questions
+- Testing stages with objectives
+- Complete survey questions (all types)
+- Interview script (intro, questions, closing)
+- Success metrics and targets
+- Timeline with phase durations
+- Generated timestamp and metadata
+
+## Output
+
+Write complete user testing plan to `.aidp/docs/USER_TEST_PLAN.md` with all components listed above.

data/templates/planning/agile/ingest_feedback.md

@@ -0,0 +1,174 @@
+# Ingest User Feedback Data
+
+You are a UX researcher ingesting user feedback data for analysis.
+
+## Your Task
+
+Collect user feedback data from CSV, JSON, or markdown files and normalize it into a consistent format for AI-powered analysis.
+
+## Interactive Data Collection
+
+**Prompt the user for:**
+
+1. Path to feedback data file (CSV, JSON, or markdown)
+2. Confirm file format is correct
+3. Validate file exists and is readable
+
+## Supported Formats
+
+### CSV Format
+
+Expected columns (flexible names):
+
+- `id` or `respondent_id` or `user_id` - Respondent identifier
+- `timestamp` or `date` or `submitted_at` - When submitted
+- `rating` or `score` - Numeric rating (1-5, 1-10, etc.)
+- `feedback` or `comments` or `response` - Text feedback
+- `feature` or `area` - Feature being commented on
+- `sentiment` - Positive/negative/neutral
+- `tags` - Comma-separated tags
+
+### JSON Format
+
+Two structures supported:
+
+**Array of responses:**
+
+```json
+[
+  {
+    "id": "user123",
+    "timestamp": "2025-01-15",
+    "rating": 4,
+    "feedback": "Great product!",
+    "feature": "dashboard",
+    "sentiment": "positive"
+  }
+]
+```
+
+**Object with responses key:**
+
+```json
+{
+  "survey_name": "MVP Feedback",
+  "responses": [...]
+}
+```
+
+### Markdown Format
+
+Responses in sections:
+
+```markdown
+## Response 1
+**ID:** user123
+**Timestamp:** 2025-01-15
+**Rating:** 4
+**Feedback:** Great product!
+```
+
+## Normalization
+
+Normalize all formats to consistent structure:
+
+- `respondent_id` - User identifier
+- `timestamp` - Submission time
+- `rating` - Numeric rating (normalized)
+- `feedback_text` - Text feedback
+- `feature` - Feature name
+- `sentiment` - Sentiment classification
+- `tags` - Array of tags
+- `raw_data` - Original data for reference
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Parsers::FeedbackDataParser`:
+
+1. Prompt user for file path using TTY::Prompt
+2. Validate file exists and is readable
+3. Parse using `FeedbackDataParser.new(file_path:).parse`
+4. Save normalized data to `.aidp/docs/feedback_data.json`
+
+Example:
+
+```ruby
+prompt = TTY::Prompt.new
+file_path = prompt.ask("Enter path to feedback data file:", required: true)
+
+unless File.exist?(file_path)
+  prompt.error("File not found: #{file_path}")
+  exit 1
+end
+
+parser = Aidp::Planning::Parsers::FeedbackDataParser.new(file_path: file_path)
+feedback_data = parser.parse
+
+File.write(".aidp/docs/feedback_data.json", JSON.pretty_generate(feedback_data))
+prompt.ok("Feedback data ingested: #{feedback_data[:response_count]} responses")
+```
+
+**For other implementations**, create equivalent functionality that:
+
+1. Prompts user for file path
+2. Detects format from file extension
+3. Parses format-specific data
+4. Normalizes to consistent structure
+5. Validates required fields
+6. Saves to JSON format
+
+## Validation
+
+Check for:
+
+- File exists and is readable
+- Format is supported (.csv, .json, .md)
+- Required fields present (at minimum: feedback text or rating)
+- Data is parseable (valid CSV/JSON/markdown)
+
+## Error Handling
+
+Handle gracefully:
+
+- File not found
+- Invalid format
+- Missing required fields
+- Parse errors (malformed JSON, etc.)
+- Empty datasets
+
+Provide clear error messages to help user fix issues.
+
+## Output Structure
+
+Save to `.aidp/docs/feedback_data.json`:
+
+```json
+{
+  "format": "csv|json|markdown",
+  "source_file": "path/to/file",
+  "parsed_at": "2025-01-15T10:30:00Z",
+  "response_count": 42,
+  "responses": [
+    {
+      "respondent_id": "user123",
+      "timestamp": "2025-01-15",
+      "rating": 4,
+      "feedback_text": "Text feedback",
+      "feature": "feature_name",
+      "sentiment": "positive",
+      "tags": ["tag1", "tag2"],
+      "raw_data": {...}
+    }
+  ],
+  "metadata": {
+    "total_rows": 42,
+    "columns": [...],
+    "has_timestamps": true,
+    "has_ratings": true
+  }
+}
+```
+
+## Output
+
+Write normalized feedback data to `.aidp/docs/feedback_data.json` and confirm successful ingestion with count to user via TUI.

data/templates/planning/assemble_project_plan.md

@@ -0,0 +1,113 @@
+# Assemble Complete Project Plan
+
+You are creating the master PROJECT_PLAN.md document that integrates all planning artifacts.
+
+## Input Files
+
+Read all generated artifacts:
+
+- `.aidp/docs/PRD.md` - Product requirements
+- `.aidp/docs/TECH_DESIGN.md` - Technical design
+- `.aidp/docs/WBS.md` - Work breakdown structure
+- `.aidp/docs/GANTT.md` - Gantt chart and critical path
+- `.aidp/docs/TASK_LIST.md` - Detailed task list
+- `.aidp/docs/persona_map.yml` - Persona assignments
+
+## Your Task
+
+Assemble everything into a comprehensive, integrated project plan document.
+
+## Project Plan Structure
+
+```markdown
+# Project Plan
+
+Generated: <timestamp>
+
+## Executive Summary
+[Brief overview of the project and plan]
+
+## Work Breakdown Structure
+[Include WBS content]
+
+## Timeline and Gantt Chart
+[Include Gantt chart with Mermaid visualization]
+
+## Critical Path
+[List critical path tasks]
+
+## Persona Assignments
+[Summary of task assignments by persona]
+
+## Metadata
+- Total Phases: X
+- Total Tasks: Y
+- Critical Path Length: Z tasks
+- Personas Used: N
+
+## References
+- [PRD](./PRD.md)
+- [Technical Design](./TECH_DESIGN.md)
+- [Task List](./TASK_LIST.md)
+- [Persona Map](./persona_map.yml)
+```
+
+## Assembly Guidelines
+
+1. **Integrate all artifacts** - Combine WBS, Gantt, personas into one document
+2. **Maintain structure** - Preserve hierarchies and relationships
+3. **Add cross-references** - Link related sections
+4. **Include metadata** - Counts, timestamps, generation info
+5. **Format consistently** - Use consistent markdown styling
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill to:
+
+1. Parse all input documents using `Aidp::Planning::Parsers::DocumentParser`
+2. Use `Aidp::Planning::Builders::ProjectPlanBuilder` to orchestrate assembly
+3. Call `assemble_project_plan(components)` with all artifacts
+4. Write to `.aidp/docs/PROJECT_PLAN.md`
+
+The skill provides the complete Ruby implementation including:
+
+- Document parsing and loading
+- Component assembly and integration
+- Markdown formatting
+- Metadata calculation
+- File output operations
+
+**For other language implementations**, implement equivalent functionality:
+
+1. Read and parse all input markdown files
+2. Extract key information from each:
+   - WBS: phases, tasks, estimates
+   - Gantt: timeline, critical path
+   - Personas: task assignments by role
+3. Assemble into single structured document:
+   - Executive summary
+   - Full WBS content
+   - Gantt visualization
+   - Critical path list
+   - Persona assignments grouped by persona
+   - Metadata and statistics
+4. Format as markdown with proper headings and structure
+5. Write to output file
+
+## Output
+
+Write the complete, integrated project plan to `.aidp/docs/PROJECT_PLAN.md`
+
+This serves as the single source of truth for project planning.
+
+## Quality Checks
+
+Ensure the assembled plan includes:
+
+- ✅ All phases from WBS
+- ✅ All tasks with dependencies
+- ✅ Gantt chart visualization
+- ✅ Complete critical path
+- ✅ Every task assigned to a persona
+- ✅ Accurate metadata counts
+- ✅ Cross-references to source documents

data/templates/planning/assign_personas.md

@@ -0,0 +1,108 @@
+# Assign Tasks to Personas
+
+You are assigning each task to the most appropriate persona using **Zero Framework Cognition** (ZFC).
+
+## Critical: Use ZFC Pattern
+
+**DO NOT use heuristics, regex, or keyword matching!**
+
+All task-to-persona assignments must be made using semantic AI decision making, not programmatic rules.
+
+## Input
+
+Read `.aidp/docs/TASK_LIST.md` - All project tasks
+
+## Available Personas
+
+Default personas include:
+
+- **product_strategist** - Product requirements, user research, stakeholder management
+- **architect** - System design, architecture decisions, technology choices
+- **senior_developer** - Implementation, code quality, technical problem solving
+- **qa_engineer** - Testing strategy, test implementation, quality assurance
+- **devops_engineer** - Infrastructure, CI/CD, deployment, monitoring
+- **tech_writer** - Documentation, user guides, API documentation
+
+## Assignment Principles
+
+The AI should consider:
+
+- **Task type**: Requirements, design, implementation, testing, deployment
+- **Required expertise**: Product, architecture, development, QA, operations
+- **Phase**: Different personas for different phases
+- **Complexity**: Senior developers for complex tasks
+
+## Zero Framework Cognition
+
+**FORBIDDEN**:
+
+- Regex pattern matching on task names
+- Keyword matching ("test" → qa_engineer)
+- Heuristic rules
+- Scoring formulas
+
+**REQUIRED**:
+
+- Use AI decision engine for ALL assignments
+- Provide task context to AI (name, description, phase, effort)
+- Let AI make semantic decisions
+- Assignment rationale comes from AI, not code
+
+## Parallel Execution
+
+Multiple personas can work in parallel - the system handles conflicts automatically.
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill to:
+
+1. Load tasks from Gantt chart or task list
+2. Use `Aidp::Planning::Mappers::PersonaMapper` with AI decision engine
+3. Call `AIDecisionEngine.decide()` for each task assignment
+4. Generate `persona_map.yml` configuration
+5. Write to `.aidp/docs/persona_map.yml`
+
+The skill provides the complete Ruby implementation including:
+
+- AI engine integration
+- ZFC-based decision making (NO heuristics!)
+- YAML configuration generation
+- Proper error handling and logging
+
+**For other language implementations**, implement equivalent functionality:
+
+1. Load task list with descriptions, phases, and effort
+2. For each task, invoke AI decision engine with:
+   - Task characteristics (name, description, phase, effort)
+   - Available personas list
+   - Decision prompt asking for best persona match
+3. Store AI's decision (persona assignment)
+4. Generate configuration file mapping tasks to personas
+5. Include assignment rationale from AI
+
+## Output Format
+
+Write assignments to `.aidp/docs/persona_map.yml`:
+
+```yaml
+version: "1.0"
+generated_at: "<timestamp>"
+assignments:
+  TASK-001:
+    persona: product_strategist
+    task: "Document Functional Requirements"
+    phase: "Requirements"
+  TASK-002:
+    persona: architect
+    task: "Design System Architecture"
+    phase: "Design"
+  ...
+```
+
+## Remember
+
+- Use AIDecisionEngine - NO manual heuristics!
+- Assignment rationale comes from AI, not code
+- Every task must be assigned
+- Personas can work in parallel
+- This is a ZFC pattern - meaning goes to AI, structure goes to code