aidp 0.15.2 → 0.16.0

data/lib/aidp/harness/user_interface.rb

@@ -2056,14 +2056,13 @@ module Aidp
         return unless @control_interface_enabled
 
         @control_mutex.synchronize do
-          return if @control_thread&.alive?
+          return if @control_future&.pending?
 
-          # Start control interface using Async (skip in test mode)
+          # Start control interface using concurrent-ruby (skip in test mode)
+          # Using Concurrent::Future for background execution with proper thread pool management
           unless ENV["RACK_ENV"] == "test" || defined?(RSpec)
-            require "async"
-            Async do |task|
-              task.async { control_interface_loop }
-            end
+            require "concurrent"
+            @control_future = Concurrent::Future.execute { control_interface_loop }
           end
         end
 
@@ -2079,9 +2078,9 @@ module Aidp
       # Stop the control interface
       def stop_control_interface
         @control_mutex.synchronize do
-          if @control_thread&.alive?
-            @control_thread.kill
-            @control_thread = nil
+          if @control_future
+            @control_future.cancel
+            @control_future = nil
           end
         end
 
@@ -2153,10 +2152,9 @@ module Aidp
           elsif resume_requested?
             handle_resume_state
             break
-          elsif ENV["RACK_ENV"] == "test" || defined?(RSpec)
-            sleep(0.1)
           else
-            Async::Task.current.sleep(0.1)
+            # Periodic check for user input/state changes
+            sleep(0.1)
           end
         end
       end
@@ -2400,10 +2398,9 @@ module Aidp
           elsif Time.now - start_time > timeout_seconds
             display_message("\n⏰ Control interface timeout reached. Continuing execution...", type: :warning)
             break
-          elsif ENV["RACK_ENV"] == "test" || defined?(RSpec)
-            sleep(0.1)
           else
-            Async::Task.current.sleep(0.1)
+            # Periodic check for user confirmation
+            sleep(0.1)
           end
         end
       end

data/lib/aidp/jobs/background_runner.rb

@@ -3,7 +3,9 @@
 require "securerandom"
 require "yaml"
 require "fileutils"
+require "time"
 require_relative "../rescue_logging"
+require_relative "../concurrency"
 
 module Aidp
   module Jobs
@@ -69,7 +71,14 @@ module Aidp
 
         # Wait for child to fork
         Process.detach(pid)
-        sleep 0.1 # Give daemon time to write PID file
+
+        # Wait for daemon to write PID file (with timeout)
+        begin
+          Aidp::Concurrency::Wait.for_file(pid_file, timeout: 5, interval: 0.05)
+        rescue Aidp::Concurrency::TimeoutError
+          # PID file not created - daemon may have failed to start
+          # Continue anyway, metadata will reflect this
+        end
 
         # Save job metadata in parent process
         save_job_metadata(job_id, pid, mode, options)
@@ -191,7 +200,7 @@ module Aidp
           job_id: job_id,
           pid: pid,
           mode: mode,
-          started_at: Time.now,
+          started_at: Time.now.iso8601,
           status: "running",
           options: options.except(:prompt) # Don't save prompt object
         }
@@ -203,6 +212,7 @@ module Aidp
         metadata_file = File.join(@jobs_dir, job_id, "metadata.yml")
         return nil unless File.exist?(metadata_file)
 
+        # Return raw metadata with times as ISO8601 strings to avoid unsafe class loading
         YAML.load_file(metadata_file)
       rescue
         nil
@@ -220,7 +230,7 @@ module Aidp
       def mark_job_completed(job_id, result)
         update_job_metadata(job_id, {
           status: "completed",
-          completed_at: Time.now,
+          completed_at: Time.now.iso8601,
           result: result
         })
       end
@@ -228,7 +238,7 @@ module Aidp
       def mark_job_failed(job_id, error)
         update_job_metadata(job_id, {
           status: "failed",
-          completed_at: Time.now,
+          completed_at: Time.now.iso8601,
           error: {
             message: error.message,
             class: error.class.name,
@@ -240,7 +250,7 @@ module Aidp
       def mark_job_stopped(job_id)
         update_job_metadata(job_id, {
           status: "stopped",
-          completed_at: Time.now
+          completed_at: Time.now.iso8601
         })
       end
 

data/lib/aidp/providers/codex.rb

@@ -57,7 +57,6 @@ module Aidp
         spinner = TTY::Spinner.new("[:spinner] :title", format: :dots, hide_cursor: true)
         spinner.auto_spin
 
-        # Start activity display thread with timeout
         activity_display_thread = Thread.new do
           start_time = Time.now
           loop do

data/lib/aidp/providers/cursor.rb

@@ -54,7 +54,6 @@ module Aidp
         spinner = TTY::Spinner.new("[:spinner] :title", format: :dots, hide_cursor: true)
         spinner.auto_spin
 
-        # Start activity display thread with timeout
         activity_display_thread = Thread.new do
           start_time = Time.now
           loop do

data/lib/aidp/providers/github_copilot.rb

@@ -57,7 +57,6 @@ module Aidp
         spinner = TTY::Spinner.new("[:spinner] :title", format: :dots, hide_cursor: true)
         spinner.auto_spin
 
-        # Start activity display thread with timeout
         activity_display_thread = Thread.new do
           start_time = Time.now
           loop do

data/lib/aidp/providers/opencode.rb

@@ -50,7 +50,6 @@ module Aidp
         spinner = TTY::Spinner.new("[:spinner] :title", format: :dots, hide_cursor: true)
         spinner.auto_spin
 
-        # Start activity display thread with timeout
         activity_display_thread = Thread.new do
           start_time = Time.now
           loop do

data/lib/aidp/skills/composer.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Aidp
+  module Skills
+    # Composes skills with templates to create complete prompts
+    #
+    # The Composer combines skill content (WHO the agent is and WHAT capabilities
+    # they have) with template content (WHEN/HOW to execute a specific task).
+    #
+    # Composition structure:
+    #   1. Skill content (persona, expertise, philosophy)
+    #   2. Separator
+    #   3. Template content (task-specific instructions)
+    #
+    # @example Basic composition
+    #   composer = Composer.new
+    #   prompt = composer.compose(
+    #     skill: repository_analyst_skill,
+    #     template: "Analyze the repository..."
+    #   )
+    #
+    # @example Template-only (no skill)
+    #   prompt = composer.compose(template: "Do this task...")
+    class Composer
+      # Separator between skill and template content
+      SKILL_TEMPLATE_SEPARATOR = "\n\n---\n\n"
+
+      # Compose a skill and template into a complete prompt
+      #
+      # @param skill [Skill, nil] Skill to include (optional)
+      # @param template [String] Template content
+      # @param options [Hash] Optional parameters for template variable replacement
+      # @return [String] Composed prompt
+      def compose(template:, skill: nil, options: {})
+        Aidp.log_debug(
+          "skills",
+          "Composing prompt",
+          skill_id: skill&.id,
+          template_length: template.length,
+          options_count: options.size
+        )
+
+        # Replace template variables
+        rendered_template = render_template(template, options: options)
+
+        # If no skill, return template only
+        unless skill
+          Aidp.log_debug("skills", "Template-only composition", template_length: rendered_template.length)
+          return rendered_template
+        end
+
+        # Compose skill + template
+        composed = [
+          skill.content,
+          SKILL_TEMPLATE_SEPARATOR,
+          "# Current Task",
+          "",
+          rendered_template
+        ].join("\n")
+
+        Aidp.log_debug(
+          "skills",
+          "Composed prompt with skill",
+          skill_id: skill.id,
+          total_length: composed.length,
+          skill_length: skill.content.length,
+          template_length: rendered_template.length
+        )
+
+        composed
+      end
+
+      # Render a template with variable substitution
+      #
+      # Replaces {{variable}} placeholders with values from options hash
+      #
+      # @param template [String] Template content
+      # @param options [Hash] Variable values for substitution
+      # @return [String] Rendered template
+      def render_template(template, options: {})
+        return template if options.empty?
+
+        rendered = template.dup
+
+        options.each do |key, value|
+          placeholder = "{{#{key}}}"
+          rendered = rendered.gsub(placeholder, value.to_s)
+        end
+
+        # Log if there are unreplaced placeholders
+        remaining_placeholders = extract_placeholders(rendered)
+        if remaining_placeholders.any?
+          Aidp.log_warn(
+            "skills",
+            "Unreplaced template variables",
+            placeholders: remaining_placeholders
+          )
+        end
+
+        rendered
+      end
+
+      # Compose multiple skills with a template
+      #
+      # Note: This is for future use when skill composition is supported.
+      # Currently raises an error as it's not implemented in v1.
+      #
+      # @param skills [Array<Skill>] Skills to compose
+      # @param template [String] Template content
+      # @param options [Hash] Template variables
+      # @return [String] Composed prompt
+      # @raise [NotImplementedError] Skill composition not yet supported
+      def compose_multiple(skills:, template:, options: {})
+        raise NotImplementedError, "Multiple skill composition not yet supported in v1"
+      end
+
+      # Preview what a composed prompt would look like
+      #
+      # Returns a hash with skill content, template content, and full composition
+      # for inspection without executing.
+      #
+      # @param skill [Skill, nil] Skill to include
+      # @param template [String] Template content
+      # @param options [Hash] Template variables
+      # @return [Hash] Preview with :skill, :template, :composed, :metadata
+      def preview(template:, skill: nil, options: {})
+        rendered_template = render_template(template, options: options)
+        composed = compose(skill: skill, template: template, options: options)
+
+        {
+          skill: skill ? {
+            id: skill.id,
+            name: skill.name,
+            content: skill.content,
+            length: skill.content.length
+          } : nil,
+          template: {
+            content: rendered_template,
+            length: rendered_template.length,
+            variables: options.keys
+          },
+          composed: {
+            content: composed,
+            length: composed.length
+          },
+          metadata: {
+            has_skill: !skill.nil?,
+            separator_used: !skill.nil?,
+            unreplaced_vars: extract_placeholders(composed)
+          }
+        }
+      end
+
+      private
+
+      def extract_placeholders(text)
+        return [] if text.nil? || text.empty?
+
+        scanner = StringScanner.new(text)
+        placeholders = []
+
+        while scanner.skip_until(/\{\{/)
+          fragment = scanner.scan_until(/\}\}/)
+          break unless fragment
+
+          placeholder = fragment[0...-2]
+          next if placeholder.nil? || placeholder.empty? || placeholder.include?("{")
+
+          placeholders << placeholder
+        end
+
+        placeholders
+      end
+    end
+  end
+end

data/lib/aidp/skills/loader.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "../errors"
+
+module Aidp
+  module Skills
+    # Loads skills from SKILL.md files with YAML frontmatter
+    #
+    # Parses skill files in the format:
+    #   ---
+    #   id: skill_id
+    #   name: Skill Name
+    #   ...
+    #   ---
+    #   # Skill content in markdown
+    #
+    # @example Loading a skill
+    #   skill = Loader.load_from_file("/path/to/SKILL.md")
+    #
+    # @example Loading a skill with provider filtering
+    #   skill = Loader.load_from_file("/path/to/SKILL.md", provider: "anthropic")
+    class Loader
+      # Load a skill from a file path
+      #
+      # @param file_path [String] Path to SKILL.md file
+      # @param provider [String, nil] Optional provider name for compatibility check
+      # @return [Skill, nil] Loaded skill or nil if incompatible with provider
+      # @raise [Aidp::Errors::ValidationError] if file format is invalid
+      def self.load_from_file(file_path, provider: nil)
+        Aidp.log_debug("skills", "Loading skill from file", file: file_path, provider: provider)
+
+        unless File.exist?(file_path)
+          raise Aidp::Errors::ValidationError, "Skill file not found: #{file_path}"
+        end
+
+        content = File.read(file_path)
+        load_from_string(content, source_path: file_path, provider: provider)
+      end
+
+      # Load a skill from a string
+      #
+      # @param content [String] SKILL.md file content
+      # @param source_path [String] Source file path for reference
+      # @param provider [String, nil] Optional provider name for compatibility check
+      # @return [Skill, nil] Loaded skill or nil if incompatible with provider
+      # @raise [Aidp::Errors::ValidationError] if format is invalid
+      def self.load_from_string(content, source_path:, provider: nil)
+        metadata, markdown = parse_frontmatter(content, source_path: source_path)
+
+        skill = Skill.new(
+          id: metadata["id"],
+          name: metadata["name"],
+          description: metadata["description"],
+          version: metadata["version"],
+          expertise: metadata["expertise"] || [],
+          keywords: metadata["keywords"] || [],
+          when_to_use: metadata["when_to_use"] || [],
+          when_not_to_use: metadata["when_not_to_use"] || [],
+          compatible_providers: metadata["compatible_providers"] || [],
+          content: markdown,
+          source_path: source_path
+        )
+
+        # Filter by provider compatibility if specified
+        if provider && !skill.compatible_with?(provider)
+          Aidp.log_debug(
+            "skills",
+            "Skipping incompatible skill",
+            skill_id: skill.id,
+            provider: provider,
+            compatible: skill.compatible_providers
+          )
+          return nil
+        end
+
+        Aidp.log_debug(
+          "skills",
+          "Loaded skill",
+          skill_id: skill.id,
+          version: skill.version,
+          source: source_path
+        )
+
+        skill
+      rescue Aidp::Errors::ValidationError => e
+        Aidp.log_error("skills", "Skill validation failed", error: e.message, file: source_path)
+        raise
+      end
+
+      # Load all skills from a directory
+      #
+      # @param directory [String] Path to directory containing skill subdirectories
+      # @param provider [String, nil] Optional provider name for compatibility check
+      # @return [Array<Skill>] Array of loaded skills (excludes incompatible)
+      def self.load_from_directory(directory, provider: nil)
+        Aidp.log_debug("skills", "Loading skills from directory", directory: directory, provider: provider)
+
+        unless Dir.exist?(directory)
+          Aidp.log_warn("skills", "Skills directory not found", directory: directory)
+          return []
+        end
+
+        skills = []
+        skill_dirs = Dir.glob(File.join(directory, "*")).select { |path| File.directory?(path) }
+
+        skill_dirs.each do |skill_dir|
+          skill_file = File.join(skill_dir, "SKILL.md")
+          next unless File.exist?(skill_file)
+
+          begin
+            skill = load_from_file(skill_file, provider: provider)
+            skills << skill if skill # nil if incompatible with provider
+          rescue Aidp::Errors::ValidationError => e
+            Aidp.log_warn(
+              "skills",
+              "Failed to load skill",
+              file: skill_file,
+              error: e.message
+            )
+            # Continue loading other skills even if one fails
+          end
+        end
+
+        Aidp.log_info(
+          "skills",
+          "Loaded skills from directory",
+          directory: directory,
+          count: skills.size
+        )
+
+        skills
+      end
+
+      # Parse YAML frontmatter from content
+      #
+      # @param content [String] File content with frontmatter
+      # @param source_path [String] Source path for error messages
+      # @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:)
+        lines = content.lines
+
+        unless lines.first&.strip == "---"
+          raise Aidp::Errors::ValidationError,
+            "Invalid SKILL.md format: missing YAML frontmatter in #{source_path}"
+        end
+
+        frontmatter_lines = []
+        body_start_index = nil
+
+        lines[1..].each_with_index do |line, index|
+          if line.strip == "---"
+            body_start_index = index + 2
+            break
+          end
+
+          frontmatter_lines << line
+        end
+
+        unless body_start_index
+          raise Aidp::Errors::ValidationError,
+            "Invalid SKILL.md format: missing closing frontmatter delimiter in #{source_path}"
+        end
+
+        markdown_content = lines[body_start_index..]&.join.to_s.strip
+        frontmatter_yaml = frontmatter_lines.join
+
+        begin
+          metadata = YAML.safe_load(frontmatter_yaml, permitted_classes: [Symbol])
+        rescue Psych::SyntaxError => e
+          raise Aidp::Errors::ValidationError,
+            "Invalid YAML frontmatter in #{source_path}: #{e.message}"
+        end
+
+        unless metadata.is_a?(Hash)
+          raise Aidp::Errors::ValidationError,
+            "YAML frontmatter must be a hash in #{source_path}"
+        end
+
+        validate_required_fields(metadata, source_path: source_path)
+
+        [metadata, markdown_content]
+      end
+
+      # Validate required frontmatter fields
+      #
+      # @param metadata [Hash] Parsed YAML metadata
+      # @param source_path [String] Source path for error messages
+      # @raise [Aidp::Errors::ValidationError] if required fields are missing
+      def self.validate_required_fields(metadata, source_path:)
+        required_fields = %w[id name description version]
+
+        required_fields.each do |field|
+          next if metadata[field] && !metadata[field].to_s.strip.empty?
+
+          raise Aidp::Errors::ValidationError,
+            "Missing required field '#{field}' in #{source_path}"
+        end
+      end
+
+      private_class_method :parse_frontmatter, :validate_required_fields
+    end
+  end
+end