aidp 0.17.1 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 949670fdea4721406643f4fd8da096e943740effbd836407311b812350919b14
-  data.tar.gz: 8034a3c798571e4626b273c4a9abe9a5da38cef5dd4f25de8794a0ef63bf6022
+  metadata.gz: 220c03eda20360cfa8b954bc578b15fe766742e849037539f1a1f9c794310569
+  data.tar.gz: 0fa8cc7ff18ab1ee66c11f187df4554f84504d4713322f089427b9d921de5420
 SHA512:
-  metadata.gz: cdabc6ba04d06a89dbc4ad19b27a64862e960daa350029db4fada5a4f6d32d3fba27cb32dda291871a79ad8f319d27e7dd1348ddcb7fdb8b0f0a1390b9493fc1
-  data.tar.gz: 39c384f4c01bf00bef550ac9190d27ddd268437be92fc4cdfcdeac3dff09c79c055b2e5b5582e553af6fa838b3f904cce354e9db62ee3638f658eec05673e4f5
+  metadata.gz: 772f8bc2099fce5b1d8ff0c9d8567382281851b7d3a283eb0aa847ad92d5f420b9aff91c702424df89cf6570cc59cfe35dacc8baf7df60b0d019cd1dfc97ceea
+  data.tar.gz: 1bad64d70c87752e7416bbad5558ff9cab2e67902b2e461bbd1ad946a4659951949ea4f6c0642a2424d81a6119e405f9208647e5d7c229d13626fc9f0774bae7

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

@@ -51,8 +51,11 @@ module Aidp
           interrupt: :exit
         )
 
-        # Read line with full readline support (Ctrl-A, Ctrl-E, Ctrl-W, etc.)
-        result = reader.read_line(prompt, default: default || "")
+        # TTY::Reader#read_line does not support a :default keyword; we emulate fallback
+        result = reader.read_line(prompt)
+        if (result.nil? || result.chomp.empty?) && !default.nil?
+          return default
+        end
         result&.chomp
       rescue TTY::Reader::InputInterrupt
         raise Interrupt

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

@@ -16,6 +16,26 @@ module Aidp
         nil
       end
 
+      # Parse task filing signals from agent output
+      # Returns array of task hashes with description, priority, and tags
+      def self.parse_task_filing(output)
+        return [] unless output
+
+        tasks = []
+        # Pattern: File task: "description" [priority: high|medium|low] [tags: tag1,tag2]
+        pattern = /File\s+task:\s*"([^"]+)"(?:\s+priority:\s*(high|medium|low))?(?:\s+tags:\s*([^\s]+))?/i
+
+        output.to_s.scan(pattern).each do |description, priority, tags|
+          tasks << {
+            description: description.strip,
+            priority: (priority || "medium").downcase.to_sym,
+            tags: tags ? tags.split(",").map(&:strip) : []
+          }
+        end
+
+        tasks
+      end
+
       def self.normalize_token(raw)
         return nil if raw.nil? || raw.empty?
 

data/lib/aidp/execute/persistent_tasklist.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "securerandom"
+require "fileutils"
+
+module Aidp
+  module Execute
+    # Task struct for persistent tasklist entries
+    Task = Struct.new(
+      :id,
+      :description,
+      :status,
+      :priority,
+      :created_at,
+      :updated_at,
+      :session,
+      :discovered_during,
+      :started_at,
+      :completed_at,
+      :abandoned_at,
+      :abandoned_reason,
+      :tags,
+      keyword_init: true
+    ) do
+      def to_h
+        super.compact
+      end
+    end
+
+    # Persistent tasklist for tracking tasks across sessions
+    # Uses append-only JSONL format for git-friendly storage
+    class PersistentTasklist
+      attr_reader :project_dir, :file_path
+
+      class TaskNotFoundError < StandardError; end
+      class InvalidTaskError < StandardError; end
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+        @file_path = File.join(project_dir, ".aidp", "tasklist.jsonl")
+        ensure_file_exists
+      end
+
+      # Create a new task
+      def create(description, priority: :medium, session: nil, discovered_during: nil, tags: [])
+        validate_description!(description)
+        validate_priority!(priority)
+
+        task = Task.new(
+          id: generate_id,
+          description: description.strip,
+          status: :pending,
+          priority: priority,
+          created_at: Time.now,
+          updated_at: Time.now,
+          session: session,
+          discovered_during: discovered_during,
+          tags: Array(tags)
+        )
+
+        append_task(task)
+        Aidp.log_debug("tasklist", "Created task", task_id: task.id, description: task.description)
+        task
+      end
+
+      # Update task status
+      def update_status(task_id, new_status, reason: nil)
+        validate_status!(new_status)
+        task = find(task_id)
+        raise TaskNotFoundError, "Task not found: #{task_id}" unless task
+
+        task.status = new_status
+        task.updated_at = Time.now
+
+        case new_status
+        when :in_progress
+          task.started_at ||= Time.now
+        when :done
+          task.completed_at = Time.now
+        when :abandoned
+          task.abandoned_at = Time.now
+          task.abandoned_reason = reason
+        end
+
+        append_task(task)
+        Aidp.log_debug("tasklist", "Updated task status", task_id: task.id, status: new_status)
+        task
+      end
+
+      # Query tasks with optional filters
+      def all(status: nil, priority: nil, since: nil, tags: nil)
+        tasks = load_latest_tasks
+
+        tasks = tasks.select { |t| t.status == status } if status
+        tasks = tasks.select { |t| t.priority == priority } if priority
+        tasks = tasks.select { |t| t.created_at >= since } if since
+        tasks = tasks.select { |t| (Array(t.tags) & Array(tags)).any? } if tags && !tags.empty?
+
+        tasks.sort_by(&:created_at).reverse
+      end
+
+      # Find single task by ID
+      def find(task_id)
+        all.find { |t| t.id == task_id }
+      end
+
+      # Query pending tasks (common operation)
+      def pending
+        all(status: :pending)
+      end
+
+      # Query in-progress tasks
+      def in_progress
+        all(status: :in_progress)
+      end
+
+      # Count tasks by status
+      def counts
+        tasks = load_latest_tasks
+        {
+          total: tasks.size,
+          pending: tasks.count { |t| t.status == :pending },
+          in_progress: tasks.count { |t| t.status == :in_progress },
+          done: tasks.count { |t| t.status == :done },
+          abandoned: tasks.count { |t| t.status == :abandoned }
+        }
+      end
+
+      private
+
+      VALID_STATUSES = [:pending, :in_progress, :done, :abandoned].freeze
+      VALID_PRIORITIES = [:high, :medium, :low].freeze
+
+      def append_task(task)
+        File.open(@file_path, "a") do |f|
+          f.puts serialize_task(task)
+        end
+      end
+
+      def load_latest_tasks
+        return [] unless File.exist?(@file_path)
+
+        tasks_by_id = {}
+
+        File.readlines(@file_path).each_with_index do |line, index|
+          next if line.strip.empty?
+
+          begin
+            data = JSON.parse(line.strip, symbolize_names: true)
+            task = deserialize_task(data)
+            tasks_by_id[task.id] = task
+          rescue JSON::ParserError => e
+            Aidp.log_warn("tasklist", "Skipping malformed JSONL line", line_number: index + 1, error: e.message)
+            next
+          rescue => e
+            Aidp.log_warn("tasklist", "Error loading task", line_number: index + 1, error: e.message)
+            next
+          end
+        end
+
+        tasks_by_id.values
+      end
+
+      def serialize_task(task)
+        hash = task.to_h
+        # Convert Time objects to ISO8601 strings
+        hash[:created_at] = hash[:created_at].iso8601 if hash[:created_at]
+        hash[:updated_at] = hash[:updated_at].iso8601 if hash[:updated_at]
+        hash[:started_at] = hash[:started_at].iso8601 if hash[:started_at]
+        hash[:completed_at] = hash[:completed_at].iso8601 if hash[:completed_at]
+        hash[:abandoned_at] = hash[:abandoned_at].iso8601 if hash[:abandoned_at]
+        JSON.generate(hash)
+      end
+
+      def deserialize_task(data)
+        Task.new(**data.merge(
+          status: data[:status]&.to_sym,
+          priority: data[:priority]&.to_sym,
+          created_at: parse_time(data[:created_at]),
+          updated_at: parse_time(data[:updated_at]),
+          started_at: parse_time(data[:started_at]),
+          completed_at: parse_time(data[:completed_at]),
+          abandoned_at: parse_time(data[:abandoned_at]),
+          tags: Array(data[:tags])
+        ))
+      end
+
+      def parse_time(time_string)
+        return nil if time_string.nil?
+        Time.parse(time_string)
+      rescue ArgumentError
+        nil
+      end
+
+      def generate_id
+        "task_#{Time.now.to_i}_#{SecureRandom.hex(4)}"
+      end
+
+      def ensure_file_exists
+        FileUtils.mkdir_p(File.dirname(@file_path))
+        FileUtils.touch(@file_path) unless File.exist?(@file_path)
+      end
+
+      def validate_description!(description)
+        raise InvalidTaskError, "Description cannot be empty" if description.nil? || description.strip.empty?
+        raise InvalidTaskError, "Description too long (max 200 chars)" if description.length > 200
+      end
+
+      def validate_priority!(priority)
+        raise InvalidTaskError, "Invalid priority: #{priority}" unless VALID_PRIORITIES.include?(priority)
+      end
+
+      def validate_status!(status)
+        raise InvalidTaskError, "Invalid status: #{status}" unless VALID_STATUSES.include?(status)
+      end
+    end
+  end
+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