aidp 0.17.1 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 949670fdea4721406643f4fd8da096e943740effbd836407311b812350919b14
-  data.tar.gz: 8034a3c798571e4626b273c4a9abe9a5da38cef5dd4f25de8794a0ef63bf6022
+  metadata.gz: 95269030b5c3fe91c2cfb6e29066a4f37afbcf1903e930a377ec02dd1e8a738c
+  data.tar.gz: 6c343d45e804a73751c99e0e63491703c1eb9ba18fb2acf4e828198e774c2c92
 SHA512:
-  metadata.gz: cdabc6ba04d06a89dbc4ad19b27a64862e960daa350029db4fada5a4f6d32d3fba27cb32dda291871a79ad8f319d27e7dd1348ddcb7fdb8b0f0a1390b9493fc1
-  data.tar.gz: 39c384f4c01bf00bef550ac9190d27ddd268437be92fc4cdfcdeac3dff09c79c055b2e5b5582e553af6fa838b3f904cce354e9db62ee3638f658eec05673e4f5
+  metadata.gz: dc54a6f0b9424c18ebdd8e6df75e77f0f233db98dd59543a9dd6152eacd835d8820c437ccd220c3dbcfb43cf91bfeb47e40ce415773e8cd0e24783770b2ac033
+  data.tar.gz: f89cf387121e7edc3c384cead9369bc6ae5be97e639969fa036978a249779152ccd7a50832897be97d7fd04f4083ccf744e23e93c1117c6ed5d1cc7d8529615d

data/README.md

@@ -42,6 +42,75 @@ You can re-run the wizard manually:
 aidp --setup-config
 ```
 
+## Devcontainer Support
+
+AIDP provides first-class devcontainer support for sandboxed, secure AI agent execution. Devcontainers offer:
+
+- **Network Security**: Strict firewall with allowlisted domains only
+- **Sandboxed Environment**: Isolated from your host system
+- **Elevated Permissions**: AI agents can run with full permissions inside the container
+- **Consistent Setup**: Same environment across all developers
+
+### For AIDP Development
+
+This repository includes a `.devcontainer/` setup for developing AIDP itself:
+
+```bash
+# Open in VS Code
+code .
+
+# Press F1 → "Dev Containers: Reopen in Container"
+# Container builds automatically with Ruby 3.4.5, all tools, and firewall
+
+# Run tests inside container
+bundle exec rspec
+
+# Run AIDP inside container
+bundle exec aidp
+```
+
+See [.devcontainer/README.md](.devcontainer/README.md) for complete documentation.
+
+### Generating Devcontainers for Your Projects
+
+Use `aidp init` to generate a devcontainer for any project:
+
+```bash
+# Initialize project with devcontainer
+aidp init
+
+# When prompted:
+# "Generate devcontainer configuration for sandboxed development?" → Yes
+
+# Or use the flag directly
+aidp init --with-devcontainer
+```
+
+This creates:
+
+- `.devcontainer/Dockerfile` - Customized for your project's language/framework
+- `.devcontainer/devcontainer.json` - VS Code configuration and extensions
+- `.devcontainer/init-firewall.sh` - Network security rules
+- `.devcontainer/README.md` - Setup and usage documentation
+
+### Elevated Permissions in Devcontainers
+
+When running inside a devcontainer, you can enable elevated permissions for AI agents:
+
+```yaml
+# aidp.yml
+devcontainer:
+  enabled: true
+  full_permissions_when_in_devcontainer: true  # Run all providers with full permissions
+
+  # Or enable per-provider
+  permissions:
+    skip_permission_checks:
+      - claude  # Adds --dangerously-skip-permissions for Claude Code
+```
+
+AIDP automatically detects when it's running in a devcontainer and adjusts agent permissions accordingly. This is safe because the container is sandboxed from your host system.
+
 ## Core Features
 
 ### Work Loops

data/lib/aidp/cli.rb

@@ -759,9 +759,10 @@ module Aidp
         require_relative "harness/provider_info"
 
         provider_name = args.shift
+
+        # If no provider specified, show models catalog table
         unless provider_name
-          display_message("Usage: aidp providers info <provider_name>", type: :info)
-          display_message("Example: aidp providers info claude", type: :info)
+          run_providers_models_catalog
           return
         end
 
@@ -839,6 +840,46 @@ module Aidp
         display_message("Tip: Use --refresh to update this information", type: :muted)
       end
 
+      def run_providers_models_catalog
+        require_relative "harness/capability_registry"
+        require "tty-table"
+
+        display_message("Models Catalog - Thinking Depth Tiers", type: :highlight)
+        display_message("=" * 80, type: :muted)
+
+        registry = Aidp::Harness::CapabilityRegistry.new
+        unless registry.load_catalog
+          display_message("No models catalog found. Create .aidp/models_catalog.yml first.", type: :error)
+          return
+        end
+
+        rows = []
+        registry.provider_names.sort.each do |provider|
+          models = registry.models_for_provider(provider)
+          models.each do |model_name, model_data|
+            tier = model_data["tier"] || "-"
+            context = model_data["context_window"] ? "#{model_data["context_window"] / 1000}k" : "-"
+            tools = model_data["supports_tools"] ? "yes" : "no"
+            cost_input = model_data["cost_per_mtok_input"]
+            cost = cost_input ? "$#{cost_input}/MTok" : "-"
+
+            rows << [provider, model_name, tier, context, tools, cost]
+          end
+        end
+
+        if rows.empty?
+          display_message("No models found in catalog", type: :info)
+          return
+        end
+
+        header = ["Provider", "Model", "Tier", "Context", "Tools", "Cost"]
+        table = TTY::Table.new(header, rows)
+        display_message(table.render(:basic), type: :info)
+
+        display_message("\n" + "=" * 80, type: :muted)
+        display_message("Use '/thinking show' in REPL to see current tier configuration", type: :muted)
+      end
+
       def run_providers_refresh_command(args)
         require_relative "harness/provider_info"
         require "tty-spinner"

data/lib/aidp/config.rb

@@ -15,8 +15,7 @@ module Aidp
         no_api_keys_required: false,
         provider_weights: {
           "cursor" => 3,
-          "anthropic" => 2,
-          "macos" => 1
+          "anthropic" => 2
         },
         circuit_breaker: {
           enabled: true,
@@ -74,6 +73,7 @@ module Aidp
         cursor: {
           type: "subscription",
           priority: 1,
+          model_family: "auto",
           default_flags: [],
           models: ["cursor-default", "cursor-fast", "cursor-precise"],
           model_weights: {
@@ -108,6 +108,7 @@ module Aidp
         anthropic: {
           type: "usage_based",
           priority: 2,
+          model_family: "claude",
           max_tokens: 100_000,
           default_flags: ["--dangerously-skip-permissions"],
           models: ["claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022", "claude-3-opus-20240229"],
@@ -149,18 +150,6 @@ module Aidp
             enabled: true,
             metrics_interval: 60
           }
-        },
-        macos: {
-          type: "passthrough",
-          priority: 4,
-          underlying_service: "cursor",
-          models: ["cursor-chat"],
-          features: {
-            file_upload: false,
-            code_generation: true,
-            analysis: true,
-            interactive: true
-          }
         }
       },
       skills: {
@@ -342,6 +331,12 @@ module Aidp
         merged[:skills] = merged[:skills].merge(symbolize_keys(skills_section))
       end
 
+      # Deep merge thinking config
+      if config[:thinking] || config["thinking"]
+        thinking_section = config[:thinking] || config["thinking"]
+        merged[:thinking] = symbolize_keys(thinking_section)
+      end
+
       merged
     end
 

data/lib/aidp/execute/prompt_manager.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "../prompt_optimization/optimizer"
 
 module Aidp
   module Execute
@@ -9,21 +10,91 @@ module Aidp
     # - Read/write PROMPT.md
     # - Check existence
     # - Archive completed prompts
+    # - Optionally optimize prompts using intelligent fragment selection (ZFC)
     class PromptManager
       PROMPT_FILENAME = "PROMPT.md"
       ARCHIVE_DIR = ".aidp/prompt_archive"
 
-      def initialize(project_dir)
+      attr_reader :optimizer, :last_optimization_stats
+
+      def initialize(project_dir, config: nil)
         @project_dir = project_dir
         @prompt_path = File.join(project_dir, PROMPT_FILENAME)
         @archive_dir = File.join(project_dir, ARCHIVE_DIR)
+        @config = config
+        @optimizer = nil
+        @last_optimization_stats = nil
+
+        # Initialize optimizer if enabled
+        if config&.respond_to?(:prompt_optimization_enabled?) && config.prompt_optimization_enabled?
+          @optimizer = Aidp::PromptOptimization::Optimizer.new(
+            project_dir: project_dir,
+            config: config.prompt_optimization_config
+          )
+        end
       end
 
       # Write content to PROMPT.md
+      # If optimization is enabled, stores the content but doesn't write yet
+      # (use write_optimized instead)
       def write(content)
         File.write(@prompt_path, content)
       end
 
+      # Write optimized prompt using intelligent fragment selection
+      #
+      # Uses Zero Framework Cognition to select only the most relevant fragments
+      # from style guides, templates, and source code based on task context.
+      #
+      # @param task_context [Hash] Context about the current task
+      # @option task_context [Symbol] :task_type Type of task (:feature, :bugfix, etc.)
+      # @option task_context [String] :description Task description
+      # @option task_context [Array<String>] :affected_files Files being modified
+      # @option task_context [String] :step_name Current work loop step
+      # @option task_context [Array<String>] :tags Additional context tags
+      # @param options [Hash] Optimization options
+      # @option options [Boolean] :include_metadata Include debug metadata
+      # @return [Boolean] True if optimization was used, false if fallback to regular write
+      def write_optimized(task_context, options = {})
+        unless @optimizer
+          Aidp.logger.warn("prompt_manager", "Optimization requested but not enabled")
+          return false
+        end
+
+        begin
+          # Use optimizer to build intelligent prompt
+          result = @optimizer.optimize_prompt(
+            task_type: task_context[:task_type],
+            description: task_context[:description],
+            affected_files: task_context[:affected_files] || [],
+            step_name: task_context[:step_name],
+            tags: task_context[:tags] || [],
+            options: options
+          )
+
+          # Write optimized prompt
+          result.write_to_file(@prompt_path)
+
+          # Store statistics for inspection
+          @last_optimization_stats = result.composition_result
+
+          # Log optimization results
+          Aidp.logger.info(
+            "prompt_manager",
+            "Optimized prompt written",
+            selected_fragments: result.composition_result.selected_count,
+            excluded_fragments: result.composition_result.excluded_count,
+            tokens: result.estimated_tokens,
+            budget_utilization: result.composition_result.budget_utilization
+          )
+
+          true
+        rescue => e
+          Aidp.logger.error("prompt_manager", "Optimization failed, using fallback", error: e.message)
+          false
+        end
+      end
+
       # Read content from PROMPT.md
       def read
         return nil unless exists?
@@ -57,6 +128,62 @@ module Aidp
       def path
         @prompt_path
       end
+
+      # Get optimization report for last optimization
+      #
+      # @return [String, nil] Markdown report or nil if no optimization performed
+      def optimization_report
+        return nil unless @last_optimization_stats
+
+        # Build report from composition result
+        lines = []
+        lines << "# Prompt Optimization Report"
+        lines << ""
+        lines << "## Statistics"
+        lines << "- **Selected Fragments**: #{@last_optimization_stats.selected_count}"
+        lines << "- **Excluded Fragments**: #{@last_optimization_stats.excluded_count}"
+        lines << "- **Total Tokens**: #{@last_optimization_stats.total_tokens} / #{@last_optimization_stats.budget}"
+        lines << "- **Budget Utilization**: #{@last_optimization_stats.budget_utilization.round(1)}%"
+        lines << "- **Average Relevance Score**: #{(@last_optimization_stats.average_score * 100).round(1)}%"
+        lines << ""
+        lines << "## Selected Fragments"
+        @last_optimization_stats.selected_fragments.each do |scored|
+          fragment = scored[:fragment]
+          score = scored[:score]
+          lines << "- #{fragment_name(fragment)} (#{(score * 100).round(0)}%)"
+        end
+
+        lines.join("\n")
+      end
+
+      # Check if optimization is enabled
+      #
+      # @return [Boolean] True if optimizer is available
+      def optimization_enabled?
+        !@optimizer.nil?
+      end
+
+      # Get optimizer statistics
+      #
+      # @return [Hash, nil] Statistics hash or nil if optimizer not available
+      def optimizer_stats
+        @optimizer&.statistics
+      end
+
+      private
+
+      # Get human-readable name for a fragment
+      def fragment_name(fragment)
+        if fragment.respond_to?(:heading)
+          fragment.heading
+        elsif fragment.respond_to?(:name)
+          fragment.name
+        elsif fragment.respond_to?(:id)
+          fragment.id
+        else
+          "Unknown fragment"
+        end
+      end
     end
   end
 end