aidp 0.24.0 → 0.26.0

data/lib/aidp/safe_directory.rb

@@ -22,14 +22,21 @@ module Aidp
         path
       rescue SystemCallError => e
         fallback = determine_fallback_path(path)
-        Kernel.warn "[#{component_name}] Cannot create directory #{path}: #{e.class}: #{e.message}"
-        Kernel.warn "[#{component_name}] Using fallback directory: #{fallback}"
+
+        # Suppress permission warnings during tests to reduce noise
+        unless ENV["RSPEC_RUNNING"] == "true"
+          Kernel.warn "[#{component_name}] Cannot create directory #{path}: #{e.class}: #{e.message}"
+          Kernel.warn "[#{component_name}] Using fallback directory: #{fallback}"
+        end
 
         # Try to create fallback directory
         begin
           FileUtils.mkdir_p(fallback) unless Dir.exist?(fallback)
         rescue SystemCallError => e2
-          Kernel.warn "[#{component_name}] Fallback directory creation also failed: #{e2.class}: #{e2.message}"
+          # Suppress fallback errors during tests too
+          unless ENV["RSPEC_RUNNING"] == "true"
+            Kernel.warn "[#{component_name}] Fallback directory creation also failed: #{e2.class}: #{e2.message}"
+          end
         end
 
         fallback

data/lib/aidp/setup/provider_registry.rb

@@ -41,6 +41,21 @@ module Aidp
           value: "claude",
           description: "Balanced performance for general-purpose tasks"
         },
+        {
+          label: "Google Gemini (multimodal)",
+          value: "gemini",
+          description: "Google's multimodal AI with strong reasoning and vision capabilities"
+        },
+        {
+          label: "Meta Llama (open-source)",
+          value: "llama",
+          description: "Meta's open-source model family, suitable for self-hosting"
+        },
+        {
+          label: "DeepSeek (efficient reasoning)",
+          value: "deepseek",
+          description: "Cost-efficient reasoning models with strong performance"
+        },
         {
           label: "Mistral (European/open)",
           value: "mistral",

data/lib/aidp/setup/wizard.rb

@@ -1305,12 +1305,20 @@ module Aidp
       # Canonicalization helpers ------------------------------------------------
       def normalize_model_family(value)
         return "auto" if value.nil? || value.to_s.strip.empty?
-        # Already a canonical value
-        return value if ProviderRegistry.valid_model_family?(value)
-        # Try label -> value
+
+        normalized_input = value.to_s.strip.downcase
+
+        # Check for exact canonical value match (case-insensitive)
+        canonical_match = ProviderRegistry.model_family_values.find do |v|
+          v.downcase == normalized_input
+        end
+        return canonical_match if canonical_match
+
+        # Try label -> value mapping (case-insensitive)
         choices = ProviderRegistry.model_family_choices
-        mapped = choices.find { |label, _| label == value }&.last
+        mapped = choices.find { |label, _| label.downcase == value.to_s.downcase }&.last
         return mapped if mapped
+
         # Unknown legacy entry -> fallback to auto
         "auto"
       end

data/lib/aidp/skills/composer.rb

@@ -82,6 +82,8 @@ module Aidp
       def render_template(template, options: {})
         return template if options.empty?
 
+        # Ensure template is UTF-8 encoded
+        template = template.encode("UTF-8", invalid: :replace, undef: :replace) unless template.encoding == Encoding::UTF_8
         rendered = template.dup
 
         options.each do |key, value|
@@ -158,6 +160,8 @@ module Aidp
       def extract_placeholders(text)
         return [] if text.nil? || text.empty?
 
+        # Ensure text is UTF-8 encoded
+        text = text.encode("UTF-8", invalid: :replace, undef: :replace) unless text.encoding == Encoding::UTF_8
         scanner = StringScanner.new(text)
         placeholders = []
 

data/lib/aidp/skills/loader.rb

@@ -34,7 +34,7 @@ module Aidp
           raise Aidp::Errors::ValidationError, "Skill file not found: #{file_path}"
         end
 
-        content = File.read(file_path)
+        content = File.read(file_path, encoding: "UTF-8")
         load_from_string(content, source_path: file_path, provider: provider)
       end
 
@@ -139,6 +139,8 @@ module Aidp
       # @return [Array(Hash, String)] Tuple of [metadata, markdown_content]
       # @raise [Aidp::Errors::ValidationError] if frontmatter is missing or invalid
       def self.parse_frontmatter(content, source_path:)
+        # Ensure content is UTF-8 encoded
+        content = content.encode("UTF-8", invalid: :replace, undef: :replace) unless content.encoding == Encoding::UTF_8
         lines = content.lines
 
         unless lines.first&.strip == "---"

data/lib/aidp/storage/csv_storage.rb

@@ -205,12 +205,12 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}"
+          warn_storage("[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}")
           @base_dir = fallback
           begin
             FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
           rescue SystemCallError => e2
-            Kernel.warn "[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent CSV storage."
+            warn_storage("[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent CSV storage.")
           end
         end
       end
@@ -225,11 +225,17 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          warn_storage("[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'")
           return fallback
         end
         str
       end
+
+      # Suppress storage warnings in test/CI environments
+      def warn_storage(message)
+        return if ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+        Kernel.warn(message)
+      end
     end
   end
 end

data/lib/aidp/storage/file_manager.rb

@@ -16,7 +16,7 @@ module Aidp
         csv_dir = @csv_storage.instance_variable_get(:@base_dir)
         if json_dir != @base_dir || csv_dir != @base_dir
           @base_dir = json_dir # Prefer JSON storage directory
-          Kernel.warn "[AIDP Storage] Base directory normalized to #{@base_dir} after fallback."
+          warn_storage("[AIDP Storage] Base directory normalized to #{@base_dir} after fallback.")
         end
       end
 
@@ -229,11 +229,17 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          warn_storage("[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'")
           return fallback
         end
         str
       end
+
+      # Suppress storage warnings in test/CI environments
+      def warn_storage(message)
+        return if ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+        Kernel.warn(message)
+      end
     end
   end
 end

data/lib/aidp/storage/json_storage.rb

@@ -171,12 +171,12 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}"
+          warn_storage("[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}")
           @base_dir = fallback
           begin
             FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
           rescue SystemCallError => e2
-            Kernel.warn "[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent JSON storage."
+            warn_storage("[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent JSON storage.")
           end
         end
       end
@@ -192,11 +192,17 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          warn_storage("[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'")
           return fallback
         end
         str
       end
+
+      # Suppress storage warnings in test/CI environments
+      def warn_storage(message)
+        return if ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+        Kernel.warn(message)
+      end
     end
   end
 end

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.24.0"
+  VERSION = "0.26.0"
 end

data/lib/aidp/watch/build_processor.rb

@@ -228,12 +228,51 @@ module Aidp
         relevant.map do |comment|
           author = comment["author"] || "unknown"
           created = comment["createdAt"] ? Time.parse(comment["createdAt"]).utc.iso8601 : "unknown"
-          "### #{author} (#{created})\n#{comment["body"]}"
+          body = strip_archived_plans(comment["body"])
+          "### #{author} (#{created})\n#{body}"
         end.join("\n\n")
       rescue
         "_Unable to parse comment thread._"
       end
 
+      def strip_archived_plans(content)
+        return content unless content
+
+        # Remove all archived plan sections (wrapped in HTML comments)
+        result = content.dup
+
+        # Remove archived plan blocks
+        # Safe string-based approach to avoid ReDoS vulnerabilities
+        start_prefix = "<!-- ARCHIVED_PLAN_START"
+        end_marker = "<!-- ARCHIVED_PLAN_END -->"
+
+        loop do
+          # Find the start of an archived plan block (may have attributes after ARCHIVED_PLAN_START)
+          start_idx = result.index(start_prefix)
+          break unless start_idx
+
+          # Find the closing --> of the start marker
+          start_marker_end = result.index("-->", start_idx)
+          break unless start_marker_end
+
+          # Find the corresponding end marker
+          end_idx = result.index(end_marker, start_marker_end)
+          break unless end_idx
+
+          # Remove the entire block including markers
+          result = result[0...start_idx] + result[(end_idx + end_marker.length)..]
+        end
+
+        # Remove HTML-commented sections from active plan
+        # Keep the content between START and END markers, but strip the markers themselves
+        # This preserves the current plan while removing archived content
+        result = result.gsub(/<!-- (PLAN_SUMMARY_START|PLAN_TASKS_START|CLARIFYING_QUESTIONS_START) -->/, "")
+        result = result.gsub(/<!-- (PLAN_SUMMARY_END|PLAN_TASKS_END|CLARIFYING_QUESTIONS_END) -->/, "")
+
+        # Clean up any extra blank lines
+        result.gsub(/\n{3,}/, "\n\n").strip
+      end
+
       def write_prompt(content, working_dir: @project_dir)
         prompt_manager = Aidp::Execute::PromptManager.new(working_dir)
         prompt_manager.write(content, step_name: IMPLEMENTATION_STEP)
@@ -355,7 +394,7 @@ module Aidp
         FileUtils.mkdir_p(File.dirname(target_config))
 
         # Only copy when target missing or differs
-        if !File.exist?(target_config) || File.read(source_config) != File.read(target_config)
+        if !File.exist?(target_config) || File.read(source_config, encoding: "UTF-8") != File.read(target_config, encoding: "UTF-8")
           FileUtils.cp(source_config, target_config)
         end
       rescue => e
@@ -382,8 +421,8 @@ module Aidp
 
         # Check if PR should be created based on VCS preferences
         # For watch mode, default to creating PRs (set to false to disable)
-        vcs_config = config.dig(:work_loop, :version_control) || {}
-        auto_create_pr = vcs_config.fetch(:auto_create_pr, true)
+        vcs_config = config_dig(:work_loop, :version_control) || {}
+        auto_create_pr = config_value(vcs_config, :auto_create_pr, true)
 
         pr_url = if !changes_committed
           Aidp.log_info(
@@ -410,12 +449,17 @@ module Aidp
           nil
         end
 
+        # Fetch the user who added the most recent label
+        label_actor = @repository_client.most_recent_label_actor(issue[:number])
+
         workstream_note = @use_workstreams ? "\n- Workstream: `#{slug}`" : ""
         pr_line = pr_url ? "\n- Pull Request: #{pr_url}" : ""
+        actor_tag = label_actor ? "cc @#{label_actor}\n\n" : ""
 
         comment = <<~COMMENT
           ✅ Implementation complete for ##{issue[:number]}.
-          - Branch: `#{branch_name}`#{workstream_note}#{pr_line}
+
+          #{actor_tag}- Branch: `#{branch_name}`#{workstream_note}#{pr_line}
 
           Summary:
           #{plan_value(plan_data, "summary")}
@@ -448,10 +492,20 @@ module Aidp
         questions = result[:clarification_questions] || []
         workstream_note = @use_workstreams ? " The workstream `#{slug}` has been preserved." : " The branch has been preserved."
 
+        # Fetch the user who added the most recent label
+        label_actor = @repository_client.most_recent_label_actor(issue[:number])
+
         # Build comment with questions
         comment_parts = []
         comment_parts << "❓ Implementation needs clarification for ##{issue[:number]}."
         comment_parts << ""
+
+        # Tag the label actor if available
+        if label_actor
+          comment_parts << "cc @#{label_actor}"
+          comment_parts << ""
+        end
+
         comment_parts << "The AI agent needs additional information to proceed with implementation:"
         comment_parts << ""
         questions.each_with_index do |question, index|
@@ -615,15 +669,15 @@ module Aidp
       end
 
       def build_commit_message(issue)
-        vcs_config = config.dig(:work_loop, :version_control) || {}
+        vcs_config = config_dig(:work_loop, :version_control) || {}
 
         # Base message components
         issue_ref = "##{issue[:number]}"
         title = issue[:title]
 
         # Determine commit prefix based on configuration
-        prefix = if vcs_config[:conventional_commits]
-          commit_style = vcs_config[:commit_style] || "default"
+        prefix = if config_value(vcs_config, :conventional_commits)
+          commit_style = config_value(vcs_config, :commit_style, "default")
           emoji = (commit_style == "emoji") ? "✨ " : ""
           scope = (commit_style == "angular") ? "(implementation)" : ""
           "#{emoji}feat#{scope}: "
@@ -635,7 +689,7 @@ module Aidp
         main_message = "#{prefix}implement #{issue_ref} #{title}"
 
         # Add co-author attribution if configured
-        if vcs_config.fetch(:co_author_ai, true)
+        if config_value(vcs_config, :co_author_ai, true)
           provider_name = detect_current_provider || "AI Agent"
           co_author = "\n\nCo-authored-by: #{provider_name} <ai@aidp.dev>"
           main_message + co_author
@@ -658,30 +712,64 @@ module Aidp
         @config ||= begin
           config_manager = Aidp::Harness::ConfigManager.new(@project_dir)
           config_manager.config || {}
-        rescue
+        rescue => e
+          Aidp.log_error("build_processor", "config_load_exception", project_dir: @project_dir, error: e.message, backtrace: e.backtrace&.first(5))
           {}
         end
       end
 
+      # Helper to safely dig into config with both string and symbol keys
+      def config_dig(*keys)
+        value = config
+        keys.each do |key|
+          return nil unless value.is_a?(Hash)
+          # Try both symbol and string versions of the key
+          value = value[key] || value[key.to_s] || value[key.to_sym]
+          return nil if value.nil?
+        end
+        value
+      end
+
+      # Helper to get config value with both string and symbol key support
+      def config_value(hash, key, default = nil)
+        return default unless hash.is_a?(Hash)
+        # Check each key variation explicitly to handle false/nil values correctly
+        return hash[key] if hash.key?(key)
+        return hash[key.to_s] if hash.key?(key.to_s)
+        return hash[key.to_sym] if hash.key?(key.to_sym)
+        default
+      end
+
       def create_pull_request(issue:, branch_name:, base_branch:, working_dir: @project_dir)
         title = "aidp: Resolve ##{issue[:number]} - #{issue[:title]}"
         test_summary = gather_test_summary(working_dir: working_dir)
         body = <<~BODY
+          Fixes ##{issue[:number]}
+
           ## Summary
           - Automated resolution for ##{issue[:number]}
-          - Fixes ##{issue[:number]}
 
           ## Testing
           #{test_summary}
         BODY
 
         # Determine if PR should be draft based on VCS preferences
-        vcs_config = config.dig(:work_loop, :version_control) || {}
-        pr_strategy = vcs_config[:pr_strategy] || "draft"
+        vcs_config = config_dig(:work_loop, :version_control) || {}
+        pr_strategy = config_value(vcs_config, :pr_strategy, "draft")
         draft = (pr_strategy == "draft")
 
-        # Assign PR to the issue author
-        assignee = issue[:author]
+        # Fetch the user who added the most recent label to assign the PR
+        label_actor = @repository_client.most_recent_label_actor(issue[:number])
+        assignee = label_actor || issue[:author]
+
+        Aidp.log_info(
+          "build_processor",
+          "assigning_pr",
+          issue: issue[:number],
+          assignee: assignee,
+          label_actor: label_actor,
+          fallback_to_author: label_actor.nil?
+        )
 
         output = @repository_client.create_pull_request(
           title: title,
@@ -700,7 +788,8 @@ module Aidp
           issue: issue[:number],
           branch: branch_name,
           base_branch: base_branch,
-          pr_url: pr_url
+          pr_url: pr_url,
+          assignee: assignee
         )
         pr_url
       end
@@ -710,7 +799,7 @@ module Aidp
           log_path = File.join(".aidp", "logs", "test_runner.log")
           return "- Fix-forward harness executed; refer to #{log_path}" unless File.exist?(log_path)
 
-          recent = File.readlines(log_path).last(20).map(&:strip).reject(&:empty?)
+          recent = File.readlines(log_path, encoding: "UTF-8").last(20).map(&:strip).reject(&:empty?)
           if recent.empty?
             "- Fix-forward harness executed successfully."
           else