aidp 0.17.1 → 0.18.0

data/lib/aidp/prompt_optimization/style_guide_indexer.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Aidp
+  module PromptOptimization
+    # Indexes LLM_STYLE_GUIDE.md into retrievable fragments
+    #
+    # Parses the style guide markdown and creates searchable fragments
+    # based on headings and sections. Each fragment can be independently
+    # included or excluded from prompts based on relevance.
+    #
+    # @example Basic usage
+    #   indexer = StyleGuideIndexer.new(project_dir: "/path/to/project")
+    #   indexer.index!
+    #   fragments = indexer.find_fragments(tags: ["testing", "naming"])
+    class StyleGuideIndexer
+      attr_reader :fragments, :project_dir
+
+      def initialize(project_dir:)
+        @project_dir = project_dir
+        @fragments = []
+      end
+
+      # Index the style guide file
+      #
+      # Parses the LLM_STYLE_GUIDE.md and extracts fragments
+      # organized by sections and headings
+      #
+      # @return [Array<Fragment>] List of indexed fragments
+      def index!
+        @fragments = []
+        content = read_style_guide
+
+        return @fragments if content.nil? || content.empty?
+
+        parse_fragments(content)
+        @fragments
+      end
+
+      # Find fragments matching given criteria
+      #
+      # @param tags [Array<String>] Tags to match (e.g., ["testing", "naming"])
+      # @param heading [String] Heading pattern to match
+      # @param min_level [Integer] Minimum heading level (1-6)
+      # @param max_level [Integer] Maximum heading level (1-6)
+      # @return [Array<Fragment>] Matching fragments
+      def find_fragments(tags: nil, heading: nil, min_level: 1, max_level: 6)
+        results = @fragments
+
+        if tags && !tags.empty?
+          results = results.select { |f| f.matches_any_tag?(tags) }
+        end
+
+        if heading
+          pattern = Regexp.new(heading, Regexp::IGNORECASE)
+          results = results.select { |f| f.heading =~ pattern }
+        end
+
+        results.select { |f| f.level.between?(min_level, max_level) }
+      end
+
+      # Get all unique tags from indexed fragments
+      #
+      # @return [Array<String>] List of all tags
+      def all_tags
+        @fragments.flat_map(&:tags).uniq.sort
+      end
+
+      # Get fragment by ID
+      #
+      # @param id [String] Fragment ID (e.g., "naming-structure")
+      # @return [Fragment, nil] The fragment or nil if not found
+      def find_by_id(id)
+        @fragments.find { |f| f.id == id }
+      end
+
+      private
+
+      # Read the LLM_STYLE_GUIDE.md file
+      #
+      # @return [String, nil] File content or nil if not found
+      def read_style_guide
+        guide_path = File.join(@project_dir, "docs", "LLM_STYLE_GUIDE.md")
+        return nil unless File.exist?(guide_path)
+
+        File.read(guide_path)
+      end
+
+      # Parse markdown content into fragments
+      #
+      # @param content [String] Markdown content
+      # @return [Array<Fragment>] Parsed fragments
+      def parse_fragments(content)
+        lines = content.lines
+        current_content = []
+        current_heading = nil
+        current_level = 0
+
+        lines.each_with_index do |line, idx|
+          if line.match?(/^#+\s+/)
+            # Save previous section if exists
+            save_fragment(current_heading, current_level, current_content) if current_heading
+
+            # Start new section
+            current_level = line.match(/^(#+)/)[1].length
+            current_heading = line.sub(/^#+\s+/, "").strip
+            current_content = [line]
+          elsif current_heading
+            current_content << line
+          end
+        end
+
+        # Save last section
+        save_fragment(current_heading, current_level, current_content) if current_heading
+      end
+
+      # Save a fragment from heading and content
+      #
+      # @param heading [String] Section heading
+      # @param level [Integer] Heading level (1-6)
+      # @param content [Array<String>] Section content lines
+      def save_fragment(heading, level, content)
+        return if heading.nil? || content.empty?
+
+        fragment = Fragment.new(
+          id: generate_id(heading),
+          heading: heading,
+          level: level,
+          content: content.join,
+          tags: extract_tags(heading, content.join)
+        )
+
+        @fragments << fragment
+      end
+
+      # Generate a unique ID from heading
+      #
+      # @param heading [String] Section heading
+      # @return [String] Fragment ID (e.g., "zero-framework-cognition-zfc")
+      def generate_id(heading)
+        heading
+          .downcase
+          .gsub(/[^a-z0-9\s-]/, "")
+          .gsub(/\s+/, "-").squeeze("-")
+          .gsub(/\A-|-\z/, "")
+      end
+
+      # Extract relevant tags from heading and content
+      #
+      # @param heading [String] Section heading
+      # @param content [String] Section content
+      # @return [Array<String>] List of tags
+      def extract_tags(heading, content)
+        tags = []
+
+        # Extract from heading
+        tags << "naming" if /naming|structure/i.match?(heading)
+        tags << "testing" if /test/i.match?(heading)
+        tags << "logging" if /log/i.match?(heading)
+        tags << "error" if /error|exception/i.match?(heading)
+        tags << "security" if /security|auth/i.match?(heading)
+        tags << "performance" if /performance|optim/i.match?(heading)
+        tags << "zfc" if /zero framework|zfc/i.match?(heading)
+        tags << "tty" if /tty|tui|ui/i.match?(heading)
+        tags << "git" if /git|version|commit/i.match?(heading)
+        tags << "style" if /style|format|convention/i.match?(heading)
+        tags << "refactor" if /refactor/i.match?(heading)
+        tags << "architecture" if /architect|design|pattern/i.match?(heading)
+
+        # Extract from content keywords
+        tags << "testing" if /rspec|test.*spec|describe.*it/i.match?(content)
+        tags << "async" if /async|thread|concurrent/i.match?(content)
+        tags << "api" if /api|endpoint|rest/i.match?(content)
+        tags << "database" if /database|sql|query/i.match?(content)
+
+        tags.uniq
+      end
+    end
+
+    # Represents a fragment of the style guide
+    #
+    # Each fragment corresponds to a section or subsection
+    # and can be independently selected for inclusion in prompts
+    class Fragment
+      attr_reader :id, :heading, :level, :content, :tags
+
+      def initialize(id:, heading:, level:, content:, tags: [])
+        @id = id
+        @heading = heading
+        @level = level
+        @content = content
+        @tags = tags
+      end
+
+      # Check if fragment matches any of the given tags
+      #
+      # @param query_tags [Array<String>] Tags to match against
+      # @return [Boolean] True if any tag matches
+      def matches_any_tag?(query_tags)
+        query_tags = query_tags.map(&:downcase)
+        @tags.any? { |tag| query_tags.include?(tag.downcase) }
+      end
+
+      # Get the size of the fragment in characters
+      #
+      # @return [Integer] Character count
+      def size
+        @content.length
+      end
+
+      # Estimate token count (rough approximation: 1 token ≈ 4 chars)
+      #
+      # @return [Integer] Estimated token count
+      def estimated_tokens
+        (size / 4.0).ceil
+      end
+
+      # Get a summary of the fragment
+      #
+      # @return [Hash] Fragment summary
+      def summary
+        {
+          id: @id,
+          heading: @heading,
+          level: @level,
+          tags: @tags,
+          size: size,
+          estimated_tokens: estimated_tokens
+        }
+      end
+
+      def to_s
+        "Fragment<#{@id}>"
+      end
+
+      def inspect
+        "#<Fragment id=#{@id} heading=\"#{@heading}\" level=#{@level} tags=#{@tags}>"
+      end
+    end
+  end
+end

data/lib/aidp/prompt_optimization/template_indexer.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Aidp
+  module PromptOptimization
+    # Indexes step templates into retrievable fragments
+    #
+    # Parses template markdown files from the templates/ directory
+    # and creates searchable fragments based on template category,
+    # content, and keywords.
+    #
+    # @example Basic usage
+    #   indexer = TemplateIndexer.new(project_dir: "/path/to/project")
+    #   indexer.index!
+    #   fragments = indexer.find_templates(category: "analysis", tags: ["testing"])
+    class TemplateIndexer
+      attr_reader :templates, :project_dir
+
+      # Template categories based on directory structure
+      CATEGORIES = %w[analysis planning implementation].freeze
+
+      def initialize(project_dir:)
+        @project_dir = project_dir
+        @templates = []
+      end
+
+      # Index all template files
+      #
+      # Scans the templates/ directory and indexes all markdown templates
+      #
+      # @return [Array<TemplateFragment>] List of indexed templates
+      def index!
+        @templates = []
+
+        CATEGORIES.each do |category|
+          category_dir = File.join(@project_dir, "templates", category)
+          next unless Dir.exist?(category_dir)
+
+          index_category(category, category_dir)
+        end
+
+        @templates
+      end
+
+      # Find templates matching given criteria
+      #
+      # @param category [String, nil] Category to filter by (e.g., "analysis", "planning")
+      # @param tags [Array<String>] Tags to match
+      # @param name [String, nil] Template name pattern to match
+      # @return [Array<TemplateFragment>] Matching templates
+      def find_templates(category: nil, tags: nil, name: nil)
+        results = @templates
+
+        if category
+          results = results.select { |t| t.category == category }
+        end
+
+        if tags && !tags.empty?
+          results = results.select { |t| t.matches_any_tag?(tags) }
+        end
+
+        if name
+          pattern = Regexp.new(name, Regexp::IGNORECASE)
+          results = results.select { |t| t.name =~ pattern }
+        end
+
+        results
+      end
+
+      # Get all unique tags from indexed templates
+      #
+      # @return [Array<String>] List of all tags
+      def all_tags
+        @templates.flat_map(&:tags).uniq.sort
+      end
+
+      # Get all categories
+      #
+      # @return [Array<String>] List of categories
+      def categories
+        @templates.map(&:category).uniq.sort
+      end
+
+      # Get template by ID
+      #
+      # @param id [String] Template ID
+      # @return [TemplateFragment, nil] The template or nil if not found
+      def find_by_id(id)
+        @templates.find { |t| t.id == id }
+      end
+
+      private
+
+      # Index all templates in a category
+      #
+      # @param category [String] Category name
+      # @param category_dir [String] Category directory path
+      def index_category(category, category_dir)
+        Dir.glob(File.join(category_dir, "*.md")).each do |file_path|
+          template = parse_template(category, file_path)
+          @templates << template if template
+        end
+      end
+
+      # Parse a template file
+      #
+      # @param category [String] Template category
+      # @param file_path [String] Path to template file
+      # @return [TemplateFragment, nil] Parsed template or nil
+      def parse_template(category, file_path)
+        content = File.read(file_path)
+        filename = File.basename(file_path, ".md")
+
+        # Extract title from first heading
+        title = extract_title(content) || titleize(filename)
+
+        # Extract tags from content and filename
+        tags = extract_tags(filename, content, category)
+
+        TemplateFragment.new(
+          id: "#{category}/#{filename}",
+          name: title,
+          category: category,
+          file_path: file_path,
+          content: content,
+          tags: tags
+        )
+      rescue => e
+        Aidp.log_error("template_indexer", "Failed to parse template",
+          file: file_path, error: e.message)
+        nil
+      end
+
+      # Extract title from markdown content
+      #
+      # @param content [String] Markdown content
+      # @return [String, nil] Extracted title
+      def extract_title(content)
+        match = content.match(/^#\s+(.+)$/)
+        match&.[](1)&.strip
+      end
+
+      # Convert filename to title case
+      #
+      # @param filename [String] Filename without extension
+      # @return [String] Title-cased string
+      def titleize(filename)
+        filename.split("_").map(&:capitalize).join(" ")
+      end
+
+      # Extract tags from template
+      #
+      # @param filename [String] Template filename
+      # @param content [String] Template content
+      # @param category [String] Template category
+      # @return [Array<String>] List of tags
+      def extract_tags(filename, content, category)
+        tags = [category]
+
+        # Extract from filename
+        tags << "testing" if /test/i.match?(filename)
+        tags << "refactor" if /refactor/i.match?(filename)
+        tags << "architecture" if /architect/i.match?(filename)
+        tags << "documentation" if /doc/i.match?(filename)
+        tags << "analysis" if /analy[sz]/i.match?(filename)
+        tags << "planning" if /plan|design/i.match?(filename)
+        tags << "implementation" if /implement/i.match?(filename)
+        tags << "security" if /security|auth/i.match?(filename)
+        tags << "performance" if /performance|optim/i.match?(filename)
+
+        # Extract from content
+        tags << "testing" if /test coverage|testing strategy/i.match?(content)
+        tags << "refactor" if /refactor|complexity/i.match?(content)
+        tags << "security" if /security|vulnerabilit/i.match?(content)
+        tags << "performance" if /performance|scalability/i.match?(content)
+        tags << "documentation" if /documentation|readme/i.match?(content)
+        tags << "database" if /database|sql|schema/i.match?(content)
+        tags << "api" if /\bapi\b|endpoint|rest/i.match?(content)
+
+        # Extract role-based tags
+        tags << "analyst" if /analyst/i.match?(content)
+        tags << "architect" if /architect/i.match?(content)
+        tags << "developer" if /developer|implementation/i.match?(content)
+
+        tags.uniq
+      end
+    end
+
+    # Represents a template fragment
+    #
+    # Each template is a complete markdown file that can be
+    # included or excluded from prompts based on relevance
+    class TemplateFragment
+      attr_reader :id, :name, :category, :file_path, :content, :tags
+
+      def initialize(id:, name:, category:, file_path:, content:, tags: [])
+        @id = id
+        @name = name
+        @category = category
+        @file_path = file_path
+        @content = content
+        @tags = tags
+      end
+
+      # Check if template matches any of the given tags
+      #
+      # @param query_tags [Array<String>] Tags to match against
+      # @return [Boolean] True if any tag matches
+      def matches_any_tag?(query_tags)
+        query_tags = query_tags.map(&:downcase)
+        @tags.any? { |tag| query_tags.include?(tag.downcase) }
+      end
+
+      # Get the size of the template in characters
+      #
+      # @return [Integer] Character count
+      def size
+        @content.length
+      end
+
+      # Estimate token count (rough approximation: 1 token ≈ 4 chars)
+      #
+      # @return [Integer] Estimated token count
+      def estimated_tokens
+        (size / 4.0).ceil
+      end
+
+      # Get a summary of the template
+      #
+      # @return [Hash] Template summary
+      def summary
+        {
+          id: @id,
+          name: @name,
+          category: @category,
+          tags: @tags,
+          size: size,
+          estimated_tokens: estimated_tokens
+        }
+      end
+
+      def to_s
+        "TemplateFragment<#{@id}>"
+      end
+
+      def inspect
+        "#<TemplateFragment id=#{@id} name=\"#{@name}\" category=#{@category} tags=#{@tags}>"
+      end
+    end
+  end
+end

data/lib/aidp/provider_manager.rb

@@ -142,8 +142,6 @@ module Aidp
           Aidp::Providers::Anthropic.new(prompt: prompt)
         when "gemini"
           Aidp::Providers::Gemini.new(prompt: prompt)
-        when "macos_ui"
-          Aidp::Providers::MacOSUI.new(prompt: prompt)
         when "github_copilot"
           Aidp::Providers::GithubCopilot.new(prompt: prompt)
         when "codex"

data/lib/aidp/providers/anthropic.rb

@@ -67,6 +67,12 @@ module Aidp
           args += ["--output-format=text"]
         end
 
+        # Check if we should skip permissions (devcontainer support)
+        if should_skip_permissions?
+          args << "--dangerously-skip-permissions"
+          debug_log("🔓 Running with elevated permissions (devcontainer mode)", level: :info)
+        end
+
         begin
           # Use debug_execute_command with streaming support
           result = debug_execute_command("claude", args: args, input: prompt, timeout: timeout_seconds, streaming: streaming_enabled)
@@ -156,6 +162,19 @@ module Aidp
         end
       end
 
+      # Check if we should skip permissions based on devcontainer configuration
+      def should_skip_permissions?
+        # Check if harness context is available
+        return false unless @harness_context
+
+        # Get configuration from harness
+        config = @harness_context.config
+        return false unless config
+
+        # Use configuration method to determine if full permissions should be used
+        config.should_use_full_permissions?("claude")
+      end
+
       # Parse stream-json output from Claude CLI
       def parse_stream_json_output(output)
         return output if output.nil? || output.empty?