aidp 0.24.0 → 0.25.0

data/lib/aidp/providers/kilocode.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "base"
+require_relative "../util"
+require_relative "../debug_mixin"
+
+module Aidp
+  module Providers
+    class Kilocode < Base
+      include Aidp::DebugMixin
+
+      def self.available?
+        !!Aidp::Util.which("kilocode")
+      end
+
+      def name
+        "kilocode"
+      end
+
+      def display_name
+        "Kilocode"
+      end
+
+      def send_message(prompt:, session: nil)
+        raise "kilocode not available" unless self.class.available?
+
+        # Smart timeout calculation
+        timeout_seconds = calculate_timeout
+
+        debug_provider("kilocode", "Starting execution", {timeout: timeout_seconds})
+        debug_log("📝 Sending prompt to kilocode (length: #{prompt.length})", level: :info)
+
+        # Check if streaming mode is enabled
+        streaming_enabled = ENV["AIDP_STREAMING"] == "1" || ENV["DEBUG"] == "1"
+        if streaming_enabled
+          display_message("📺 Display streaming enabled - output buffering reduced", type: :info)
+        end
+
+        # Check if prompt is too large and warn
+        if prompt.length > 3000
+          debug_log("⚠️  Large prompt detected (#{prompt.length} chars) - this may cause rate limiting", level: :warn)
+        end
+
+        # Set up activity monitoring
+        setup_activity_monitoring("kilocode", method(:activity_callback))
+        record_activity("Starting kilocode execution")
+
+        # Create a spinner for activity display
+        spinner = TTY::Spinner.new("[:spinner] :title", format: :dots, hide_cursor: true)
+        spinner.auto_spin
+
+        activity_display_thread = Thread.new do
+          start_time = Time.now
+          loop do
+            sleep 0.5 # Update every 500ms to reduce spam
+            elapsed = Time.now - start_time
+
+            # Break if we've been running too long or state changed
+            break if elapsed > timeout_seconds || @activity_state == :completed || @activity_state == :failed
+
+            update_spinner_status(spinner, elapsed, "🔄 kilocode")
+          end
+        end
+
+        begin
+          # Build kilocode command arguments
+          args = ["--auto"]
+
+          # Add model if specified
+          model = ENV["KILOCODE_MODEL"]
+          if model
+            args.concat(["-m", model])
+          end
+
+          # Add workspace detection if needed
+          if Dir.exist?(".git") && ENV["KILOCODE_WORKSPACE"]
+            args.concat(["--workspace", ENV["KILOCODE_WORKSPACE"]])
+          end
+
+          # Set authentication via environment variable
+          env_vars = {}
+          if ENV["KILOCODE_TOKEN"]
+            env_vars["KILOCODE_TOKEN"] = ENV["KILOCODE_TOKEN"]
+          end
+
+          # Use debug_execute_command for better debugging
+          result = debug_execute_command("kilocode", args: args, input: prompt, timeout: timeout_seconds, streaming: streaming_enabled, env: env_vars)
+
+          # Log the results
+          debug_command("kilocode", args: args, input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
+
+          if result.exit_status == 0
+            spinner.success("✓")
+            mark_completed
+            result.out
+          else
+            spinner.error("✗")
+            mark_failed("kilocode failed with exit code #{result.exit_status}")
+            debug_error(StandardError.new("kilocode failed"), {exit_code: result.exit_status, stderr: result.err})
+            raise "kilocode failed with exit code #{result.exit_status}: #{result.err}"
+          end
+        rescue => e
+          spinner&.error("✗")
+          mark_failed("kilocode execution failed: #{e.message}")
+          debug_error(e, {provider: "kilocode", prompt_length: prompt.length})
+          raise
+        ensure
+          cleanup_activity_display(activity_display_thread, spinner)
+        end
+      end
+
+      private
+
+      def calculate_timeout
+        # Priority order for timeout calculation:
+        # 1. Quick mode (for testing)
+        # 2. Environment variable override
+        # 3. Adaptive timeout based on step type
+        # 4. Default timeout
+
+        if ENV["AIDP_QUICK_MODE"]
+          display_message("⚡ Quick mode enabled - #{TIMEOUT_QUICK_MODE / 60} minute timeout", type: :highlight)
+          return TIMEOUT_QUICK_MODE
+        end
+
+        if ENV["AIDP_KILOCODE_TIMEOUT"]
+          return ENV["AIDP_KILOCODE_TIMEOUT"].to_i
+        end
+
+        if adaptive_timeout
+          display_message("🧠 Using adaptive timeout: #{adaptive_timeout} seconds", type: :info)
+          return adaptive_timeout
+        end
+
+        # Default timeout
+        display_message("📋 Using default timeout: #{TIMEOUT_DEFAULT / 60} minutes", type: :info)
+        TIMEOUT_DEFAULT
+      end
+
+      def adaptive_timeout
+        @adaptive_timeout ||= begin
+          # Timeout recommendations based on step type patterns
+          step_name = ENV["AIDP_CURRENT_STEP"] || ""
+
+          case step_name
+          when /REPOSITORY_ANALYSIS/
+            TIMEOUT_REPOSITORY_ANALYSIS
+          when /ARCHITECTURE_ANALYSIS/
+            TIMEOUT_ARCHITECTURE_ANALYSIS
+          when /TEST_ANALYSIS/
+            TIMEOUT_TEST_ANALYSIS
+          when /FUNCTIONALITY_ANALYSIS/
+            TIMEOUT_FUNCTIONALITY_ANALYSIS
+          when /DOCUMENTATION_ANALYSIS/
+            TIMEOUT_DOCUMENTATION_ANALYSIS
+          when /STATIC_ANALYSIS/
+            TIMEOUT_STATIC_ANALYSIS
+          when /REFACTORING_RECOMMENDATIONS/
+            TIMEOUT_REFACTORING_RECOMMENDATIONS
+          else
+            nil # Use default
+          end
+        end
+      end
+
+      def activity_callback(state, message, provider)
+        # This is now handled by the animated display thread
+        # Only print static messages for state changes
+        case state
+        when :starting
+          display_message("🚀 Starting kilocode execution...", type: :info)
+        when :completed
+          display_message("✅ kilocode execution completed", type: :success)
+        when :failed
+          display_message("❌ kilocode execution failed: #{message}", type: :error)
+        end
+      end
+
+      def setup_activity_monitoring(provider_name, callback)
+        @activity_callback = callback
+        @activity_state = :starting
+        @activity_start_time = Time.now
+      end
+
+      def record_activity(message)
+        @activity_state = :running
+        @activity_callback&.call(:running, message, "kilocode")
+      end
+
+      def mark_completed
+        @activity_state = :completed
+        @activity_callback&.call(:completed, "Execution completed", "kilocode")
+      end
+
+      def mark_failed(reason)
+        @activity_state = :failed
+        @activity_callback&.call(:failed, reason, "kilocode")
+      end
+    end
+  end
+end

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/version.rb

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

data/lib/aidp/watch/build_processor.rb

@@ -355,7 +355,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 +382,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 +410,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 +453,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 +630,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 +650,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 +673,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 +749,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 +760,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