aidp 0.21.1 → 0.23.0

data/lib/aidp/storage/json_storage.rb

@@ -11,7 +11,7 @@ module Aidp
       include Aidp::RescueLogging
 
       def initialize(base_dir = ".aidp")
-        @base_dir = base_dir
+        @base_dir = sanitize_base_dir(base_dir)
         ensure_directory_exists
       end
 
@@ -156,7 +156,46 @@ module Aidp
       end
 
       def ensure_directory_exists
-        FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
+        return if Dir.exist?(@base_dir)
+        begin
+          FileUtils.mkdir_p(@base_dir)
+        rescue SystemCallError => e
+          # Fallback when directory creation fails (e.g., attempting to write to '/.aidp')
+          fallback = begin
+            home = Dir.respond_to?(:home) ? Dir.home : nil
+            if home && !home.empty? && File.writable?(home)
+              File.join(home, ".aidp")
+            else
+              File.join(Dir.tmpdir, "aidp_storage")
+            end
+          rescue
+            File.join(Dir.tmpdir, "aidp_storage")
+          end
+          Kernel.warn "[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}"
+          @base_dir = fallback
+          begin
+            FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
+          rescue SystemCallError => e2
+            Kernel.warn "[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent JSON storage."
+          end
+        end
+      end
+
+      def sanitize_base_dir(dir)
+        return Dir.pwd if dir.nil? || dir.to_s.strip.empty?
+        str = dir.to_s
+        # If given root '/', redirect to a writable location to avoid EACCES on CI
+        if str == File::SEPARATOR
+          fallback = begin
+            home = Dir.home
+            (home && !home.empty? && File.writable?(home)) ? File.join(home, ".aidp") : File.join(Dir.tmpdir, "aidp_storage")
+          rescue
+            File.join(Dir.tmpdir, "aidp_storage")
+          end
+          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          return fallback
+        end
+        str
       end
     end
   end

data/lib/aidp/version.rb

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

data/lib/aidp/watch/build_processor.rb

@@ -15,14 +15,22 @@ module Aidp
     class BuildProcessor
       include Aidp::MessageDisplay
 
-      BUILD_LABEL = "aidp-build"
+      DEFAULT_BUILD_LABEL = "aidp-build"
+      DEFAULT_NEEDS_INPUT_LABEL = "aidp-needs-input"
       IMPLEMENTATION_STEP = "16_IMPLEMENTATION"
 
-      def initialize(repository_client:, state_store:, project_dir: Dir.pwd, use_workstreams: true)
+      attr_reader :build_label, :needs_input_label
+
+      def initialize(repository_client:, state_store:, project_dir: Dir.pwd, use_workstreams: true, verbose: false, label_config: {})
         @repository_client = repository_client
         @state_store = state_store
         @project_dir = project_dir
         @use_workstreams = use_workstreams
+        @verbose = verbose
+
+        # Load label configuration
+        @build_label = label_config[:build_trigger] || label_config["build_trigger"] || DEFAULT_BUILD_LABEL
+        @needs_input_label = label_config[:needs_input] || label_config["needs_input"] || DEFAULT_NEEDS_INPUT_LABEL
       end
 
       def process(issue)
@@ -55,6 +63,8 @@ module Aidp
 
         if result[:status] == "completed"
           handle_success(issue: issue, slug: slug, branch_name: branch_name, base_branch: base_branch, plan_data: plan_data, working_dir: working_dir)
+        elsif result[:status] == "needs_clarification"
+          handle_clarification_request(issue: issue, slug: slug, result: result)
         else
           handle_failure(issue: issue, slug: slug, result: result)
         end
@@ -203,15 +213,33 @@ module Aidp
         prompt_manager = Aidp::Execute::PromptManager.new(working_dir)
         prompt_manager.write(content)
         display_message("📝 Wrote PROMPT.md with implementation contract", type: :info)
+
+        if @verbose
+          display_message("\n--- Implementation Prompt ---", type: :muted)
+          display_message(content.strip, type: :muted)
+          display_message("--- End Prompt ---\n", type: :muted)
+        end
       end
 
       def build_user_input(issue:, plan_data:)
         tasks = Array(plan_value(plan_data, "tasks"))
-        {
+        user_input = {
           "Implementation Contract" => plan_value(plan_data, "summary").to_s,
           "Tasks" => tasks.map { |task| "- #{task}" }.join("\n"),
           "Issue URL" => issue[:url]
         }.delete_if { |_k, v| v.nil? || v.empty? }
+
+        if @verbose
+          display_message("\n--- User Input for Harness ---", type: :muted)
+          user_input.each do |key, value|
+            display_message("#{key}:", type: :muted)
+            display_message(value, type: :muted)
+            display_message("", type: :muted)
+          end
+          display_message("--- End User Input ---\n", type: :muted)
+        end
+
+        user_input
       end
 
       def run_harness(user_input:, working_dir: @project_dir)
@@ -220,8 +248,20 @@ module Aidp
           workflow_type: :watch_mode,
           user_input: user_input
         }
+
+        display_message("🚀 Running harness in execute mode...", type: :info) if @verbose
+
         runner = Aidp::Harness::Runner.new(working_dir, :execute, options)
-        runner.run
+        result = runner.run
+
+        if @verbose
+          display_message("\n--- Harness Result ---", type: :muted)
+          display_message("Status: #{result[:status]}", type: :muted)
+          display_message("Message: #{result[:message]}", type: :muted) if result[:message]
+          display_message("--- End Result ---\n", type: :muted)
+        end
+
+        result
       end
 
       def handle_success(issue:, slug:, branch_name:, base_branch:, plan_data:, working_dir:)
@@ -257,12 +297,62 @@ module Aidp
         )
         display_message("🎉 Posted completion comment for issue ##{issue[:number]}", type: :success)
 
+        # Remove build label after successful completion
+        begin
+          @repository_client.remove_labels(issue[:number], @build_label)
+          display_message("🏷️  Removed '#{@build_label}' label after completion", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to remove build label: #{e.message}", type: :warn)
+          # Don't fail the process if label removal fails
+        end
+
         # Keep workstream for review - don't auto-cleanup on success
         if @use_workstreams
           display_message("ℹ️  Workstream #{slug} preserved for review. Remove with: aidp ws rm #{slug}", type: :muted)
         end
       end
 
+      def handle_clarification_request(issue:, slug:, result:)
+        questions = result[:clarification_questions] || []
+        workstream_note = @use_workstreams ? " The workstream `#{slug}` has been preserved." : " The branch has been preserved."
+
+        # Build comment with questions
+        comment_parts = []
+        comment_parts << "❓ Implementation needs clarification for ##{issue[:number]}."
+        comment_parts << ""
+        comment_parts << "The AI agent needs additional information to proceed with implementation:"
+        comment_parts << ""
+        questions.each_with_index do |question, index|
+          comment_parts << "#{index + 1}. #{question}"
+        end
+        comment_parts << ""
+        comment_parts << "**Next Steps**: Please reply with answers to the questions above. Once resolved, remove the `#{@needs_input_label}` label and add the `#{@build_label}` label to resume implementation."
+        comment_parts << ""
+        comment_parts << workstream_note.to_s
+
+        comment = comment_parts.join("\n")
+        @repository_client.post_comment(issue[:number], comment)
+
+        # Update labels: remove build trigger, add needs input
+        begin
+          @repository_client.replace_labels(
+            issue[:number],
+            old_labels: [@build_label],
+            new_labels: [@needs_input_label]
+          )
+          display_message("🏷️  Updated labels: removed '#{@build_label}', added '#{@needs_input_label}' (needs clarification)", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to update labels for issue ##{issue[:number]}: #{e.message}", type: :warn)
+        end
+
+        @state_store.record_build_status(
+          issue[:number],
+          status: "needs_clarification",
+          details: {questions: questions, workstream: slug}
+        )
+        display_message("💬 Posted clarification request for issue ##{issue[:number]}", type: :success)
+      end
+
       def handle_failure(issue:, slug:, result:)
         message = result[:message] || "Unknown failure"
         workstream_note = @use_workstreams ? " The workstream `#{slug}` has been left intact for debugging." : " The branch has been left intact for debugging."

data/lib/aidp/watch/plan_generator.rb

@@ -26,8 +26,9 @@ module Aidp
         Focus on concrete engineering tasks. Ensure questions are actionable.
       PROMPT
 
-      def initialize(provider_name: nil)
+      def initialize(provider_name: nil, verbose: false)
         @provider_name = provider_name
+        @verbose = verbose
       end
 
       def generate(issue)
@@ -67,7 +68,21 @@ module Aidp
 
       def generate_with_provider(provider, issue)
         payload = build_prompt(issue)
+
+        if @verbose
+          display_message("\n--- Plan Generation Prompt ---", type: :muted)
+          display_message(payload.strip, type: :muted)
+          display_message("--- End Prompt ---\n", type: :muted)
+        end
+
         response = provider.send_message(prompt: payload)
+
+        if @verbose
+          display_message("\n--- Provider Response ---", type: :muted)
+          display_message(response.strip, type: :muted)
+          display_message("--- End Response ---\n", type: :muted)
+        end
+
         parsed = parse_structured_response(response)
 
         return parsed if parsed

data/lib/aidp/watch/plan_processor.rb

@@ -11,13 +11,32 @@ module Aidp
     class PlanProcessor
       include Aidp::MessageDisplay
 
-      PLAN_LABEL = "aidp-plan"
+      # Default label names
+      DEFAULT_PLAN_LABEL = "aidp-plan"
+      DEFAULT_NEEDS_INPUT_LABEL = "aidp-needs-input"
+      DEFAULT_READY_LABEL = "aidp-ready"
+      DEFAULT_BUILD_LABEL = "aidp-build"
+
       COMMENT_HEADER = "## 🤖 AIDP Plan Proposal"
 
-      def initialize(repository_client:, state_store:, plan_generator:)
+      attr_reader :plan_label, :needs_input_label, :ready_label, :build_label
+
+      def initialize(repository_client:, state_store:, plan_generator:, label_config: {})
         @repository_client = repository_client
         @state_store = state_store
         @plan_generator = plan_generator
+
+        # Load label configuration with defaults
+        @plan_label = label_config[:plan_trigger] || label_config["plan_trigger"] || DEFAULT_PLAN_LABEL
+        @needs_input_label = label_config[:needs_input] || label_config["needs_input"] || DEFAULT_NEEDS_INPUT_LABEL
+        @ready_label = label_config[:ready_to_build] || label_config["ready_to_build"] || DEFAULT_READY_LABEL
+        @build_label = label_config[:build_trigger] || label_config["build_trigger"] || DEFAULT_BUILD_LABEL
+      end
+
+      # For backward compatibility
+      def self.plan_label_from_config(config)
+        labels = config[:labels] || config["labels"] || {}
+        labels[:plan_trigger] || labels["plan_trigger"] || DEFAULT_PLAN_LABEL
       end
 
       def process(issue)
@@ -35,14 +54,39 @@ module Aidp
 
         display_message("💬 Posted plan comment for issue ##{number}", type: :success)
         @state_store.record_plan(number, plan_data.merge(comment_body: comment_body, comment_hint: COMMENT_HEADER))
+
+        # Update labels: remove plan trigger, add appropriate status label
+        update_labels_after_plan(number, plan_data)
       end
 
       private
 
+      def update_labels_after_plan(number, plan_data)
+        questions = Array(plan_data[:questions])
+        has_questions = questions.any? && !questions.all? { |q| q.to_s.strip.empty? }
+
+        # Determine which label to add based on whether there are questions
+        new_label = has_questions ? @needs_input_label : @ready_label
+        status_text = has_questions ? "needs input" : "ready to build"
+
+        begin
+          @repository_client.replace_labels(
+            number,
+            old_labels: [@plan_label],
+            new_labels: [new_label]
+          )
+          display_message("🏷️  Updated labels: removed '#{@plan_label}', added '#{new_label}' (#{status_text})", type: :info)
+        rescue => e
+          display_message("⚠️  Failed to update labels for issue ##{number}: #{e.message}", type: :warn)
+          # Don't fail the whole process if label update fails
+        end
+      end
+
       def build_comment(issue:, plan:)
         summary = plan[:summary].to_s.strip
         tasks = Array(plan[:tasks])
         questions = Array(plan[:questions])
+        has_questions = questions.any? && !questions.all? { |q| q.to_s.strip.empty? }
 
         parts = []
         parts << COMMENT_HEADER
@@ -59,7 +103,14 @@ module Aidp
         parts << "### Clarifying Questions"
         parts << format_numbered(questions, placeholder: "_No questions identified_")
         parts << ""
-        parts << "Please reply inline with answers to the questions above. Once the discussion is resolved, apply the `aidp-build` label to begin implementation."
+
+        # Add instructions based on whether there are questions
+        parts << if has_questions
+          "**Next Steps**: Please reply with answers to the questions above. Once resolved, remove the `#{@needs_input_label}` label and add the `#{@build_label}` label to begin implementation."
+        else
+          "**Next Steps**: This plan is ready for implementation. Add the `#{@build_label}` label to begin."
+        end
+
         parts.join("\n")
       end
 

data/lib/aidp/watch/repository_client.rb

@@ -65,6 +65,20 @@ module Aidp
         gh_available? ? create_pull_request_via_gh(title: title, body: body, head: head, base: base, issue_number: issue_number) : raise("GitHub CLI not available - cannot create PR")
       end
 
+      def add_labels(number, *labels)
+        gh_available? ? add_labels_via_gh(number, labels.flatten) : add_labels_via_api(number, labels.flatten)
+      end
+
+      def remove_labels(number, *labels)
+        gh_available? ? remove_labels_via_gh(number, labels.flatten) : remove_labels_via_api(number, labels.flatten)
+      end
+
+      def replace_labels(number, old_labels:, new_labels:)
+        # Remove old labels and add new ones atomically where possible
+        remove_labels(number, *old_labels) unless old_labels.empty?
+        add_labels(number, *new_labels) unless new_labels.empty?
+      end
+
       private
 
       def list_issues_via_gh(labels:, state:)
@@ -180,6 +194,66 @@ module Aidp
         stdout.strip
       end
 
+      def add_labels_via_gh(number, labels)
+        return if labels.empty?
+
+        cmd = ["gh", "issue", "edit", number.to_s, "--repo", full_repo]
+        labels.each { |label| cmd += ["--add-label", label] }
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to add labels via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def add_labels_via_api(number, labels)
+        return if labels.empty?
+
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/labels")
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = JSON.dump({labels: labels})
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "Failed to add labels via API (#{response.code})" unless response.code.start_with?("2")
+        response.body
+      end
+
+      def remove_labels_via_gh(number, labels)
+        return if labels.empty?
+
+        cmd = ["gh", "issue", "edit", number.to_s, "--repo", full_repo]
+        labels.each { |label| cmd += ["--remove-label", label] }
+
+        stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to remove labels via gh: #{stderr.strip}" unless status.success?
+
+        stdout.strip
+      end
+
+      def remove_labels_via_api(number, labels)
+        return if labels.empty?
+
+        labels.each do |label|
+          # URL encode the label name
+          encoded_label = URI.encode_www_form_component(label)
+          uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/labels/#{encoded_label}")
+          request = Net::HTTP::Delete.new(uri)
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+            http.request(request)
+          end
+
+          # 404 is OK - label didn't exist
+          unless response.code.start_with?("2") || response.code == "404"
+            raise "Failed to remove label '#{label}' via API (#{response.code})"
+          end
+        end
+      end
+
       def normalize_issue(raw)
         {
           number: raw["number"],

data/lib/aidp/watch/repository_safety_checker.rb

@@ -163,16 +163,25 @@ module Aidp
       end
 
       def public_repos_allowed?
-        @config.dig(:safety, :allow_public_repos) == true
+        # Support both string and symbol keys
+        safety_config = @config[:safety] || @config["safety"] || {}
+        (safety_config[:allow_public_repos] || safety_config["allow_public_repos"]) == true
       end
 
       def author_allowlist
-        @author_allowlist ||= Array(@config.dig(:safety, :author_allowlist)).compact.map(&:to_s)
+        # Support both string and symbol keys
+        safety_config = @config[:safety] || @config["safety"] || {}
+        @author_allowlist ||= Array(
+          safety_config[:author_allowlist] || safety_config["author_allowlist"]
+        ).compact.map(&:to_s)
       end
 
       def safe_environment?
         # Check if running in a container
-        in_container? || @config.dig(:safety, :require_container) == false
+        # Support both string and symbol keys
+        safety_config = @config[:safety] || @config["safety"] || {}
+        require_container = safety_config[:require_container] || safety_config["require_container"]
+        in_container? || require_container == false
       end
 
       def in_container?

data/lib/aidp/watch/runner.rb

@@ -19,12 +19,13 @@ module Aidp
 
       DEFAULT_INTERVAL = 30
 
-      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, use_workstreams: true, prompt: TTY::Prompt.new, safety_config: {}, force: false)
+      def initialize(issues_url:, interval: DEFAULT_INTERVAL, provider_name: nil, gh_available: nil, project_dir: Dir.pwd, once: false, use_workstreams: true, prompt: TTY::Prompt.new, safety_config: {}, force: false, verbose: false)
         @prompt = prompt
         @interval = interval
         @once = once
         @project_dir = project_dir
         @force = force
+        @verbose = verbose
 
         owner, repo = RepositoryClient.parse_issues_url(issues_url)
         @repository_client = RepositoryClient.new(owner: owner, repo: repo, gh_available: gh_available)
@@ -33,16 +34,23 @@ module Aidp
           config: safety_config
         )
         @state_store = StateStore.new(project_dir: project_dir, repository: "#{owner}/#{repo}")
+
+        # Extract label configuration from safety_config (it's actually the full watch config)
+        label_config = safety_config[:labels] || safety_config["labels"] || {}
+
         @plan_processor = PlanProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
-          plan_generator: PlanGenerator.new(provider_name: provider_name)
+          plan_generator: PlanGenerator.new(provider_name: provider_name, verbose: verbose),
+          label_config: label_config
         )
         @build_processor = BuildProcessor.new(
           repository_client: @repository_client,
           state_store: @state_store,
           project_dir: project_dir,
-          use_workstreams: use_workstreams
+          use_workstreams: use_workstreams,
+          verbose: verbose,
+          label_config: label_config
         )
       end
 
@@ -73,9 +81,10 @@ module Aidp
       end
 
       def process_plan_triggers
-        issues = @repository_client.list_issues(labels: [PlanProcessor::PLAN_LABEL], state: "open")
+        plan_label = @plan_processor.plan_label
+        issues = @repository_client.list_issues(labels: [plan_label], state: "open")
         issues.each do |issue|
-          next unless issue_has_label?(issue, PlanProcessor::PLAN_LABEL)
+          next unless issue_has_label?(issue, plan_label)
 
           detailed = @repository_client.fetch_issue(issue[:number])
 
@@ -89,9 +98,10 @@ module Aidp
       end
 
       def process_build_triggers
-        issues = @repository_client.list_issues(labels: [BuildProcessor::BUILD_LABEL], state: "open")
+        build_label = @build_processor.build_label
+        issues = @repository_client.list_issues(labels: [build_label], state: "open")
         issues.each do |issue|
-          next unless issue_has_label?(issue, BuildProcessor::BUILD_LABEL)
+          next unless issue_has_label?(issue, build_label)
 
           status = @state_store.build_status(issue[:number])
           next if status["status"] == "completed"

data/lib/aidp/workflows/guided_agent.rb

@@ -33,7 +33,6 @@ module Aidp
         @provider_manager = Aidp::Harness::ProviderManager.new(@config_manager, prompt: @prompt)
         @conversation_history = []
         @user_input = {}
-        @invalid_planning_responses = 0
         @verbose = verbose
         @debug_env = ENV["DEBUG"] == "1" || ENV["DEBUG"] == "2"
       end
@@ -138,7 +137,7 @@ module Aidp
         end
 
         response = call_provider_for_analysis(system_prompt, user_prompt)
-        parsed = safe_parse_planning_response(response)
+        parsed = parse_planning_response(response)
         # Attach raw response for debug
         parsed[:raw_response] = response
         emit_verbose_raw_prompt(system_prompt, user_prompt, response)
@@ -378,53 +377,20 @@ module Aidp
         json_match = response_text.match(/```json\s*(\{.*?\})\s*```/m) ||
           response_text.match(/(\{.*\})/m)
 
-        return {error: :invalid_format} unless json_match
-        JSON.parse(json_match[1], symbolize_names: true)
-      rescue JSON::ParserError
-        {error: :invalid_format}
-      end
-
-      # Provides structured fallback sequence when provider keeps returning invalid planning JSON.
-      # After exceeding sequence length, switches to manual entry question.
-      def safe_parse_planning_response(response_text)
-        parsed = parse_planning_response(response_text)
-        return parsed unless parsed.is_a?(Hash) && parsed[:error] == :invalid_format
-
-        @invalid_planning_responses += 1
-        fallback_sequence = [
-          "Provide scope (key features) and primary users.",
-          "List 3-5 key functional requirements and any technical constraints.",
-          "Supply any non-functional requirements (performance/security) or type 'skip'."
-        ]
-
-        if @invalid_planning_responses <= fallback_sequence.size
-          {complete: false, questions: [fallback_sequence[@invalid_planning_responses - 1]], reasoning: "Fallback due to invalid provider response (format)", error: :fallback}
-        else
-          display_message("[ERROR] Provider returned invalid planning JSON #{@invalid_planning_responses} times. Enter combined plan details manually.", type: :error)
-          {complete: false, questions: ["Enter plan details manually (features; users; requirements; constraints) or type 'skip'"], reasoning: "Manual recovery mode", error: :manual_recovery}
+        unless json_match
+          raise ConversationError, "Provider returned invalid format: no JSON found in response"
         end
+
+        JSON.parse(json_match[1], symbolize_names: true)
+      rescue JSON::ParserError => e
+        raise ConversationError, "Provider returned invalid JSON: #{e.message}"
       end
 
       def update_plan_from_answer(plan, question, answer)
         # Simple heuristic-based plan updates
         # In a more sophisticated implementation, use AI to categorize answers
 
-        # IMPORTANT: Check manual recovery sentinel prompt first so it isn't misclassified
-        # by broader keyword heuristics (e.g., it contains the word 'users').
-        if question.start_with?("Enter plan details manually")
-          unless answer.strip.downcase == "skip"
-            parts = answer.split(/;|\|/).map(&:strip).reject(&:empty?)
-            features, users, requirements, constraints = parts
-            plan[:scope][:included] ||= []
-            plan[:scope][:included] << features if features
-            plan[:users][:personas] ||= []
-            plan[:users][:personas] << users if users
-            plan[:requirements][:functional] ||= []
-            plan[:requirements][:functional] << requirements if requirements
-            plan[:constraints][:technical] ||= []
-            plan[:constraints][:technical] << constraints if constraints
-          end
-        elsif question.downcase.include?("scope") || question.downcase.include?("include")
+        if question.downcase.include?("scope") || question.downcase.include?("include")
           plan[:scope][:included] ||= []
           plan[:scope][:included] << answer
         elsif question.downcase.include?("user") || question.downcase.include?("who")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.21.1
+  version: 0.23.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -245,6 +245,7 @@ files:
 - lib/aidp/analyze/tree_sitter_grammar_loader.rb
 - lib/aidp/analyze/tree_sitter_scan.rb
 - lib/aidp/cli.rb
+- lib/aidp/cli/devcontainer_commands.rb
 - lib/aidp/cli/enhanced_input.rb
 - lib/aidp/cli/first_run_wizard.rb
 - lib/aidp/cli/issue_importer.rb
@@ -354,6 +355,11 @@ files:
 - lib/aidp/providers/github_copilot.rb
 - lib/aidp/providers/opencode.rb
 - lib/aidp/rescue_logging.rb
+- lib/aidp/safe_directory.rb
+- lib/aidp/setup/devcontainer/backup_manager.rb
+- lib/aidp/setup/devcontainer/generator.rb
+- lib/aidp/setup/devcontainer/parser.rb
+- lib/aidp/setup/devcontainer/port_manager.rb
 - lib/aidp/setup/wizard.rb
 - lib/aidp/skills.rb
 - lib/aidp/skills/composer.rb