aidp 0.41.0 → 0.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f3d8cc88b8d264095f965487244c597be15336e889a57babebf8bc6da70cb17
-  data.tar.gz: c1cb36afa4ae243874087152715829f72f72a8a530d8168c872cbe36367a7659
+  metadata.gz: 013dc044889cc320404776d0691d2091f3cddda0d9ba854dc0afb92312396336
+  data.tar.gz: bb1c57bf8e7d87dfa7d7b169d69646ac76c0cb14fe2f72c70ef02b8543b43494
 SHA512:
-  metadata.gz: d8f4bd6b9900a418406f72e34c52daecca793284f137ea28227503d723495cf9c7a3f03910474bce6d460c37f51773c16e96a012612680342791b41e0cbd076f
-  data.tar.gz: b797ddd64998481040f02a10a830fab2f7f739fd83e0d7d69b97cbc3a77816e3d1781a97910d57cebcabf2f6fe76c214a82650fec575f8a412c9a831e68e6602
+  metadata.gz: c7ea760cd1d62424ada60f64acc356cdf4a82db6e2166c203d9d41c489fed936a704afaee17e9a20d588fbf0ead8ebd816a991a3fa01d87644939c872b104b12
+  data.tar.gz: 9c3b34d7474a2f9e899bf50d9b61d1edcb67a1b4a7b41d78abf810517db8cb2082fe889ec7b1fda5266276b6f1406e577644f2ddca16142bcf66e66e79b1e338

data/lib/aidp/cli/providers_command.rb

@@ -6,6 +6,7 @@ require "tty-spinner"
 require_relative "../harness/provider_info"
 require_relative "../harness/capability_registry"
 require_relative "../harness/config_manager"
+require_relative "../security"
 
 module Aidp
   class CLI
@@ -21,12 +22,13 @@ module Aidp
     class ProvidersCommand
       include Aidp::MessageDisplay
 
-      def initialize(prompt: TTY::Prompt.new, provider_info_class: nil, capability_registry_class: nil, config_manager_class: nil, project_dir: nil)
+      def initialize(prompt: TTY::Prompt.new, provider_info_class: nil, capability_registry_class: nil, config_manager_class: nil, project_dir: nil, mcp_tool_risk_classifier_class: nil)
         @prompt = prompt
         @provider_info_class = provider_info_class || Aidp::Harness::ProviderInfo
         @capability_registry_class = capability_registry_class || Aidp::Harness::CapabilityRegistry
         @config_manager_class = config_manager_class || Aidp::Harness::ConfigManager
         @project_dir = project_dir || Dir.pwd
+        @mcp_tool_risk_classifier_class = mcp_tool_risk_classifier_class || Aidp::Security::McpToolRiskClassifier
       end
 
       # Main entry point for providers info/refresh subcommands
@@ -198,10 +200,23 @@ module Aidp
           end
         end
 
+        refresh_mcp_risk_profile(config_manager, providers_to_refresh)
+
         display_message("\n" + "=" * 60, type: :muted)
         display_message("Refresh complete", type: :highlight)
       end
 
+      def refresh_mcp_risk_profile(config_manager, providers_to_refresh)
+        classifier = @mcp_tool_risk_classifier_class.new(config_manager, project_dir: @project_dir)
+        classifier.generate!(
+          providers: config_manager.provider_names,
+          force_refresh_providers: providers_to_refresh
+        )
+        display_message("✓ MCP risk profile refreshed", type: :success)
+      rescue => e
+        display_message("⚠ MCP risk profile refresh failed: #{e.message}", type: :warning)
+      end
+
       def display_help
         display_message("\nUsage: aidp providers <subcommand> [options]", type: :info)
         display_message("\nSubcommands:", type: :info)

data/lib/aidp/config_paths.rb

@@ -32,6 +32,7 @@ module Aidp
     # Security module paths
     def self.security_dir(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "security")
     def self.secrets_registry_file(project_dir = Dir.pwd) = File.join(security_dir(project_dir), "secrets_registry.json")
+    def self.mcp_risk_profile_file(project_dir = Dir.pwd) = File.join(security_dir(project_dir), "mcp_risk_profile.yml")
 
     # Database path
     def self.database_file(project_dir = Dir.pwd) = File.join(aidp_dir(project_dir), "aidp.db")

data/lib/aidp/execute/project_knowledge_manager.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "shellwords"
+
+module Aidp
+  module Execute
+    # Creates and refreshes concise feature/tool notes under docs/
+    class ProjectKnowledgeManager
+      MAX_TOOL_NOTES = 5
+      FEATURE_ROOT_SEGMENTS = %w[app client lib packages server src].freeze
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+      end
+
+      def sync!(step_name:, task_description:, affected_files:, tool_commands:, feature_identifier: nil)
+        sync_feature_note(
+          feature_identifier: feature_identifier,
+          task_description: task_description,
+          affected_files: affected_files
+        )
+        sync_tool_notes(step_name: step_name, affected_files: affected_files, tool_commands: tool_commands)
+      end
+
+      private
+
+      def sync_feature_note(feature_identifier:, task_description:, affected_files:)
+        return if affected_files.empty?
+
+        feature_id = resolve_feature_id(
+          feature_identifier: feature_identifier,
+          affected_files: affected_files
+        )
+        return if feature_id.empty?
+
+        path = File.join(@project_dir, "docs", "features", "#{feature_id}.md")
+        markers = affected_files.map { |file| "<#{feature_id}:#{file}>" }
+        learning = bullet_line("#{Time.now.utc.iso8601}: #{learning_summary(task_description)}")
+
+        content = if File.exist?(path)
+          update_existing_note(File.read(path, encoding: "UTF-8"), markers: markers, learning: learning)
+        else
+          build_feature_note(feature_id: feature_id, markers: markers, learning: learning)
+        end
+
+        write_note(path, content)
+      end
+
+      def sync_tool_notes(step_name:, affected_files:, tool_commands:)
+        tool_commands.first(MAX_TOOL_NOTES).each do |command|
+          tool_id = tool_identifier(command)
+          next if tool_id.empty?
+
+          path = File.join(@project_dir, "docs", "tools", "#{tool_id}.md")
+          commands = [bullet_line("`#{command}`")]
+          markers = affected_files.map { |file| "<#{tool_id}:#{file}>" }
+          learning = bullet_line("#{Time.now.utc.iso8601}: Used `#{command}` during `#{step_name}`.")
+
+          content = if File.exist?(path)
+            update_existing_note(File.read(path, encoding: "UTF-8"), markers: markers, learning: learning, commands: commands)
+          else
+            build_tool_note(commands: commands, tool_id: tool_id, markers: markers, learning: learning)
+          end
+
+          write_note(path, content)
+        end
+      end
+
+      def build_feature_note(feature_id:, markers:, learning:)
+        <<~MARKDOWN
+          # #{humanize(feature_id)}
+
+          ## Paths
+          #{markers.join("\n")}
+
+          ## Purpose
+          - Concise feature context for work touching these paths.
+
+          ## Users
+          - Add the end users or personas when they become clear.
+
+          ## Known Gaps
+          - Add concrete gaps when discovered.
+
+          ## Key Decisions
+          - Add behavior-affecting decisions when they become clear.
+
+          ## Recent Learnings
+          #{learning}
+        MARKDOWN
+      end
+
+      def build_tool_note(commands:, tool_id:, markers:, learning:)
+        paths_section = markers.empty? ? "- Add affected paths as they become known." : markers.join("\n")
+
+        <<~MARKDOWN
+          # #{humanize(tool_id)}
+
+          ## Commands
+          #{commands.join("\n")}
+
+          ## Paths
+          #{paths_section}
+
+          ## Intended Use
+          - Run this tool while validating or updating related paths.
+
+          ## Known Gaps
+          - Add environment quirks or failure modes when discovered.
+
+          ## Recent Learnings
+          #{learning}
+        MARKDOWN
+      end
+
+      def update_existing_note(content, markers:, learning:, commands: [])
+        updated = ensure_section_entries(content, "Commands", commands)
+        updated = ensure_section_entries(updated, "Paths", markers)
+        ensure_section_entries(updated, "Recent Learnings", [learning], normalizer: method(:normalize_learning_entry))
+      end
+
+      def ensure_section_entries(content, section_name, entries, normalizer: nil)
+        return content if entries.empty?
+
+        existing_section = content.match(/(## #{Regexp.escape(section_name)}\n)(.*?)(?=\n## |\z)/m)
+        return append_new_section(content, section_name, entries) unless existing_section
+
+        body = existing_section[2].to_s
+        existing_entries = body.lines.map(&:strip).reject(&:empty?)
+        normalized_existing = normalize_section_entries(existing_entries, normalizer)
+        missing = entries.reject do |entry|
+          normalized_existing.include?(normalize_section_entry(entry, normalizer))
+        end
+        return content if missing.empty?
+
+        replacement = "#{existing_section[1]}#{body.rstrip}\n#{missing.join("\n")}\n"
+        content.sub(existing_section[0], replacement)
+      end
+
+      def append_new_section(content, section_name, entries)
+        [content.rstrip, "", "## #{section_name}", entries.join("\n"), ""].join("\n")
+      end
+
+      def write_note(path, content)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+      end
+
+      def resolve_feature_id(feature_identifier:, affected_files:)
+        explicit_id = normalize_id(feature_identifier)
+        return explicit_id unless explicit_id.empty?
+
+        derived_id = normalize_id(feature_path_identifier(affected_files))
+        return derived_id unless derived_id.empty?
+
+        ""
+      end
+
+      def feature_path_identifier(affected_files)
+        feature_files = affected_files.select { |file| feature_path?(file) }
+        segments = feature_files.map { |file| trimmed_feature_segments(file) }
+        return "" if segments.empty?
+
+        shared_segments = meaningful_segments(common_path_segments(segments))
+        return shared_segments.join("_") unless shared_segments.empty?
+
+        meaningful_segments(segments.first).join("_")
+      end
+
+      def feature_path?(file)
+        path_segments = file.to_s.split("/")
+        FEATURE_ROOT_SEGMENTS.include?(path_segments.first) && path_segments.length > 1
+      end
+
+      def common_path_segments(all_segments)
+        shared = []
+        max_length = all_segments.map(&:length).min
+
+        max_length.times do |index|
+          segment = all_segments.first[index]
+          break unless all_segments.all? { |segments| segments[index] == segment }
+
+          shared << segment
+        end
+
+        shared
+      end
+
+      def meaningful_segments(path_segments)
+        path_segments.map { |segment| segment.sub(/\.[^.]+\z/, "") }
+          .reject { |segment| generic_path_segment?(segment) }
+          .reject(&:empty?)
+      end
+
+      def trimmed_feature_segments(file)
+        segments = file.to_s.split("/")
+        return segments unless generic_path_segment?(segments.first)
+
+        segments.drop(1)
+      end
+
+      def generic_path_segment?(segment)
+        %w[app client docs lib packages server spec src test].include?(segment)
+      end
+
+      def normalize_id(value)
+        value.to_s.downcase.gsub(/[^a-z0-9]+/, "_").gsub(/\A_|_\z/, "")
+      end
+
+      def learning_summary(task_description)
+        single_line = task_description.to_s.encode("UTF-8", invalid: :replace, undef: :replace)
+          .lines
+          .map(&:strip)
+          .reject(&:empty?)
+          .join(" ")
+          .gsub(/\s+/, " ")
+
+        return "Updated feature context." if single_line.empty?
+        return single_line if single_line.length <= 200
+
+        "#{single_line[0, 197].rstrip}..."
+      end
+
+      def normalize_section_entries(entries, normalizer)
+        entries.map { |entry| normalize_section_entry(entry, normalizer) }
+      end
+
+      def normalize_section_entry(entry, normalizer)
+        return entry unless normalizer
+
+        normalizer.call(entry)
+      end
+
+      def normalize_learning_entry(entry)
+        entry.to_s.sub(/\A-\s*/, "").sub(/\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z:\s*/, "")
+      end
+
+      def tool_identifier(command)
+        raw_command = command.to_s.strip
+        tokens = Shellwords.split(raw_command)
+        executable = unwrap_tool_command(strip_env_assignments(tokens))
+        normalize_id(executable)
+      rescue ArgumentError
+        normalize_id(raw_command.split(/\s+/).first)
+      end
+
+      def unwrap_tool_command(tokens)
+        command_tokens = tokens.dup
+
+        loop do
+          return "" if command_tokens.empty?
+
+          case command_tokens.first
+          when "mise"
+            command_tokens = unwrap_mise_exec(command_tokens)
+          when "env", "/usr/bin/env"
+            command_tokens = unwrap_env(command_tokens)
+          when "bundle"
+            return File.basename(command_tokens.first, ".rb") unless command_tokens[1] == "exec"
+
+            command_tokens = command_tokens.drop(2)
+          when "ruby"
+            return File.basename(command_tokens[1], ".rb") if command_tokens[1]
+
+            command_tokens = []
+          else
+            return File.basename(command_tokens.first, ".rb")
+          end
+        end
+      end
+
+      def strip_env_assignments(tokens)
+        tokens.drop_while { |token| token.include?("=") && !token.start_with?("/", "./", "../") }
+      end
+
+      def unwrap_mise_exec(tokens)
+        return tokens unless tokens[1] == "exec"
+
+        separator_index = tokens.index("--")
+        remaining = separator_index ? tokens.drop(separator_index + 1) : tokens.drop(2)
+        strip_env_assignments(remaining)
+      end
+
+      def unwrap_env(tokens)
+        remaining = tokens.drop(1)
+        remaining = remaining.drop_while { |token| token.start_with?("-") }
+        strip_env_assignments(remaining)
+      end
+
+      def humanize(value)
+        value.to_s.split(/[_\s]+/).map(&:capitalize).join(" ")
+      end
+
+      def bullet_line(value)
+        "- #{value}"
+      end
+    end
+  end
+end