aidp 0.26.0 → 0.28.0

data/templates/implementation/iterative_implementation.md

@@ -0,0 +1,122 @@
+# Iterative Implementation
+
+You are implementing a feature or fix within the AIDP work loop using an iterative, task-based approach.
+
+## Your Mission
+
+{{task_description}}
+
+## Important Instructions
+
+### 1. Break Down the Work
+
+If this is a multi-step feature, **break it into concrete subtasks** using the persistent tasklist:
+
+```text
+File task: "Subtask description here" priority: high|medium|low tags: tag1,tag2
+```
+
+Examples:
+
+```text
+File task: "Add worktree lookup logic to find existing worktrees" priority: high tags: implementation,git
+File task: "Implement worktree creation for PR branches" priority: high tags: implementation,git
+File task: "Add comprehensive logging using Aidp.log_debug" priority: medium tags: observability
+File task: "Add tests for worktree operations" priority: high tags: testing
+```
+
+### 2. Implement One Subtask at a Time
+
+**Focus on completing ONE subtask per iteration.** Keep changes minimal and focused.
+
+- Read the pending tasks from the tasklist
+- Pick the highest priority task that's ready to implement
+- Implement it completely with tests
+- Mark it done: `Update task: task_id_here status: done`
+
+### 3. Request Next Iteration
+
+When you've completed a subtask and there's more work:
+
+```text
+NEXT_UNIT: agentic
+```
+
+This tells the work loop to continue with the next subtask after running tests/linters.
+
+### 4. Track Progress in PROMPT.md
+
+Update this file to:
+
+- Remove completed items
+- Show current status
+- List what remains
+
+### 5. Mark Complete When Done
+
+When ALL work is complete (all subtasks done, tests passing):
+
+```text
+STATUS: COMPLETE
+```
+
+## Completion Criteria
+
+✅ All subtasks filed and completed
+✅ All tests passing
+✅ All linters passing
+✅ Code follows project style guide
+✅ Comprehensive logging added
+✅ STATUS: COMPLETE added to PROMPT.md
+
+## Context
+
+{{additional_context}}
+
+## Best Practices
+
+- **Small iterations**: Better to do 5 small focused iterations than 1 giant one
+- **Test as you go**: Write tests for each subtask before moving on
+- **Use signals**: `File task:`, `Update task:`, `NEXT_UNIT:` keep the system coordinated
+- **Log extensively**: Use `Aidp.log_debug()` at all important code paths
+- **Fail fast**: Let bugs surface early rather than masking with rescues
+
+## Example Flow
+
+Iteration 1:
+
+```text
+File task: "Create WorktreeBranchManager class" priority: high tags: implementation
+File task: "Add worktree lookup logic" priority: high tags: implementation
+File task: "Add tests for WorktreeBranchManager" priority: high tags: testing
+
+[Implement WorktreeBranchManager class with basic structure]
+
+Update task: task_abc123 status: done
+NEXT_UNIT: agentic
+```
+
+Iteration 2:
+
+```text
+[Implement worktree lookup logic]
+
+Update task: task_def456 status: done
+NEXT_UNIT: agentic
+```
+
+Iteration 3:
+
+```text
+[Add comprehensive tests]
+
+Update task: task_ghi789 status: done
+STATUS: COMPLETE
+```
+
+## Notes
+
+- The work loop will automatically run tests/linters after each iteration
+- If tests fail, you'll see the errors in the next iteration - fix them before continuing
+- Use the persistent tasklist to coordinate work across sessions
+- Each iteration should leave the codebase in a working state

data/templates/planning/agile/analyze_feedback.md

@@ -0,0 +1,183 @@
+# Analyze User Feedback
+
+You are a UX researcher analyzing user feedback using AI-powered semantic analysis.
+
+## Input
+
+Read:
+
+- `.aidp/docs/feedback_data.json` - Normalized feedback data from ingestion step
+
+## Your Task
+
+Perform comprehensive analysis of user feedback to extract insights, identify trends, and generate actionable recommendations.
+
+## Analysis Components
+
+### 1. Executive Summary
+
+High-level overview (2-3 paragraphs):
+
+- Overall sentiment and key themes
+- Most important findings
+- Top recommendations
+
+### 2. Sentiment Breakdown
+
+Distribution analysis:
+
+- Positive/negative/neutral counts and percentages
+- Sentiment trends over time if timestamps available
+- Sentiment by feature or category
+
+### 3. Key Findings
+
+3-5 major discoveries, each with:
+
+- Finding title and description
+- Evidence (quotes, data supporting the finding)
+- Impact assessment (high/medium/low)
+
+### 4. Trends and Patterns
+
+Recurring themes across responses:
+
+- Trend description
+- Frequency (how often mentioned)
+- Implications for product development
+
+### 5. Insights
+
+Categorized observations:
+
+- **Usability**: Ease of use, interface issues
+- **Features**: What's working, what's missing
+- **Performance**: Speed, reliability concerns
+- **Value**: Perceived value and benefits
+
+### 6. Feature-Specific Feedback
+
+For each feature mentioned:
+
+- Overall sentiment
+- Positive feedback
+- Negative feedback
+- Suggested improvements
+
+### 7. Priority Issues
+
+Critical items requiring immediate attention:
+
+- Issue description
+- Priority level (critical/high/medium)
+- Number/percentage of users affected
+- Recommended action
+
+### 8. Positive Highlights
+
+What users loved:
+
+- Features or aspects that delighted users
+- Strengths to maintain or amplify
+
+### 9. Recommendations
+
+4-6 actionable recommendations, each with:
+
+- Recommendation title and description
+- Rationale based on feedback
+- Effort estimate (low/medium/high)
+- Expected impact (low/medium/high)
+
+## Analysis Principles
+
+**Semantic Analysis:**
+
+- Use AI to understand meaning and context, not just keywords
+- Identify themes across different wording
+- Understand user intent and emotion
+
+**Evidence-Based:**
+
+- Support findings with specific quotes or data
+- Quantify when possible
+- Don't over-generalize from limited data
+
+**Actionable:**
+
+- Translate insights into specific recommendations
+- Prioritize by impact and urgency
+- Make recommendations concrete and implementable
+
+**Objective:**
+
+- Present both positive and negative feedback fairly
+- Avoid bias toward confirming existing beliefs
+- Let data speak for itself
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Analyzers::FeedbackAnalyzer`:
+
+1. Read feedback data from `.aidp/docs/feedback_data.json`
+2. Analyze using `FeedbackAnalyzer.new(ai_decision_engine:).analyze(feedback_data)`
+3. Format as markdown using `format_as_markdown(analysis)`
+4. Write to `.aidp/docs/USER_FEEDBACK_ANALYSIS.md`
+
+**For other implementations**, create equivalent functionality that:
+
+1. Parses normalized feedback data
+2. Uses AI for semantic analysis (NO regex, keyword matching, or heuristics)
+3. Identifies patterns and themes
+4. Calculates sentiment distribution
+5. Extracts evidence-based findings
+6. Generates prioritized recommendations
+7. Formats as comprehensive markdown report
+
+## AI Analysis Guidelines
+
+Use AI Decision Engine with Zero Framework Cognition:
+
+**NO:**
+
+- Regex pattern matching
+- Keyword counting
+- Scoring formulas
+- Heuristic thresholds
+
+**YES:**
+
+- Semantic understanding of text
+- Context-aware analysis
+- Theme identification across varied wording
+- Nuanced sentiment analysis
+- Evidence-based recommendations
+
+Provide structured schema for consistent output.
+
+## Output Structure
+
+Write to `.aidp/docs/USER_FEEDBACK_ANALYSIS.md` with:
+
+- Executive summary
+- Sentiment breakdown (table with counts and percentages)
+- Key findings with evidence and impact
+- Trends and patterns with frequency and implications
+- Categorized insights (usability, features, performance, value)
+- Feature-specific feedback (positive, negative, improvements)
+- Priority issues (with recommended actions)
+- Positive highlights
+- Actionable recommendations (with rationale, effort, impact)
+- Generated timestamp and metadata
+
+## Common Pitfalls to Avoid
+
+- Keyword matching instead of semantic understanding
+- Ignoring negative feedback
+- Over-generalizing from limited responses
+- Recommendations without evidence
+- Analysis paralysis (waiting for perfect data)
+
+## Output
+
+Write complete feedback analysis to `.aidp/docs/USER_FEEDBACK_ANALYSIS.md` with all insights and evidence-based recommendations.

data/templates/planning/agile/generate_iteration_plan.md

@@ -0,0 +1,179 @@
+# Generate Next Iteration Plan
+
+You are a product manager creating the next iteration plan based on user feedback.
+
+## Input
+
+Read:
+
+- `.aidp/docs/USER_FEEDBACK_ANALYSIS.md` - Analyzed user feedback with insights and recommendations
+- `.aidp/docs/MVP_SCOPE.md` (if available) - Current MVP features
+
+## Your Task
+
+Create a detailed plan for the next development iteration that addresses user feedback, prioritizes improvements, and defines specific, actionable tasks.
+
+## Iteration Plan Components
+
+### 1. Overview
+
+- Focus of this iteration
+- Why these priorities
+- Expected outcomes
+
+### 2. Iteration Goals
+
+3-5 clear, measurable goals for this iteration
+
+### 3. Feature Improvements
+
+For existing features that need enhancement:
+
+- Feature name
+- Current issue/problem
+- Proposed improvement
+- User impact
+- Effort estimate (low/medium/high)
+- Priority (critical/high/medium/low)
+
+### 4. New Features
+
+Features to add based on user requests:
+
+- Feature name and description
+- Rationale (why add this now)
+- Acceptance criteria
+- Effort estimate
+
+### 5. Bug Fixes
+
+Critical and high-priority bugs:
+
+- Bug title and description
+- Priority level
+- Number/percentage of users affected
+- Fix approach
+
+### 6. Technical Debt
+
+Technical improvements needed:
+
+- Debt item title and description
+- Why it matters (impact on quality, performance, maintainability)
+- Effort estimate
+
+### 7. Task Breakdown
+
+Specific, actionable tasks:
+
+- Task name and description
+- Category (feature, improvement, bug_fix, tech_debt, testing, documentation)
+- Priority
+- Estimated effort
+- Dependencies
+- Success criteria
+
+### 8. Success Metrics
+
+How to measure iteration success:
+
+- Metric name
+- Target value
+- How to measure
+
+### 9. Risks and Mitigation
+
+What could go wrong:
+
+- Risk description
+- Probability (low/medium/high)
+- Impact (low/medium/high)
+- Mitigation strategy
+
+### 10. Timeline
+
+Iteration phases:
+
+- Phase name
+- Duration
+- Key activities
+
+## Prioritization Framework
+
+Consider these factors when prioritizing:
+
+1. **User Impact**: How many users benefit? How significantly?
+2. **Business Value**: Does this align with business goals?
+3. **Effort**: How much work required?
+4. **Risk**: What's the probability and impact of failure?
+5. **Dependencies**: What must happen first?
+6. **Learning**: What will we learn from building this?
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Generators::IterationPlanGenerator`:
+
+1. Parse feedback analysis using `Aidp::Planning::Parsers::DocumentParser`
+2. Parse MVP scope if available
+3. Generate plan using `IterationPlanGenerator.generate(feedback_analysis:, current_mvp:)`
+4. Format as markdown using `format_as_markdown(plan)`
+5. Write to `.aidp/docs/NEXT_ITERATION_PLAN.md`
+
+**For other implementations**, create equivalent functionality that:
+
+1. Parses feedback analysis to understand issues and recommendations
+2. Parses current MVP scope if available
+3. Uses AI to transform recommendations into actionable tasks
+4. Prioritizes based on user impact, effort, and dependencies
+5. Breaks down work into specific tasks
+6. Defines success metrics for iteration
+7. Identifies and plans mitigation for risks
+
+## AI Analysis Guidelines
+
+Use AI Decision Engine to:
+
+- Transform feedback insights into specific improvements
+- Prioritize tasks by impact and effort
+- Break down complex improvements into tasks
+- Identify dependencies and sequencing
+- Suggest realistic timelines
+
+Be specific and actionable—tasks should be clear enough for developers to implement.
+
+## Task Categories
+
+- **feature**: New functionality
+- **improvement**: Enhancement to existing feature
+- **bug_fix**: Resolve defect or error
+- **tech_debt**: Technical improvement (refactoring, performance, etc.)
+- **testing**: Test coverage or quality improvements
+- **documentation**: User guides, API docs, etc.
+
+## Output Structure
+
+Write to `.aidp/docs/NEXT_ITERATION_PLAN.md` with:
+
+- Overview of iteration focus
+- Iteration goals (3-5 measurable goals)
+- Feature improvements (with issue, improvement, impact, effort, priority)
+- New features (with rationale and acceptance criteria)
+- Bug fixes (with priority and affected users)
+- Technical debt items (with impact and effort)
+- Task breakdown (with category, priority, effort, dependencies, success criteria)
+- Success metrics and targets
+- Risks with probability, impact, and mitigation
+- Timeline with phases and activities
+- Generated timestamp and metadata
+
+## Common Pitfalls to Avoid
+
+- Vague, non-actionable tasks
+- Ignoring technical debt
+- Over-ambitious scope for iteration
+- Missing dependencies between tasks
+- No clear success metrics
+
+## Output
+
+Write complete iteration plan to `.aidp/docs/NEXT_ITERATION_PLAN.md` with specific, prioritized, actionable tasks based on user feedback.

data/templates/planning/agile/generate_legacy_research_plan.md

@@ -0,0 +1,171 @@
+# Generate Legacy User Research Plan
+
+You are a UX researcher creating a user research plan for an existing codebase/product.
+
+## Your Task
+
+Analyze an existing codebase to understand what features are already built, then create a user research plan to understand how users experience the product and identify improvement opportunities.
+
+## Interactive Input
+
+**Prompt the user for:**
+
+1. Path to codebase directory
+2. Primary language/framework (for context)
+3. Known user segments (if any)
+
+## Codebase Analysis
+
+Analyze the existing codebase to understand:
+
+1. **Feature Inventory**: What features currently exist
+2. **User-Facing Components**: UI, APIs, endpoints, workflows
+3. **Integration Points**: External services, databases
+4. **Configuration Options**: Customization and settings
+5. **Documentation**: README, docs, comments
+
+Use tree-sitter or static analysis to extract:
+
+- Classes and modules
+- Public APIs and methods
+- User workflows and entry points
+- Feature flags or toggles
+- Configuration files
+
+## Legacy Research Plan Components
+
+### 1. Current Feature Audit
+
+List of features identified in codebase:
+
+- Feature name
+- Description (what it does)
+- Entry points (how users access it)
+- Status (active, deprecated, experimental)
+
+### 2. Research Questions
+
+Key questions to answer about user experience:
+
+- How are users currently using each feature?
+- What pain points exist in current workflows?
+- Which features are most/least valuable?
+- Where do users get confused or stuck?
+- What improvements would have biggest impact?
+
+### 3. Research Methods
+
+Appropriate methods for legacy product:
+
+- **User Interviews**: Understand current usage and pain points
+- **Usage Analytics**: Analyze feature adoption and patterns
+- **Usability Testing**: Observe users with existing features
+- **Surveys**: Collect feedback from broad user base
+
+### 4. Testing Priorities
+
+Which features/flows to focus on first:
+
+- High-usage features (most critical)
+- Features with known issues
+- Recently changed or updated features
+- Features with low adoption (understand why)
+
+### 5. User Segments
+
+Different types of users to study:
+
+- Power users vs. casual users
+- Different use cases or workflows
+- Different industries or contexts
+
+### 6. Improvement Opportunities
+
+Based on codebase analysis:
+
+- Missing features users likely need
+- Workflows that could be streamlined
+- Technical debt affecting user experience
+- Areas for modernization
+
+### 7. Research Timeline
+
+Phases with duration:
+
+- Codebase analysis completion
+- User recruitment
+- Data collection (interviews, surveys, testing)
+- Analysis and reporting
+
+## Implementation
+
+**For Ruby/AIDP projects**, use the `ruby_aidp_planning` skill with `Aidp::Planning::Generators::LegacyResearchPlanner`:
+
+1. Prompt for codebase path using TTY::Prompt
+2. Analyze codebase structure (tree-sitter, file scanning)
+3. Generate research plan using `LegacyResearchPlanner.generate(codebase_path:)`
+4. Format as markdown using `format_as_markdown(plan)`
+5. Write to `.aidp/docs/LEGACY_USER_RESEARCH_PLAN.md`
+
+**For other implementations**, create equivalent functionality that:
+
+1. Prompts for codebase information
+2. Analyzes codebase to extract feature list
+3. Uses AI to generate contextual research questions
+4. Identifies testing priorities based on feature importance
+5. Suggests appropriate research methods
+6. Creates improvement recommendations based on code analysis
+
+## Codebase Analysis Approach
+
+For static analysis:
+
+- Parse main entry points and routes
+- Extract public APIs and classes
+- Identify user-facing components
+- Find configuration and feature flags
+- Review documentation for feature descriptions
+
+For tree-sitter analysis:
+
+- Parse AST to find classes and methods
+- Identify public vs. private interfaces
+- Extract comments and documentation
+- Find integration points
+- Map user workflows
+
+## AI Analysis Guidelines
+
+Use AI Decision Engine to:
+
+- Generate feature descriptions from code structure
+- Create contextual research questions based on features
+- Prioritize features for testing
+- Suggest improvement opportunities
+- Recommend appropriate research methods
+
+## Output Structure
+
+Write to `.aidp/docs/LEGACY_USER_RESEARCH_PLAN.md` with:
+
+- Overview of research goals
+- Current feature audit (features identified in codebase)
+- Research questions to answer
+- Recommended research methods
+- Testing priorities (features to focus on)
+- User segments to study
+- Improvement opportunities identified
+- Research timeline
+- Generated timestamp and metadata
+
+## Common Use Cases
+
+- Understanding usage of existing product before redesign
+- Identifying pain points in mature product
+- Prioritizing feature improvements
+- Planning modernization efforts
+- Validating assumptions about user needs
+
+## Output
+
+Write complete legacy user research plan to `.aidp/docs/LEGACY_USER_RESEARCH_PLAN.md` based on codebase analysis and AI-generated research questions.