aidp 0.39.9 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48e9a4d5c62e99992a0b61d3547b20b2a7598c13dbc6ba8b23a4f8126cd74c35
-  data.tar.gz: 9427e78702251d548a938d5b93f466b9514686128162c4be5bb52eb8375013a0
+  metadata.gz: 2414ec5ab6a21100ba8ccb1d6ae8ddc6bb137a5403b069ff941707c17c9ce9fa
+  data.tar.gz: fb0401b3daf671719690b5c5347418eab335e8090dac38ebe08aef43a921430d
 SHA512:
-  metadata.gz: eb8f0d861f8b85f8df71034a2e6cbef875be34dcf28eacec009aaa65c8589527b904fa060598b43c9854e63c9b354ca0299bb70b96eb5da80e36c19b6ea0a033
-  data.tar.gz: a46a2734b9094b966c242a284b1673cd956df4281294557b813925d19f8204bdf470ad93d4a1c01e27a2846de2b6544258d062f0f36dacd29607827a7bc3049c
+  metadata.gz: c033c034fed453eb4daa2108bb653f3da5007e0d49a792d4a3d9b4f976d63de3c796647da98d3131ea4b81d41425b7aea19ab4e94e743b2eb59936eea9dcad59
+  data.tar.gz: 70ebc3d5e2f809e21398321b7b26c315309a849a35ab4be5742d58650a123a4826c69e64c0b9e8fbc0aef7402da7a99a9970c0d49e83e516aab436e57187d974

data/README.md

@@ -42,6 +42,37 @@ You can re-run the wizard manually:
 aidp --setup-config
 ```
 
+## Run With Docker
+
+Use the standalone Docker image when you want Aidp without a local Ruby
+toolchain. Build the image once, then mount any project into `/workspace`.
+
+```bash
+docker build -t aidp:local .
+
+docker run --rm -it \
+  --env-file .env \
+  -v "$(pwd)":/workspace \
+  -v "$(pwd)/.aidp":/workspace/.aidp \
+  aidp:local
+```
+
+Watch mode uses the same image:
+
+```bash
+docker run --rm -it \
+  --env-file .env \
+  -v "$(pwd)":/workspace \
+  -v "$(pwd)/.aidp":/workspace/.aidp \
+  aidp:local watch https://github.com/<owner>/<repo>/issues
+```
+
+If you supply `GH_TOKEN` or `GITHUB_TOKEN`, the image can use the bundled `gh`
+CLI for read-only access to private repos. Public repositories continue to work
+without GitHub credentials. See [docs/DOCKER_QUICKSTART.md](docs/DOCKER_QUICKSTART.md)
+for environment variables, wrapper scripts, network options, and multi-arch
+`buildx` examples.
+
 ## Devcontainer Support
 
 AIDP provides first-class devcontainer support for sandboxed, secure AI agent execution. Devcontainers offer:
@@ -116,7 +147,7 @@ aidp devcontainer list-backups
 aidp devcontainer restore 0
 ```
 
-See [docs/how-to/DEVELOPMENT_CONTAINER.md](docs/how-to/DEVELOPMENT_CONTAINER.md) for complete devcontainer management documentation.
+See [docs/how-to/DEVELOPMENT_CONTAINER.md](docs/how-to/DEVELOPMENT_CONTAINER.md) for complete devcontainer management documentation. If you do not want VS Code or a local Ruby toolchain, see [Run With Docker](#run-with-docker).
 
 ### Devcontainer Detection
 

data/lib/aidp/cli.rb

@@ -347,6 +347,7 @@ module Aidp
           opts.on("-v", "--version", "Show version information") { options[:version] = true }
           opts.on("--setup-config", "Setup or reconfigure config file") { options[:setup_config] = true }
           opts.on("--verbose", "Show detailed prompts and raw provider responses during guided workflow") { options[:verbose] = true }
+          opts.on("--style STYLE", "Override PRD style for guided planning (detailed, balanced, quick_sketch)") { |style| options[:style] = style }
           opts.on("--quiet", "Suppress non-critical output (incompatible with --verbose and --interactive)") { options[:quiet] = true }
           # Undocumented: Quick exit launch test for CI/CD validation
           opts.on("--launch-test", nil) { options[:launch_test] = true }

data/lib/aidp/harness/config_manager.rb

@@ -10,6 +10,16 @@ module Aidp
     class ConfigManager
       include ProviderTypeChecker
 
+      DEFAULT_PRD_GENERATION = {
+        interaction_style: "balanced",
+        default_style: "balanced",
+        max_question_rounds: {
+          detailed: 30,
+          balanced: 10,
+          quick_sketch: 3
+        }
+      }.freeze
+
       attr_reader :project_dir
 
       def initialize(project_dir = Dir.pwd)
@@ -195,6 +205,24 @@ module Aidp
         }
       end
 
+      def prd_generation_config(options = {})
+        config = config(options)
+        raw_config = config&.dig(:prd_generation) || config&.dig("prd_generation") || {}
+        raw_rounds = raw_config[:max_question_rounds] || raw_config["max_question_rounds"] || {}
+
+        {
+          interaction_style: raw_config[:interaction_style] || raw_config["interaction_style"] || DEFAULT_PRD_GENERATION[:interaction_style],
+          default_style: raw_config[:default_style] || raw_config["default_style"] || DEFAULT_PRD_GENERATION[:default_style],
+          max_question_rounds: DEFAULT_PRD_GENERATION[:max_question_rounds].merge(
+            symbolize_keys(raw_rounds)
+          )
+        }
+      end
+
+      def prd_interaction_style(options = {})
+        prd_generation_config(options)[:interaction_style]
+      end
+
       # Get provider models
       def provider_models(provider_name, options = {})
         provider_config = provider_config(provider_name, options)
@@ -351,6 +379,12 @@ module Aidp
 
       private
 
+      def symbolize_keys(hash)
+        hash.each_with_object({}) do |(key, value), memo|
+          memo[key.to_sym] = value
+        end
+      end
+
       def load_config_with_options(options)
         # Apply different loading strategies based on options
         if options[:mode]

data/lib/aidp/harness/ui/enhanced_workflow_selector.rb

@@ -237,10 +237,12 @@ module Aidp
         def select_guided_workflow
           # Use the guided agent to help user select workflow
           # Don't pass prompt so it uses EnhancedInput with full readline support
-          verbose_flag = (defined?(Aidp::CLI) && Aidp::CLI.respond_to?(:last_options) && Aidp::CLI.last_options) ? Aidp::CLI.last_options[:verbose] : false
+          cli_options = (defined?(Aidp::CLI) && Aidp::CLI.respond_to?(:last_options) && Aidp::CLI.last_options) ? Aidp::CLI.last_options : {}
+          verbose_flag = cli_options[:verbose]
+          interaction_style = cli_options[:style]
           # Fallback: store verbose in an env for easier access if options not available
           verbose = verbose_flag || ENV["AIDP_VERBOSE"] == "1"
-          guided_agent = Aidp::Workflows::GuidedAgent.new(@project_dir, verbose: verbose)
+          guided_agent = Aidp::Workflows::GuidedAgent.new(@project_dir, verbose: verbose, interaction_style: interaction_style)
           result = guided_agent.select_workflow
 
           # Store user input for later use

data/lib/aidp/setup/wizard.rb

@@ -23,6 +23,16 @@ module Aidp
       LEGACY_TIER_ALIASES = {
         advanced: :pro
       }.freeze
+      PRD_STYLE_OPTIONS = {
+        "Detailed - deep questioning, longer sessions" => "detailed",
+        "Balanced - moderate questioning (recommended)" => "balanced",
+        "Quick Sketch - minimal questions, Aidp fills gaps automatically" => "quick_sketch"
+      }.freeze
+      DEFAULT_PRD_QUESTION_ROUNDS = {
+        detailed: 30,
+        balanced: 10,
+        quick_sketch: 3
+      }.freeze
 
       attr_reader :project_dir, :prompt, :dry_run
       # Expose state for testability
@@ -49,6 +59,7 @@ module Aidp
         configure_harness_settings
         configure_thinking_tiers
         configure_work_loop
+        configure_prd_generation
         configure_branching
         configure_artifacts
         configure_nfrs
@@ -492,6 +503,27 @@ module Aidp
         configure_vcs_behavior
       end
 
+      def configure_prd_generation
+        prompt.say("\n🧭 PRD generation style")
+        prompt.say("-" * 40)
+
+        existing = get(%i[prd_generation]) || {}
+        current_style = existing[:interaction_style] || existing[:default_style] || "balanced"
+        default_label = PRD_STYLE_OPTIONS.key(current_style) || PRD_STYLE_OPTIONS.key("balanced")
+
+        selected_style = prompt.select("Choose PRD interaction style:", default: default_label) do |menu|
+          PRD_STYLE_OPTIONS.each do |label, value|
+            menu.choice label, value
+          end
+        end
+
+        set(%i[prd_generation], {
+          interaction_style: selected_style,
+          default_style: selected_style,
+          max_question_rounds: DEFAULT_PRD_QUESTION_ROUNDS
+        })
+      end
+
       # Configure generic deterministic commands for work loop
       # Replaces the old category-specific configure_test_commands and configure_linting
       def configure_commands
@@ -1913,6 +1945,7 @@ module Aidp
           .sub(/^schema_version:/, "# Tracks configuration migrations\nschema_version:")
           .sub(/^providers:/, "# Provider configuration (no secrets stored)\nproviders:")
           .sub(/^work_loop:/, "# Work loop execution settings\nwork_loop:")
+          .sub(/^prd_generation:/, "# PRD questioning depth and autonomy\nprd_generation:")
           .sub(/^nfrs:/, "# Non-functional requirements to reference during planning\nnfrs:")
           .sub(/^logging:/, "# Logging configuration\nlogging:")
           .sub(/^modes:/, "# Defaults for background/watch/quick modes\nmodes:")

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.39.9"
+  VERSION = "0.40.0"
 end

data/lib/aidp/workflows/guided_agent.rb

@@ -19,11 +19,32 @@ module Aidp
 
       class ConversationError < StandardError; end
 
+      PLANNING_STYLES = {
+        "detailed" => {
+          label: "Detailed",
+          max_question_rounds: 30,
+          autonomy: "low",
+          question_strategy: "Ask 1-2 sharply scoped questions per round. Avoid assumptions unless the user confirms them."
+        },
+        "balanced" => {
+          label: "Balanced",
+          max_question_rounds: 10,
+          autonomy: "medium",
+          question_strategy: "Ask 1-3 efficient questions per round. Make reasonable decisions when the context is already clear."
+        },
+        "quick_sketch" => {
+          label: "Quick Sketch",
+          max_question_rounds: 3,
+          autonomy: "high",
+          question_strategy: "Ask only the highest-leverage missing questions. Prefer inferring obvious MVP details from repository context and existing configuration."
+        }
+      }.freeze
+
       # Expose for testability
       attr_reader :project_dir, :conversation_history, :user_input, :config_manager
       attr_writer :provider_manager
 
-      def initialize(project_dir, prompt: nil, use_enhanced_input: true, verbose: false, config_manager: nil, provider_manager: nil)
+      def initialize(project_dir, prompt: nil, use_enhanced_input: true, verbose: false, interaction_style: nil, config_manager: nil, provider_manager: nil)
         @project_dir = project_dir
 
         # Use EnhancedInput with Reline for full readline-style key bindings
@@ -39,6 +60,7 @@ module Aidp
         @user_input = {}
         @verbose = verbose
         @debug_env = debug_level >= Aidp::DebugMixin::DEBUG_BASIC
+        @planning_preferences = resolve_planning_preferences(interaction_style)
       end
 
       # Main entry point for guided workflow selection
@@ -60,6 +82,7 @@ module Aidp
       # Plan-and-execute: iterative planning followed by execution
       def plan_and_execute_workflow
         display_message("\n📋 Plan Phase", type: :highlight)
+        display_message("PRD style: #{planning_style[:interaction_style]}", type: :info)
         display_message("I'll ask clarifying questions to understand your needs.\n", type: :info)
 
         # Step 1: Iterative planning conversation
@@ -77,11 +100,25 @@ module Aidp
 
       def iterative_planning
         goal = user_goal
-        plan = {goal: goal, scope: {}, users: {}, requirements: {}, constraints: {}, completion_criteria: []}
+        plan = {
+          goal: goal,
+          scope: {},
+          users: {},
+          requirements: {},
+          constraints: {},
+          completion_criteria: [],
+          assumptions: [],
+          metadata: {
+            interaction_style: planning_style[:interaction_style],
+            autonomy: planning_style[:autonomy],
+            max_question_rounds: planning_style[:max_question_rounds]
+          }
+        }
 
         @conversation_history << {role: "user", content: goal}
 
         iteration = 0
+        max_rounds = planning_style[:max_question_rounds]
         loop do
           iteration += 1
           # Ask AI for next question based on current plan
@@ -96,6 +133,7 @@ module Aidp
 
           # If AI says plan is complete, confirm with user
           if question_response[:complete]
+            plan[:assumptions].concat(Array(question_response[:assumptions])).uniq!
             display_message("\n✅ Plan Summary", type: :highlight)
             display_plan_summary(plan)
 
@@ -118,14 +156,14 @@ module Aidp
             update_plan_from_answer(plan, question, answer)
           end
 
-          # Guard: break loop after 10 iterations to avoid infinite loop
-          if iteration >= 10
-            display_message("[WARNING] Planning loop exceeded 10 iterations. Provider may be returning generic responses.", type: :warning)
+          if iteration >= max_rounds
+            display_message("[WARNING] Planning loop exceeded #{max_rounds} iterations for #{planning_style[:interaction_style]}.", type: :warning)
             display_message("Continuing with the plan information gathered so far...", type: :info)
             break
           end
         end
 
+        apply_style_assumptions(plan)
         plan
       end
 
@@ -142,6 +180,7 @@ module Aidp
 
         response = call_provider_for_analysis(system_prompt, user_prompt)
         parsed = parse_planning_response(response)
+        parsed[:assumptions] = Array(parsed[:assumptions]).compact
         # Attach raw response for debug
         parsed[:raw_response] = response
         emit_verbose_raw_prompt(system_prompt, user_prompt, response)
@@ -397,16 +436,19 @@ module Aidp
           You are a planning assistant helping gather requirements through clarifying questions.
 
           Your role:
-          1. Ask 1-3 targeted questions at a time based on what's known
+          1. #{planning_style[:question_strategy]}
           2. Build towards a complete understanding of: scope, users, requirements, constraints
           3. Determine when enough information has been gathered
           4. Be concise to preserve context window
+          5. Operate in "#{planning_style[:interaction_style]}" mode with #{planning_style[:autonomy]} autonomy
+          6. When you make an assumption, list it explicitly in "assumptions"
 
           Response Format (JSON):
           {
             "complete": true/false,
             "questions": ["question 1", "question 2"],
-            "reasoning": "brief explanation of what you're trying to learn"
+            "reasoning": "brief explanation of what you're trying to learn",
+            "assumptions": ["assumption 1"]
           }
 
           If complete is true, the plan is ready for execution.
@@ -470,6 +512,28 @@ module Aidp
         end
       end
 
+      def apply_style_assumptions(plan)
+        inferred_assumptions = []
+
+        if plan[:users].empty?
+          plan[:users][:personas] = [default_persona_for_style]
+          inferred_assumptions << "Primary user persona inferred as #{default_persona_for_style}."
+        end
+
+        if plan[:completion_criteria].empty?
+          criterion = default_completion_criterion
+          plan[:completion_criteria] << criterion
+          inferred_assumptions << "Success metric inferred as #{criterion}"
+        end
+
+        inferred_assumptions.concat(repository_default_assumptions)
+        plan[:assumptions].concat(inferred_assumptions).uniq!
+
+        inferred_assumptions.each do |assumption|
+          display_message("Inferred missing detail: #{assumption}", type: :muted)
+        end
+      end
+
       def display_plan_summary(plan)
         display_message("Goal: #{plan[:goal]}", type: :info)
         display_message("\nScope:", type: :highlight) if plan[:scope].any?
@@ -533,6 +597,10 @@ module Aidp
         prd_content = <<~PRD
           # Product Requirements Document
 
+          ## Planning Metadata
+          - PRD Style: #{plan.dig(:metadata, :interaction_style) || planning_style[:interaction_style]}
+          - Agent Autonomy: #{plan.dig(:metadata, :autonomy) || planning_style[:autonomy]}
+
           ## Goal
           #{plan[:goal]}
 
@@ -551,6 +619,9 @@ module Aidp
           ## Completion Criteria
           #{plan[:completion_criteria].map { |c| "- #{c}" }.join("\n")}
 
+          ## Assumptions & Inferred Details
+          #{plan[:assumptions]&.any? ? plan[:assumptions].map { |item| "- #{item}" }.join("\n") : "None"}
+
           ## Additional Context
           #{plan[:additional_context]&.map { |ctx| "**#{ctx[:question]}**: #{ctx[:answer]}" }&.join("\n\n")}
 
@@ -611,6 +682,64 @@ module Aidp
           end
         end.join("\n\n")
       end
+
+      def planning_style
+        @planning_preferences
+      end
+
+      def resolve_planning_preferences(override_style)
+        config = @config_manager.respond_to?(:prd_generation_config) ? @config_manager.prd_generation_config : {}
+        configured_style = override_style || config[:interaction_style] || config["interaction_style"]
+        interaction_style = normalize_interaction_style(configured_style || "balanced")
+        configured_rounds = config[:max_question_rounds] || config["max_question_rounds"] || {}
+        defaults = PLANNING_STYLES.fetch(interaction_style)
+
+        defaults.merge(
+          interaction_style: interaction_style,
+          max_question_rounds: configured_rounds[interaction_style.to_sym] || configured_rounds[interaction_style] || defaults[:max_question_rounds]
+        )
+      end
+
+      def normalize_interaction_style(style)
+        normalized = style.to_s.strip.downcase.tr(" ", "_")
+        return normalized if PLANNING_STYLES.key?(normalized)
+
+        "balanced"
+      end
+
+      def default_persona_for_style
+        if planning_style[:interaction_style] == "quick_sketch"
+          "Prototype users validating the MVP flow"
+        else
+          "Primary end users for this feature"
+        end
+      end
+
+      def default_completion_criterion
+        if planning_style[:interaction_style] == "quick_sketch"
+          "A thin MVP slice is implemented and demoable end-to-end."
+        else
+          "The feature meets the documented requirements and is ready for implementation planning."
+        end
+      end
+
+      def repository_default_assumptions
+        config = @config_manager.respond_to?(:config) ? (@config_manager.config || {}) : {}
+        assumptions = []
+        commands = config.dig(:work_loop, :commands) || config.dig("work_loop", "commands")
+        nfrs = config.dig(:nfrs) || config.dig("nfrs")
+
+        if commands.is_a?(Array) && commands.any?
+          command_label = (commands.size == 1) ? "command" : "commands"
+          assumptions << "Validation will reuse #{commands.size} configured work loop #{command_label}."
+        end
+
+        if nfrs.is_a?(Hash) && nfrs.any?
+          assumptions << "Repository-level non-functional requirements from aidp.yml will apply."
+        end
+
+        assumptions
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.39.9
+  version: 0.40.0
 platform: ruby
 authors:
 - Bart Agapinan