aidp 0.9.6 → 0.11.0

data/lib/aidp/workflows/definitions.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Workflows
+    # Centralized workflow definitions for both Analyze and Execute modes
+    # Provides pre-configured workflows at various levels of depth/complexity
+    module Definitions
+      # Analyze mode workflows - from surface-level to deep analysis
+      ANALYZE_WORKFLOWS = {
+        quick_overview: {
+          name: "Quick Overview",
+          description: "Surface-level understanding - What does this project do?",
+          icon: "🔍",
+          details: [
+            "Repository structure scan",
+            "High-level functionality mapping",
+            "Quick documentation review"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "04_FUNCTIONALITY_ANALYSIS",
+            "05_DOCUMENTATION_ANALYSIS"
+          ]
+        },
+
+        style_guide: {
+          name: "Style & Patterns",
+          description: "Identify coding patterns and create style guide",
+          icon: "📐",
+          details: [
+            "Code pattern analysis",
+            "Style consistency review",
+            "Generate project style guide"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "06_STATIC_ANALYSIS",
+            "06A_TREE_SITTER_SCAN"
+          ]
+        },
+
+        architecture_review: {
+          name: "Architecture Review",
+          description: "Understand system architecture and dependencies",
+          icon: "🏗️",
+          details: [
+            "Architecture pattern analysis",
+            "Dependency mapping",
+            "Component relationships",
+            "Design principles review"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "02_ARCHITECTURE_ANALYSIS",
+            "06A_TREE_SITTER_SCAN"
+          ]
+        },
+
+        quality_assessment: {
+          name: "Quality Assessment",
+          description: "Comprehensive code quality and test coverage analysis",
+          icon: "✅",
+          details: [
+            "Test coverage analysis",
+            "Code quality metrics",
+            "Static analysis review",
+            "Refactoring opportunities"
+          ],
+          steps: [
+            "03_TEST_ANALYSIS",
+            "06_STATIC_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "07_REFACTORING_RECOMMENDATIONS"
+          ]
+        },
+
+        deep_analysis: {
+          name: "Deep Analysis",
+          description: "Complete analysis for extension/refactoring",
+          icon: "🔬",
+          details: [
+            "Full repository analysis",
+            "Architecture deep dive",
+            "Complete test coverage analysis",
+            "Functionality mapping",
+            "Documentation review",
+            "Static analysis",
+            "Tree-sitter knowledge base",
+            "Refactoring recommendations"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "02_ARCHITECTURE_ANALYSIS",
+            "03_TEST_ANALYSIS",
+            "04_FUNCTIONALITY_ANALYSIS",
+            "05_DOCUMENTATION_ANALYSIS",
+            "06_STATIC_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "07_REFACTORING_RECOMMENDATIONS"
+          ]
+        },
+
+        custom: {
+          name: "Custom Analysis",
+          description: "Choose specific analysis steps",
+          icon: "⚙️",
+          details: ["Select exactly which analysis steps you need"],
+          steps: :custom # Will be populated by user selection
+        }
+      }.freeze
+
+      # Execute mode workflows - from quick prototype to enterprise-grade
+      EXECUTE_WORKFLOWS = {
+        quick_prototype: {
+          name: "Quick Prototype",
+          description: "Rapid prototype - minimal planning, fast iteration",
+          icon: "⚡",
+          details: [
+            "Minimal PRD",
+            "Basic testing strategy",
+            "Direct to implementation"
+          ],
+          steps: [
+            "00_PRD",
+            "10_TESTING_STRATEGY",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        exploration: {
+          name: "Exploration/Experiment",
+          description: "Proof of concept with basic quality checks",
+          icon: "🔬",
+          details: [
+            "Quick PRD generation",
+            "Testing strategy",
+            "Static analysis setup",
+            "Implementation with work loops"
+          ],
+          steps: [
+            "00_PRD",
+            "10_TESTING_STRATEGY",
+            "11_STATIC_ANALYSIS",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        feature_development: {
+          name: "Feature Development",
+          description: "Standard feature with architecture and testing",
+          icon: "🚀",
+          details: [
+            "Product requirements",
+            "Architecture design",
+            "Testing strategy",
+            "Static analysis",
+            "Implementation"
+          ],
+          steps: [
+            "00_PRD",
+            "02_ARCHITECTURE",
+            "10_TESTING_STRATEGY",
+            "11_STATIC_ANALYSIS",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        production_ready: {
+          name: "Production-Ready",
+          description: "Enterprise-grade with NFRs and compliance",
+          icon: "🏗️",
+          details: [
+            "Comprehensive PRD",
+            "Non-functional requirements",
+            "System architecture",
+            "Security review",
+            "Performance planning",
+            "Testing strategy",
+            "Observability & SLOs",
+            "Delivery planning",
+            "Implementation"
+          ],
+          steps: [
+            "00_PRD",
+            "01_NFRS",
+            "02_ARCHITECTURE",
+            "07_SECURITY_REVIEW",
+            "08_PERFORMANCE_REVIEW",
+            "10_TESTING_STRATEGY",
+            "11_STATIC_ANALYSIS",
+            "12_OBSERVABILITY_SLOS",
+            "13_DELIVERY_ROLLOUT",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        full_enterprise: {
+          name: "Full Enterprise",
+          description: "Complete enterprise workflow with all governance",
+          icon: "🏢",
+          details: [
+            "All planning documents",
+            "Architecture decision records",
+            "Domain decomposition",
+            "API design",
+            "Security & performance reviews",
+            "Reliability planning",
+            "Complete observability",
+            "Documentation portal"
+          ],
+          steps: [
+            "00_PRD",
+            "01_NFRS",
+            "02_ARCHITECTURE",
+            "03_ADR_FACTORY",
+            "04_DOMAIN_DECOMPOSITION",
+            "05_API_DESIGN",
+            "07_SECURITY_REVIEW",
+            "08_PERFORMANCE_REVIEW",
+            "09_RELIABILITY_REVIEW",
+            "10_TESTING_STRATEGY",
+            "11_STATIC_ANALYSIS",
+            "12_OBSERVABILITY_SLOS",
+            "13_DELIVERY_ROLLOUT",
+            "14_DOCS_PORTAL",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        custom: {
+          name: "Custom Workflow",
+          description: "Choose specific planning and implementation steps",
+          icon: "⚙️",
+          details: ["Select exactly which steps you need"],
+          steps: :custom # Will be populated by user selection
+        }
+      }.freeze
+
+      # Hybrid workflows - mix of analyze and execute steps
+      HYBRID_WORKFLOWS = {
+        legacy_modernization: {
+          name: "Legacy Modernization",
+          description: "Analyze existing code then plan modernization",
+          icon: "♻️",
+          details: [
+            "Deep code analysis",
+            "Refactoring recommendations",
+            "Architecture design for new system",
+            "Migration planning",
+            "Implementation"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "02_ARCHITECTURE_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "07_REFACTORING_RECOMMENDATIONS",
+            "00_PRD",
+            "02_ARCHITECTURE",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        style_guide_enforcement: {
+          name: "Style Guide Enforcement",
+          description: "Extract patterns then enforce them",
+          icon: "📏",
+          details: [
+            "Analyze existing patterns",
+            "Generate LLM style guide",
+            "Configure static analysis",
+            "Implement enforcement"
+          ],
+          steps: [
+            "01_REPOSITORY_ANALYSIS",
+            "06_STATIC_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "00_LLM_STYLE_GUIDE",
+            "11_STATIC_ANALYSIS",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        test_coverage_improvement: {
+          name: "Test Coverage Improvement",
+          description: "Analyze gaps then implement comprehensive tests",
+          icon: "🧪",
+          details: [
+            "Test coverage analysis",
+            "Functionality mapping",
+            "Testing strategy design",
+            "Test implementation"
+          ],
+          steps: [
+            "03_TEST_ANALYSIS",
+            "04_FUNCTIONALITY_ANALYSIS",
+            "06A_TREE_SITTER_SCAN",
+            "10_TESTING_STRATEGY",
+            "16_IMPLEMENTATION"
+          ]
+        },
+
+        custom_hybrid: {
+          name: "Custom Hybrid",
+          description: "Mix analyze and execute steps",
+          icon: "🔀",
+          details: ["Choose from both analyze and execute steps"],
+          steps: :custom # Will be populated by user selection
+        }
+      }.freeze
+
+      # Get all available steps for custom selection
+      def self.all_available_steps
+        analyze_steps = Aidp::Analyze::Steps::SPEC.keys.map do |step|
+          {
+            step: step,
+            mode: :analyze,
+            description: Aidp::Analyze::Steps::SPEC[step]["description"]
+          }
+        end
+
+        execute_steps = Aidp::Execute::Steps::SPEC.keys.map do |step|
+          {
+            step: step,
+            mode: :execute,
+            description: Aidp::Execute::Steps::SPEC[step]["description"]
+          }
+        end
+
+        (analyze_steps + execute_steps).sort_by { |s| s[:step] }
+      end
+
+      # Get workflow definition by key
+      def self.get_workflow(mode, workflow_key)
+        case mode
+        when :analyze
+          ANALYZE_WORKFLOWS[workflow_key]
+        when :execute
+          EXECUTE_WORKFLOWS[workflow_key]
+        when :hybrid
+          HYBRID_WORKFLOWS[workflow_key]
+        end
+      end
+
+      # Get all workflows for a mode
+      def self.workflows_for_mode(mode)
+        case mode
+        when :analyze
+          ANALYZE_WORKFLOWS
+        when :execute
+          EXECUTE_WORKFLOWS
+        when :hybrid
+          HYBRID_WORKFLOWS
+        end
+      end
+    end
+  end
+end

data/lib/aidp/workflows/selector.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "definitions"
+require_relative "../message_display"
+
+module Aidp
+  module Workflows
+    # Enhanced workflow selector with support for custom workflows
+    # Handles selection for analyze, execute, and hybrid modes
+    class Selector
+      include Aidp::MessageDisplay
+
+      def initialize(prompt: TTY::Prompt.new)
+        @prompt = prompt
+      end
+
+      # Select mode (analyze, execute, or hybrid)
+      def select_mode
+        display_message("\n🚀 Welcome to AI Dev Pipeline!", type: :highlight)
+        display_message("Choose your mode:\n", type: :highlight)
+
+        choices = {
+          "🔬 Analyze Mode" => :analyze,
+          "🏗️  Execute Mode" => :execute,
+          "🔀 Hybrid Mode" => :hybrid
+        }
+
+        @prompt.select("What would you like to do?", choices, per_page: 10)
+      end
+
+      # Select workflow for the given mode
+      def select_workflow(mode)
+        workflows = Definitions.workflows_for_mode(mode)
+
+        display_message("\n#{mode_header(mode)}", type: :highlight)
+        display_message("Choose a workflow:\n")
+
+        # Build choices with icons and descriptions
+        choices = workflows.map do |key, workflow|
+          {
+            name: "#{workflow[:icon]} #{workflow[:name]} - #{workflow[:description]}",
+            value: key
+          }
+        end
+
+        selected = @prompt.select(
+          "Select workflow:",
+          choices,
+          per_page: 15,
+          help: "(↑/↓ to navigate, Enter to select)"
+        )
+
+        workflow = workflows[selected]
+
+        # Show workflow details
+        display_workflow_details(workflow)
+
+        # Handle custom workflows
+        if workflow[:steps] == :custom
+          steps = select_custom_steps(mode)
+          {workflow_key: selected, steps: steps, workflow: workflow}
+        else
+          {workflow_key: selected, steps: workflow[:steps], workflow: workflow}
+        end
+      end
+
+      # Select custom steps for hybrid or custom workflows
+      def select_custom_steps(mode)
+        display_message("\n⚙️ Custom Step Selection", type: :highlight)
+        display_message("")
+
+        if mode == :hybrid
+          select_hybrid_steps
+        elsif mode == :analyze
+          select_steps_from_mode(:analyze)
+        elsif mode == :execute
+          select_steps_from_mode(:execute)
+        end
+      end
+
+      private
+
+      def mode_header(mode)
+        case mode
+        when :analyze
+          "🔬 Analyze Mode - Understand Your Codebase"
+        when :execute
+          "🏗️ Execute Mode - Build New Features"
+        when :hybrid
+          "🔀 Hybrid Mode - Analyze Then Execute"
+        end
+      end
+
+      def display_workflow_details(workflow)
+        display_message("\n#{workflow[:icon]} #{workflow[:name]}", type: :highlight)
+        display_message("─" * 60, type: :muted)
+        display_message("")
+        display_message("Description: #{workflow[:description]}")
+        display_message("")
+        display_message("Includes:", type: :highlight)
+        workflow[:details].each do |detail|
+          display_message("  • #{detail}", type: :info)
+        end
+        display_message("")
+      end
+
+      def select_steps_from_mode(mode)
+        spec = (mode == :analyze) ? Aidp::Analyze::Steps::SPEC : Aidp::Execute::Steps::SPEC
+
+        display_message("Available #{mode} steps:")
+        display_message("")
+
+        # Build step choices
+        step_choices = spec.map do |step_key, step_spec|
+          {
+            name: "#{step_key} - #{step_spec["description"]}",
+            value: step_key,
+            disabled: step_spec["gate"] ? "(requires manual review)" : false
+          }
+        end
+
+        selected_steps = @prompt.multi_select(
+          "Select steps (Space to select, Enter when done):",
+          step_choices,
+          per_page: 20,
+          help: "Select one or more steps"
+        )
+
+        if selected_steps.empty?
+          display_message("⚠️  No steps selected, using default workflow", type: :warning)
+          # Return a sensible default
+          (mode == :analyze) ? ["01_REPOSITORY_ANALYSIS"] : ["00_PRD", "16_IMPLEMENTATION"]
+        else
+          selected_steps.sort
+        end
+      end
+
+      def select_hybrid_steps
+        display_message("You can mix analyze and execute steps for a custom hybrid workflow.")
+        display_message("")
+
+        all_steps = Definitions.all_available_steps
+
+        # Group steps by mode for display
+        step_choices = all_steps.map do |step_info|
+          mode_tag = (step_info[:mode] == :analyze) ? "[ANALYZE]" : "[EXECUTE]"
+          {
+            name: "#{mode_tag} #{step_info[:step]} - #{step_info[:description]}",
+            value: step_info[:step]
+          }
+        end
+
+        selected_steps = @prompt.multi_select(
+          "Select steps (Space to select, Enter when done):",
+          step_choices,
+          per_page: 25,
+          help: "Mix analyze and execute steps as needed"
+        )
+
+        if selected_steps.empty?
+          display_message("⚠️  No steps selected, using default hybrid workflow", type: :warning)
+          # Return a sensible default hybrid
+          ["01_REPOSITORY_ANALYSIS", "00_PRD", "16_IMPLEMENTATION"]
+        else
+          selected_steps.sort
+        end
+      end
+    end
+  end
+end

data/lib/aidp.rb

@@ -7,7 +7,13 @@ require_relative "aidp/core_ext/class_attribute"
 require_relative "aidp/version"
 require_relative "aidp/config"
 require_relative "aidp/util"
+require_relative "aidp/message_display"
 require_relative "aidp/cli"
+
+# Jobs and background execution
+require_relative "aidp/jobs/background_runner"
+
+# CLI commands
 require_relative "aidp/cli/jobs_command"
 
 # Providers
@@ -33,15 +39,21 @@ require_relative "aidp/analyze/steps"
 require_relative "aidp/analyze/progress"
 
 # Tree-sitter analysis
-require_relative "aidp/analysis/tree_sitter_grammar_loader"
-require_relative "aidp/analysis/seams"
-require_relative "aidp/analysis/tree_sitter_scan"
-require_relative "aidp/analysis/kb_inspector"
+require_relative "aidp/analyze/tree_sitter_grammar_loader"
+require_relative "aidp/analyze/seams"
+require_relative "aidp/analyze/tree_sitter_scan"
+require_relative "aidp/analyze/kb_inspector"
+
+# Workflows
+require_relative "aidp/workflows/definitions"
+require_relative "aidp/workflows/selector"
 
 # Execute mode
 require_relative "aidp/execute/steps"
 require_relative "aidp/execute/runner"
 require_relative "aidp/execute/progress"
+require_relative "aidp/execute/checkpoint"
+require_relative "aidp/execute/checkpoint_display"
 
 # Harness mode
 require_relative "aidp/harness/configuration"

data/templates/planning/generate_llm_style_guide.md

@@ -0,0 +1,119 @@
+# Generate LLM Style Guide
+
+Your task is to create a project-specific **LLM_STYLE_GUIDE.md** that will be used by AI agents working on this project. This guide should be concise, actionable, and tailored to this specific codebase.
+
+## Context
+
+You have access to the project directory. Examine the codebase to understand:
+
+- Programming language(s) used
+- Existing code style and patterns
+- Testing framework and patterns
+- Build tools and configuration
+- Project structure
+- Dependencies and frameworks
+
+## Requirements
+
+Create a file at `docs/LLM_STYLE_GUIDE.md` with the following sections:
+
+### 1. Core Engineering Rules
+
+- Single Responsibility Principle applications
+- Code organization patterns specific to this project
+- When to extract methods/classes/modules
+- Dead code and TODO policies
+
+### 2. Naming & Structure
+
+- Language-specific naming conventions (if not standard)
+- File organization patterns
+- Module/package structure guidelines
+- Public API design principles
+
+### 3. Parameters & Data
+
+- Parameter passing conventions
+- Data structure preferences
+- Configuration management patterns
+
+### 4. Error Handling
+
+- Error handling strategy for this project
+- Logging patterns
+- Exception types and when to use them
+- Recovery strategies
+
+### 5. Testing Contracts
+
+- Testing philosophy for this project
+- What to test vs what not to test
+- Mocking/stubbing guidelines
+- Test organization and naming
+- Code coverage expectations
+
+### 6. Framework-Specific Guidelines
+
+- Key patterns from the frameworks used
+- Anti-patterns to avoid
+- Performance considerations
+- Security guidelines
+
+### 7. Dependencies & External Services
+
+- Dependency injection patterns
+- External service interaction patterns
+- API client patterns
+- Database interaction patterns (if applicable)
+
+### 8. Build & Development
+
+- Build commands and what they do
+- Linting and formatting tools
+- Pre-commit hooks (if any)
+- Development workflow
+
+### 9. Performance
+
+- Performance considerations for this codebase
+- Optimization strategies
+- Caching patterns
+- Resource management
+
+### 10. Project-Specific Anti-Patterns
+
+- Known anti-patterns in this codebase to avoid
+- Previous mistakes to learn from
+- Deprecated patterns to avoid
+
+## Output Format
+
+The LLM_STYLE_GUIDE.md should be:
+
+- **Concise**: Use bullet points and tables where possible
+- **Specific**: Reference actual code patterns from this project
+- **Actionable**: Provide clear do's and don'ts
+- **Scannable**: Use headers, lists, and formatting for easy reference
+
+## Example Structure
+
+```markdown
+# Project LLM Style Guide
+
+> Concise rules for AI agents working on [Project Name]. Based on [Language/Framework].
+
+## 1. Core Engineering Rules
+- [Specific rule based on this project]
+- [Another specific rule]
+
+## 2. Naming & Structure
+- Classes: [convention]
+- Files: [convention]
+- [etc.]
+
+[Continue with all sections...]
+```
+
+## Deliverable
+
+Create `docs/LLM_STYLE_GUIDE.md` with all the sections above, tailored specifically to this project's codebase, languages, and frameworks.