aidp 0.27.0 → 0.28.0

data/lib/aidp/planning/generators/gantt_generator.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "../../logger"
+
+module Aidp
+  module Planning
+    module Generators
+      # Generates Mermaid Gantt charts with critical path analysis
+      # Visualizes project timeline, dependencies, and milestones
+      class GanttGenerator
+        def initialize(config: nil)
+          @config = config || Aidp::Config.waterfall_config
+        end
+
+        # Generate Gantt chart from WBS and task list
+        # @param wbs [Hash] Work breakdown structure
+        # @param task_list [Array<Hash>] Optional detailed task list
+        # @return [Hash] Gantt chart data and Mermaid syntax
+        def generate(wbs:, task_list: nil)
+          Aidp.log_debug("gantt_generator", "generate", phase_count: wbs[:phases].size)
+
+          tasks = extract_tasks_from_wbs(wbs)
+          calculate_durations(tasks)
+          critical_path = calculate_critical_path(tasks)
+
+          Aidp.log_debug("gantt_generator", "calculated", task_count: tasks.size, critical_path_length: critical_path.size)
+
+          {
+            tasks: tasks,
+            critical_path: critical_path,
+            mermaid: format_mermaid(tasks, critical_path),
+            metadata: {
+              generated_at: Time.now.iso8601,
+              total_tasks: tasks.size,
+              critical_path_length: critical_path.size
+            }
+          }
+        end
+
+        # Format as Mermaid gantt syntax
+        # @param gantt_data [Hash] Gantt chart data
+        # @return [String] Mermaid formatted chart
+        def format_mermaid(tasks, critical_path)
+          Aidp.log_debug("gantt_generator", "format_mermaid")
+
+          output = ["gantt"]
+          output << "    title Project Timeline"
+          output << "    dateFormat YYYY-MM-DD"
+          output << "    section Planning"
+
+          current_section = nil
+
+          tasks.each do |task|
+            if task[:phase] != current_section
+              current_section = task[:phase]
+              output << "    section #{current_section}"
+            end
+
+            status = critical_path.include?(task[:id]) ? "crit" : ""
+            duration = task[:duration] || 1
+
+            # Mermaid gantt task format: TaskName :status, id, start, duration
+            if task[:dependencies].empty?
+              output << "    #{task[:name]} :#{status}, #{task[:id]}, #{duration}d"
+            else
+              after_task = task[:dependencies].first.tr(" ", "_")
+              output << "    #{task[:name]} :#{status}, #{task[:id]}, after #{after_task}, #{duration}d"
+            end
+          end
+
+          output.join("\n")
+        end
+
+        private
+
+        # Extract flat task list from WBS hierarchy
+        def extract_tasks_from_wbs(wbs)
+          tasks = []
+          task_counter = 0
+
+          wbs[:phases].each do |phase|
+            phase[:tasks].each do |task|
+              task_counter += 1
+              task_id = "task#{task_counter}"
+
+              tasks << {
+                id: task_id,
+                name: task[:name],
+                phase: phase[:name],
+                effort: task[:effort],
+                dependencies: task[:dependencies] || [],
+                duration: nil # Will be calculated
+              }
+            end
+          end
+
+          tasks
+        end
+
+        # Calculate task durations from effort estimates
+        # Converts story points to days (simplified: 1 story point = 0.5 days)
+        def calculate_durations(tasks)
+          Aidp.log_debug("gantt_generator", "calculate_durations", count: tasks.size)
+
+          tasks.each do |task|
+            if task[:effort]
+              # Extract numeric value from effort string (e.g., "3 story points" => 3)
+              effort_value = task[:effort].to_s.match(/\d+/)&.[](0).to_i
+              task[:duration] = [1, (effort_value * 0.5).ceil].max # Minimum 1 day
+            else
+              task[:duration] = 1 # Default to 1 day
+            end
+          end
+        end
+
+        # Calculate critical path through task dependencies
+        # Returns array of task IDs that form the longest path
+        def calculate_critical_path(tasks)
+          Aidp.log_debug("gantt_generator", "calculate_critical_path")
+
+          # Build dependency graph
+          graph = build_dependency_graph(tasks)
+
+          # Find longest path (critical path)
+          longest_path = []
+          max_duration = 0
+
+          # Start from tasks with no dependencies
+          start_tasks = tasks.select { |t| t[:dependencies].empty? }
+
+          start_tasks.each do |start_task|
+            path = find_longest_path(start_task, graph, tasks, [])
+            path_duration = calculate_path_duration(path, tasks)
+
+            if path_duration > max_duration
+              max_duration = path_duration
+              longest_path = path
+            end
+          end
+
+          Aidp.log_debug("gantt_generator", "critical_path_found", length: longest_path.size, duration: max_duration)
+          longest_path
+        end
+
+        def build_dependency_graph(tasks)
+          graph = Hash.new { |h, k| h[k] = [] }
+
+          tasks.each do |task|
+            task[:dependencies].each do |dep_name|
+              dep_task = tasks.find { |t| t[:name] == dep_name }
+              graph[dep_task[:id]] << task[:id] if dep_task
+            end
+          end
+
+          graph
+        end
+
+        def find_longest_path(current_task, graph, all_tasks, visited)
+          return [current_task[:id]] if visited.include?(current_task[:id])
+
+          visited += [current_task[:id]]
+          dependent_tasks = graph[current_task[:id]] || []
+
+          if dependent_tasks.empty?
+            [current_task[:id]]
+          else
+            longest = []
+
+            dependent_tasks.each do |dep_id|
+              dep_task = all_tasks.find { |t| t[:id] == dep_id }
+              next unless dep_task
+
+              path = find_longest_path(dep_task, graph, all_tasks, visited)
+              longest = path if path.size > longest.size
+            end
+
+            [current_task[:id]] + longest
+          end
+        end
+
+        def calculate_path_duration(path, tasks)
+          path.sum do |task_id|
+            task = tasks.find { |t| t[:id] == task_id }
+            task ? (task[:duration] || 1) : 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/planning/generators/iteration_plan_generator.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+require_relative "../../logger"
+
+module Aidp
+  module Planning
+    module Generators
+      # Generates next iteration plan based on user feedback
+      # Creates actionable tasks to address feedback and improve product
+      # Uses Zero Framework Cognition (ZFC) for priority and task generation
+      class IterationPlanGenerator
+        def initialize(ai_decision_engine:, wbs_generator: nil, config: nil)
+          @ai_decision_engine = ai_decision_engine
+          @wbs_generator = wbs_generator
+          @config = config || Aidp::Config.agile_config
+        end
+
+        # Generate iteration plan from feedback analysis
+        # @param feedback_analysis [Hash] Analyzed feedback data
+        # @param current_mvp [Hash] Current MVP scope (optional)
+        # @return [Hash] Iteration plan structure
+        def generate(feedback_analysis:, current_mvp: nil)
+          Aidp.log_debug("iteration_plan_generator", "generate",
+            recommendations: feedback_analysis[:recommendations]&.size || 0)
+
+          # Use AI to generate iteration plan
+          iteration_plan = generate_plan_with_ai(feedback_analysis, current_mvp)
+
+          {
+            overview: iteration_plan[:overview],
+            goals: iteration_plan[:goals],
+            improvements: iteration_plan[:improvements],
+            new_features: iteration_plan[:new_features],
+            bug_fixes: iteration_plan[:bug_fixes],
+            technical_debt: iteration_plan[:technical_debt],
+            tasks: iteration_plan[:tasks],
+            success_metrics: iteration_plan[:success_metrics],
+            risks: iteration_plan[:risks],
+            timeline: iteration_plan[:timeline],
+            metadata: {
+              generated_at: Time.now.iso8601,
+              improvement_count: iteration_plan[:improvements]&.size || 0,
+              new_feature_count: iteration_plan[:new_features]&.size || 0,
+              task_count: iteration_plan[:tasks]&.size || 0,
+              based_on_feedback: !feedback_analysis.nil?
+            }
+          }
+        end
+
+        # Format iteration plan as markdown
+        # @param plan [Hash] Iteration plan structure
+        # @return [String] Markdown formatted iteration plan
+        def format_as_markdown(plan)
+          Aidp.log_debug("iteration_plan_generator", "format_as_markdown")
+
+          output = ["# Next Iteration Plan", ""]
+          output << "**Generated:** #{plan[:metadata][:generated_at]}"
+          output << "**Improvements:** #{plan[:metadata][:improvement_count]}"
+          output << "**New Features:** #{plan[:metadata][:new_feature_count]}"
+          output << "**Total Tasks:** #{plan[:metadata][:task_count]}"
+          output << ""
+
+          output << "## Overview"
+          output << ""
+          output << plan[:overview]
+          output << ""
+
+          output << "## Iteration Goals"
+          output << ""
+          plan[:goals].each_with_index do |goal, idx|
+            output << "#{idx + 1}. #{goal}"
+          end
+          output << ""
+
+          output << "## Feature Improvements"
+          output << ""
+          output << "Based on user feedback, these existing features will be improved:"
+          output << ""
+          plan[:improvements].each_with_index do |improvement, idx|
+            output << "### #{idx + 1}. #{improvement[:feature_name]}"
+            output << ""
+            output << "**Current Issue:** #{improvement[:issue]}"
+            output << ""
+            output << "**Proposed Improvement:** #{improvement[:improvement]}"
+            output << ""
+            output << "**User Impact:** #{improvement[:impact]}"
+            output << ""
+            output << "**Effort:** #{improvement[:effort]}"
+            output << ""
+            output << "**Priority:** #{improvement[:priority]}"
+            output << ""
+          end
+
+          output << "## New Features"
+          output << ""
+          output << "New features to be added based on user requests:"
+          output << ""
+          plan[:new_features].each_with_index do |feature, idx|
+            output << "### #{idx + 1}. #{feature[:name]}"
+            output << ""
+            output << feature[:description]
+            output << ""
+            output << "**Rationale:** #{feature[:rationale]}"
+            output << ""
+            output << "**Acceptance Criteria:**"
+            (feature[:acceptance_criteria] || []).each do |criterion|
+              output << "- #{criterion}"
+            end
+            output << ""
+            output << "**Effort:** #{feature[:effort]}"
+            output << ""
+          end
+
+          output << "## Bug Fixes"
+          output << ""
+          plan[:bug_fixes].each_with_index do |bug, idx|
+            output << "#{idx + 1}. **#{bug[:title]}** (Priority: #{bug[:priority]})"
+            output << "   - Description: #{bug[:description]}"
+            output << "   - Affected Users: #{bug[:affected_users]}"
+            output << ""
+          end
+
+          output << "## Technical Debt"
+          output << ""
+          output << "Technical improvements to be addressed:"
+          output << ""
+          plan[:technical_debt].each do |debt|
+            output << "- **#{debt[:title]}:** #{debt[:description]} (Effort: #{debt[:effort]})"
+          end
+          output << ""
+
+          output << "## Task Breakdown"
+          output << ""
+          plan[:tasks].each_with_index do |task, idx|
+            output << "### Task #{idx + 1}: #{task[:name]}"
+            output << ""
+            output << "**Description:** #{task[:description]}"
+            output << ""
+            output << "**Category:** #{task[:category]}"
+            output << ""
+            output << "**Priority:** #{task[:priority]}"
+            output << ""
+            output << "**Estimated Effort:** #{task[:effort]}"
+            output << ""
+            output << "**Dependencies:** #{task[:dependencies]&.join(", ") || "None"}"
+            output << ""
+            output << "**Success Criteria:**"
+            (task[:success_criteria] || []).each do |criterion|
+              output << "- #{criterion}"
+            end
+            output << ""
+          end
+
+          output << "## Success Metrics"
+          output << ""
+          output << "How we'll measure success of this iteration:"
+          output << ""
+          plan[:success_metrics].each do |metric|
+            output << "- **#{metric[:name]}:** #{metric[:target]}"
+            output << ""
+          end
+
+          output << "## Risks and Mitigation"
+          output << ""
+          plan[:risks].each_with_index do |risk, idx|
+            output << "#{idx + 1}. **#{risk[:title]}**"
+            output << "   - Probability: #{risk[:probability]}"
+            output << "   - Impact: #{risk[:impact]}"
+            output << "   - Mitigation: #{risk[:mitigation]}"
+            output << ""
+          end
+
+          output << "## Timeline"
+          output << ""
+          plan[:timeline].each do |phase|
+            output << "- **#{phase[:phase]}:** #{phase[:duration]} (#{phase[:activities]})"
+          end
+          output << ""
+
+          output.join("\n")
+        end
+
+        private
+
+        def generate_plan_with_ai(feedback_analysis, current_mvp)
+          Aidp.log_debug("iteration_plan_generator", "generate_plan_with_ai")
+
+          prompt = build_iteration_prompt(feedback_analysis, current_mvp)
+
+          schema = {
+            type: "object",
+            properties: {
+              overview: {type: "string"},
+              goals: {type: "array", items: {type: "string"}},
+              improvements: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    feature_name: {type: "string"},
+                    issue: {type: "string"},
+                    improvement: {type: "string"},
+                    impact: {type: "string"},
+                    effort: {type: "string"},
+                    priority: {type: "string"}
+                  }
+                }
+              },
+              new_features: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    name: {type: "string"},
+                    description: {type: "string"},
+                    rationale: {type: "string"},
+                    acceptance_criteria: {type: "array", items: {type: "string"}},
+                    effort: {type: "string"}
+                  }
+                }
+              },
+              bug_fixes: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    title: {type: "string"},
+                    description: {type: "string"},
+                    priority: {type: "string"},
+                    affected_users: {type: "string"}
+                  }
+                }
+              },
+              technical_debt: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    title: {type: "string"},
+                    description: {type: "string"},
+                    effort: {type: "string"}
+                  }
+                }
+              },
+              tasks: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    name: {type: "string"},
+                    description: {type: "string"},
+                    category: {type: "string"},
+                    priority: {type: "string"},
+                    effort: {type: "string"},
+                    dependencies: {type: "array", items: {type: "string"}},
+                    success_criteria: {type: "array", items: {type: "string"}}
+                  }
+                }
+              },
+              success_metrics: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    name: {type: "string"},
+                    target: {type: "string"}
+                  }
+                }
+              },
+              risks: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    title: {type: "string"},
+                    probability: {type: "string"},
+                    impact: {type: "string"},
+                    mitigation: {type: "string"}
+                  }
+                }
+              },
+              timeline: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    phase: {type: "string"},
+                    duration: {type: "string"},
+                    activities: {type: "string"}
+                  }
+                }
+              }
+            },
+            required: ["overview", "goals", "improvements", "tasks"]
+          }
+
+          decision = @ai_decision_engine.decide(
+            context: "iteration_plan_generation",
+            prompt: prompt,
+            data: {
+              feedback_analysis: feedback_analysis,
+              current_mvp: current_mvp
+            },
+            schema: schema
+          )
+
+          Aidp.log_debug("iteration_plan_generator", "ai_plan_generated",
+            tasks: decision[:tasks]&.size || 0,
+            improvements: decision[:improvements]&.size || 0)
+
+          decision
+        end
+
+        def build_iteration_prompt(feedback_analysis, current_mvp)
+          mvp_context = if current_mvp
+            <<~CONTEXT
+              CURRENT MVP FEATURES:
+              #{current_mvp[:mvp_features]&.map { |f| "- #{f[:name]}: #{f[:description]}" }&.join("\n") || "No features"}
+            CONTEXT
+          else
+            ""
+          end
+
+          <<~PROMPT
+            Generate a detailed iteration plan based on user feedback analysis.
+
+            FEEDBACK SUMMARY:
+            #{feedback_analysis[:summary]}
+
+            KEY FINDINGS:
+            #{feedback_analysis[:findings]&.map { |f| "- #{f[:title]}: #{f[:description]}" }&.join("\n") || "No findings"}
+
+            RECOMMENDATIONS:
+            #{feedback_analysis[:recommendations]&.map { |r| "- #{r[:title]}: #{r[:description]}" }&.join("\n") || "No recommendations"}
+
+            PRIORITY ISSUES:
+            #{feedback_analysis[:priority_issues]&.map { |i| "- #{i[:title]} (#{i[:priority]})" }&.join("\n") || "No priority issues"}
+
+            #{mvp_context}
+
+            TASK:
+            Create a comprehensive iteration plan:
+
+            1. OVERVIEW
+               - What is the focus of this iteration?
+               - Why these priorities?
+
+            2. ITERATION GOALS (3-5 goals)
+               - Clear, measurable goals for this iteration
+
+            3. FEATURE IMPROVEMENTS
+               - For existing features that need enhancement
+               - Current issue, proposed improvement, user impact, effort, priority
+
+            4. NEW FEATURES
+               - Features to add based on user requests
+               - Description, rationale, acceptance criteria, effort estimate
+
+            5. BUG FIXES
+               - Critical and high-priority bugs from feedback
+               - Priority, description, affected users
+
+            6. TECHNICAL DEBT
+               - Technical improvements needed
+               - Performance, scalability, maintainability issues
+
+            7. TASK BREAKDOWN
+               - Specific, actionable tasks
+               - For each: description, category, priority, effort, dependencies, success criteria
+               - Categories: feature, improvement, bug_fix, tech_debt, testing, documentation
+
+            8. SUCCESS METRICS
+               - How to measure iteration success
+               - Specific targets
+
+            9. RISKS AND MITIGATION
+               - What could go wrong?
+               - Probability (low/medium/high)
+               - Impact (low/medium/high)
+               - Mitigation strategy
+
+            10. TIMELINE
+               - Phases of the iteration
+               - Duration and key activities
+
+            Prioritize based on user impact, effort, and dependencies. Be specific and actionable.
+          PROMPT
+        end
+      end
+    end
+  end
+end