aidp 0.27.0 → 0.28.0

data/lib/aidp/planning/mappers/persona_mapper.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "../../logger"
+require "yaml"
+
+module Aidp
+  module Planning
+    module Mappers
+      # Maps tasks to personas using Zero Framework Cognition (ZFC)
+      # NO heuristics, NO regex, NO keyword matching - pure AI decision making
+      class PersonaMapper
+        def initialize(ai_decision_engine:, config: nil, mode: :waterfall)
+          @ai_decision_engine = ai_decision_engine
+          @config = config
+          @mode = mode
+        end
+
+        # Assign personas to tasks using ZFC
+        # @param task_list [Array<Hash>] List of tasks to assign
+        # @param available_personas [Array<String>] Available persona names
+        # @return [Hash] Persona assignments
+        def assign_personas(task_list, available_personas: nil)
+          Aidp.log_debug("persona_mapper", "assign_personas", task_count: task_list.size)
+
+          available_personas ||= default_personas
+
+          assignments = {}
+
+          task_list.each do |task|
+            persona = assign_task_to_persona(task, available_personas)
+            assignments[task[:id] || task[:name]] = {
+              persona: persona,
+              task: task[:name],
+              phase: task[:phase],
+              rationale: "AI-determined based on task characteristics"
+            }
+
+            Aidp.log_debug("persona_mapper", "assigned", task: task[:name], persona: persona)
+          end
+
+          {
+            assignments: assignments,
+            metadata: {
+              generated_at: Time.now.iso8601,
+              total_assignments: assignments.size,
+              personas_used: assignments.values.map { |a| a[:persona] }.uniq
+            }
+          }
+        end
+
+        # Generate persona_map.yml configuration
+        # @param assignments [Hash] Persona assignments
+        # @return [String] YAML configuration
+        def generate_persona_map(assignments)
+          Aidp.log_debug("persona_mapper", "generate_persona_map")
+
+          config = {
+            "version" => "1.0",
+            "generated_at" => Time.now.iso8601,
+            "assignments" => format_assignments_for_yaml(assignments[:assignments])
+          }
+
+          YAML.dump(config)
+        end
+
+        private
+
+        # Assign a single task to the best persona using AI decision engine
+        # This is the ZFC pattern - meaning/decisions go to AI, not code
+        def assign_task_to_persona(task, available_personas)
+          Aidp.log_debug("persona_mapper", "assign_task", task: task[:name])
+
+          # Use AI decision engine to determine best persona
+          # NO regex, NO keyword matching, NO heuristics!
+          decision = @ai_decision_engine.decide(
+            context: "persona assignment",
+            prompt: build_assignment_prompt(task, available_personas),
+            data: {
+              task_name: task[:name],
+              task_description: task[:description],
+              task_phase: task[:phase],
+              task_effort: task[:effort],
+              available_personas: available_personas
+            },
+            schema: {
+              type: "string",
+              enum: available_personas
+            }
+          )
+
+          Aidp.log_debug("persona_mapper", "ai_decision", persona: decision)
+          decision
+        end
+
+        def build_assignment_prompt(task, personas)
+          <<~PROMPT
+            Assign this task to the most appropriate persona based on the task characteristics.
+
+            Task: #{task[:name]}
+            Description: #{task[:description]}
+            Phase: #{task[:phase]}
+            Effort: #{task[:effort]}
+
+            Available Personas: #{personas.join(", ")}
+
+            Consider:
+            - Task type and complexity
+            - Required skills and expertise
+            - Phase of project (requirements, design, implementation, etc.)
+            - Technical vs. product focus
+
+            Return ONLY the persona name, nothing else.
+          PROMPT
+        end
+
+        def default_personas
+          case @mode
+          when :agile
+            agile_personas
+          when :waterfall
+            waterfall_personas
+          else
+            waterfall_personas # Default to waterfall
+          end
+        end
+
+        def waterfall_personas
+          [
+            "product_strategist",
+            "architect",
+            "senior_developer",
+            "qa_engineer",
+            "devops_engineer",
+            "tech_writer"
+          ]
+        end
+
+        def agile_personas
+          [
+            "product_manager",
+            "ux_researcher",
+            "architect",
+            "senior_developer",
+            "qa_engineer",
+            "devops_engineer",
+            "tech_writer",
+            "marketing_strategist"
+          ]
+        end
+
+        def format_assignments_for_yaml(assignments)
+          assignments.transform_values do |assignment|
+            {
+              "persona" => assignment[:persona],
+              "task" => assignment[:task],
+              "phase" => assignment[:phase]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/planning/parsers/document_parser.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../../logger"
+
+module Aidp
+  module Planning
+    module Parsers
+      # Parses existing documentation files to extract structured information
+      # Uses Zero Framework Cognition (ZFC) for semantic analysis
+      class DocumentParser
+        def initialize(ai_decision_engine: nil)
+          @ai_decision_engine = ai_decision_engine
+        end
+
+        # Parse a single file and detect its structure
+        # @param file_path [String] Path to the markdown file
+        # @return [Hash] Parsed document with type and sections
+        def parse_file(file_path)
+          Aidp.log_debug("document_parser", "parse_file", path: file_path)
+
+          unless File.exist?(file_path)
+            Aidp.log_error("document_parser", "file_not_found", path: file_path)
+            raise ArgumentError, "File not found: #{file_path}"
+          end
+
+          content = File.read(file_path)
+          Aidp.log_debug("document_parser", "read_content", size: content.length)
+
+          {
+            path: file_path,
+            type: detect_document_type(content),
+            sections: extract_sections(content),
+            raw_content: content
+          }
+        end
+
+        # Parse all markdown files in a directory
+        # @param dir_path [String] Directory path
+        # @return [Array<Hash>] Array of parsed documents
+        def parse_directory(dir_path)
+          Aidp.log_debug("document_parser", "parse_directory", path: dir_path)
+
+          unless Dir.exist?(dir_path)
+            Aidp.log_error("document_parser", "directory_not_found", path: dir_path)
+            raise ArgumentError, "Directory not found: #{dir_path}"
+          end
+
+          markdown_files = Dir.glob(File.join(dir_path, "**", "*.md"))
+          Aidp.log_debug("document_parser", "found_files", count: markdown_files.size)
+
+          markdown_files.map { |file| parse_file(file) }
+        end
+
+        private
+
+        # Detect document type using ZFC (AI decision engine)
+        # Returns :prd, :design, :adr, :task_list, or :unknown
+        def detect_document_type(content)
+          Aidp.log_debug("document_parser", "detect_document_type")
+
+          # Use AI decision engine if available (ZFC pattern)
+          if @ai_decision_engine
+            decision = @ai_decision_engine.decide(
+              context: "document classification",
+              prompt: "Classify this document as PRD, technical design, ADR, task list, or unknown",
+              data: {content: content.slice(0, 2000)}, # First 2000 chars
+              schema: {
+                type: "string",
+                enum: ["prd", "design", "adr", "task_list", "unknown"]
+              }
+            )
+            Aidp.log_debug("document_parser", "ai_classification", type: decision)
+            return decision.to_sym
+          end
+
+          # Fallback: simple heuristics when AI not available
+          # This is acceptable as fallback, but ZFC is preferred
+          type = classify_by_heuristics(content)
+          Aidp.log_debug("document_parser", "heuristic_classification", type: type)
+          type
+        end
+
+        # Fallback classification using basic heuristics
+        def classify_by_heuristics(content)
+          lower_content = content.downcase
+
+          return :prd if lower_content.include?("product requirements") ||
+            lower_content.include?("user stories") ||
+            lower_content.include?("success criteria")
+
+          return :design if lower_content.include?("technical design") ||
+            lower_content.include?("system architecture") ||
+            lower_content.include?("component design")
+
+          return :adr if lower_content.include?("decision record") ||
+            lower_content.include?("adr") ||
+            lower_content.match?(/##?\s+status/i)
+
+          return :task_list if lower_content.include?("task list") ||
+            lower_content.include?("- [ ]") ||
+            lower_content.match?(/\d+\.\s+\[[ x]\]/i)
+
+          :unknown
+        end
+
+        # Extract markdown sections from content
+        # Returns hash of section_name => section_content
+        def extract_sections(content)
+          Aidp.log_debug("document_parser", "extract_sections")
+
+          sections = {}
+          current_section = nil
+          current_content = []
+
+          content.each_line do |line|
+            if line.match?(/^##?\s+(.+)/)
+              # Save previous section
+              if current_section
+                sections[current_section] = current_content.join.strip
+              end
+
+              # Start new section
+              current_section = line.match(/^##?\s+(.+)/)[1].strip.downcase.gsub(/\s+/, "_")
+              current_content = []
+            elsif current_section
+              current_content << line
+            end
+          end
+
+          # Save last section
+          if current_section
+            sections[current_section] = current_content.join.strip
+          end
+
+          Aidp.log_debug("document_parser", "extracted_sections", count: sections.size)
+          sections
+        end
+      end
+    end
+  end
+end

data/lib/aidp/planning/parsers/feedback_data_parser.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require "csv"
+require "json"
+require_relative "../../logger"
+
+module Aidp
+  module Planning
+    module Parsers
+      # Parse feedback data from multiple formats (CSV, JSON, markdown)
+      # Normalizes data into consistent structure for analysis
+      class FeedbackDataParser
+        class FeedbackParseError < StandardError; end
+
+        def initialize(file_path:)
+          @file_path = file_path
+          @format = detect_format
+        end
+
+        # Parse feedback file and return normalized structure
+        # @return [Hash] Normalized feedback data
+        def parse
+          Aidp.log_debug("feedback_data_parser", "parsing", file: @file_path, format: @format)
+
+          case @format
+          when :csv
+            parse_csv
+          when :json
+            parse_json
+          when :markdown
+            parse_markdown
+          else
+            raise FeedbackParseError, "Unsupported format: #{@format}"
+          end
+        rescue => e
+          Aidp.log_error("feedback_data_parser", "parse_failed", error: e.message, file: @file_path)
+          raise FeedbackParseError, "Failed to parse feedback file: #{e.message}"
+        end
+
+        private
+
+        def detect_format
+          ext = File.extname(@file_path).downcase
+
+          case ext
+          when ".csv"
+            :csv
+          when ".json"
+            :json
+          when ".md", ".markdown"
+            :markdown
+          else
+            raise FeedbackParseError, "Unknown file extension: #{ext}"
+          end
+        end
+
+        def parse_csv
+          Aidp.log_debug("feedback_data_parser", "parsing_csv")
+
+          unless File.exist?(@file_path)
+            raise FeedbackParseError, "File not found: #{@file_path}"
+          end
+
+          rows = CSV.read(@file_path, headers: true)
+          responses = rows.map { |row| normalize_csv_row(row) }
+
+          {
+            format: :csv,
+            source_file: @file_path,
+            parsed_at: Time.now.iso8601,
+            response_count: responses.size,
+            responses: responses,
+            metadata: extract_csv_metadata(rows)
+          }
+        end
+
+        def parse_json
+          Aidp.log_debug("feedback_data_parser", "parsing_json")
+
+          unless File.exist?(@file_path)
+            raise FeedbackParseError, "File not found: #{@file_path}"
+          end
+
+          data = JSON.parse(File.read(@file_path))
+
+          # Support both array of responses and object with responses key
+          responses = if data.is_a?(Array)
+            data
+          elsif data.is_a?(Hash) && data["responses"]
+            data["responses"]
+          else
+            raise FeedbackParseError, "Invalid JSON structure: expected array or {responses: [...]}"
+          end
+
+          normalized_responses = responses.map { |r| normalize_json_response(r) }
+
+          {
+            format: :json,
+            source_file: @file_path,
+            parsed_at: Time.now.iso8601,
+            response_count: normalized_responses.size,
+            responses: normalized_responses,
+            metadata: extract_json_metadata(data)
+          }
+        end
+
+        def parse_markdown
+          Aidp.log_debug("feedback_data_parser", "parsing_markdown")
+
+          unless File.exist?(@file_path)
+            raise FeedbackParseError, "File not found: #{@file_path}"
+          end
+
+          content = File.read(@file_path)
+          responses = extract_markdown_responses(content)
+
+          {
+            format: :markdown,
+            source_file: @file_path,
+            parsed_at: Time.now.iso8601,
+            response_count: responses.size,
+            responses: responses,
+            metadata: extract_markdown_metadata(content)
+          }
+        end
+
+        def normalize_csv_row(row)
+          {
+            respondent_id: row["id"] || row["respondent_id"] || row["user_id"],
+            timestamp: row["timestamp"] || row["date"] || row["submitted_at"],
+            rating: parse_rating(row["rating"] || row["score"]),
+            feedback_text: row["feedback"] || row["comments"] || row["response"],
+            feature: row["feature"] || row["area"],
+            sentiment: row["sentiment"],
+            tags: parse_tags(row["tags"]),
+            raw_data: row.to_h
+          }
+        end
+
+        def normalize_json_response(response)
+          {
+            respondent_id: response["id"] || response["respondent_id"] || response["user_id"],
+            timestamp: response["timestamp"] || response["date"] || response["submitted_at"],
+            rating: parse_rating(response["rating"] || response["score"]),
+            feedback_text: response["feedback"] || response["comments"] || response["response"] || response["text"],
+            feature: response["feature"] || response["area"] || response["category"],
+            sentiment: response["sentiment"],
+            tags: parse_tags(response["tags"]),
+            raw_data: response
+          }
+        end
+
+        def extract_markdown_responses(content)
+          # Simple markdown parser that looks for response sections
+          # Format: ## Response N or ### Respondent: ID
+          responses = []
+          current_response = nil
+
+          content.each_line do |line|
+            if line =~ /^##+ Response (\d+)/i || line =~ /^##+ Respondent:?\s*(.+)/i
+              responses << current_response if current_response
+              current_response = {text: "", metadata: {}}
+            elsif current_response
+              # Extract key-value pairs like **Rating:** 5
+              if line =~ /\*\*(.+?):\*\*\s*(.+)/
+                key = $1.downcase.strip
+                value = $2.strip
+                current_response[:metadata][key] = value
+              else
+                current_response[:text] += line
+              end
+            end
+          end
+
+          responses << current_response if current_response
+
+          responses.map do |resp|
+            {
+              respondent_id: resp[:metadata]["id"] || resp[:metadata]["respondent"],
+              timestamp: resp[:metadata]["timestamp"] || resp[:metadata]["date"],
+              rating: parse_rating(resp[:metadata]["rating"] || resp[:metadata]["score"]),
+              feedback_text: resp[:text].strip,
+              feature: resp[:metadata]["feature"] || resp[:metadata]["area"],
+              sentiment: resp[:metadata]["sentiment"],
+              tags: parse_tags(resp[:metadata]["tags"]),
+              raw_data: resp[:metadata]
+            }
+          end
+        end
+
+        def parse_rating(value)
+          return nil if value.nil? || value.to_s.strip.empty?
+
+          # Handle numeric ratings, star ratings, etc.
+          if value.to_s =~ /^(\d+)(?:\/\d+)?$/
+            $1.to_i
+          elsif value.to_s =~ /^(\d+)\s*stars?$/i
+            $1.to_i
+          else
+            value.to_s
+          end
+        end
+
+        def parse_tags(value)
+          return [] if value.nil? || value.to_s.strip.empty?
+
+          if value.is_a?(Array)
+            value
+          elsif value.is_a?(String)
+            value.split(/[,;]/).map(&:strip).reject(&:empty?)
+          else
+            []
+          end
+        end
+
+        def extract_csv_metadata(rows)
+          {
+            total_rows: rows.size,
+            columns: rows.headers,
+            has_timestamps: rows.headers.any? { |h| h&.match?(/timestamp|date/i) },
+            has_ratings: rows.headers.any? { |h| h&.match?(/rating|score/i) }
+          }
+        end
+
+        def extract_json_metadata(data)
+          metadata = data.is_a?(Hash) ? data.except("responses") : {}
+
+          {
+            survey_name: metadata["survey_name"] || metadata["name"],
+            survey_id: metadata["survey_id"] || metadata["id"],
+            created_at: metadata["created_at"] || metadata["timestamp"],
+            additional_fields: metadata.keys - ["responses", "survey_name", "name", "id", "survey_id", "created_at", "timestamp"]
+          }
+        end
+
+        def extract_markdown_metadata(content)
+          # Extract YAML front matter if present
+          if content =~ /^---\s*\n(.*?)\n---\s*\n/m
+            begin
+              YAML.safe_load($1, permitted_classes: [Date, Time, Symbol]) || {}
+            rescue => e
+              Aidp.log_debug("feedback_data_parser", "yaml_parse_failed", error: e.message)
+              {}
+            end
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/provider_manager.rb

@@ -7,15 +7,10 @@ module Aidp
   class ProviderManager
     class << self
       def get_provider(provider_type, options = {})
-        # Use harness factory if available
-        if options[:use_harness] != false
-          factory = get_harness_factory
-          return factory.create_provider(provider_type, options) if factory
-        end
+        factory = get_harness_factory
+        raise "Harness factory not available" unless factory
 
-        # Fallback to legacy method
-        prompt = options[:prompt] || TTY::Prompt.new
-        create_legacy_provider(provider_type, prompt: prompt)
+        factory.create_provider(provider_type, options)
       end
 
       def load_from_config(config = {}, options = {})
@@ -62,7 +57,7 @@ module Aidp
         factory = get_harness_factory
         return [] unless factory
 
-        enabled_names = factory.get_enabled_providers(options)
+        enabled_names = factory.enabled_providers(options)
         factory.create_providers(enabled_names, options)
       end
 
@@ -71,7 +66,7 @@ module Aidp
         factory = get_harness_factory
         return false unless factory
 
-        factory.get_configured_providers(options).include?(provider_name.to_s)
+        factory.configured_providers(options).include?(provider_name.to_s)
       end
 
       # Check if provider is enabled
@@ -79,7 +74,7 @@ module Aidp
         factory = get_harness_factory
         return false unless factory
 
-        factory.get_enabled_providers(options).include?(provider_name.to_s)
+        factory.enabled_providers(options).include?(provider_name.to_s)
       end
 
       # Get provider capabilities
@@ -87,7 +82,7 @@ module Aidp
         factory = get_harness_factory
         return [] unless factory
 
-        factory.get_provider_capabilities(provider_name, options)
+        factory.provider_capabilities(provider_name, options)
       end
 
       # Check if provider supports feature
@@ -103,7 +98,7 @@ module Aidp
         factory = get_harness_factory
         return [] unless factory
 
-        factory.get_provider_models(provider_name, options)
+        factory.provider_models(provider_name, options)
       end
 
       # Validate provider configuration
@@ -131,25 +126,6 @@ module Aidp
       def reload_config
         @harness_factory&.reload_config
       end
-
-      private
-
-      def create_legacy_provider(provider_type, prompt: TTY::Prompt.new)
-        case provider_type
-        when "cursor"
-          Aidp::Providers::Cursor.new(prompt: prompt)
-        when "anthropic", "claude"
-          Aidp::Providers::Anthropic.new(prompt: prompt)
-        when "gemini"
-          Aidp::Providers::Gemini.new(prompt: prompt)
-        when "kilocode"
-          Aidp::Providers::Kilocode.new(prompt: prompt)
-        when "github_copilot"
-          Aidp::Providers::GithubCopilot.new(prompt: prompt)
-        when "codex"
-          Aidp::Providers::Codex.new(prompt: prompt)
-        end
-      end
     end
   end
 end