aidp 0.22.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e07daf05fddb6301340e9a01b1c6d8eea60ddcf53b2ec2d56e914be610cd67a7
-  data.tar.gz: 21f26ed81af8f996cbb50c4a4dfe7603230f29499399c134c7a83492042a39e2
+  metadata.gz: e2ec07f1c36212b7ace8e467e098fc3bcd917dc0738e27125bbddcef9bbcc30e
+  data.tar.gz: edbc40f6c50b581729d185186eae3510e8c23885f12655c46868117af361f31a
 SHA512:
-  metadata.gz: 45a1c8c35dbf2f3f672f1990d652c238dd050b3dae3a96edf4d69960475a9e9ee27f1f4ced5ed4a6b0639de6256f56c78d25931e08adacf05ed2aa444e23c9fe
-  data.tar.gz: 85560929fa2c4a1b51a862e8c541ed92d85e51a3c025eede695a5211c7b30b0a2115c098969fbfbb3a7e4237d5d0c074d194f0df0c50b7cdb025a75e7fc9249a
+  metadata.gz: f6472e33b88cf45f0c0abc5131dd608ba20d73480074552275d6d886222357c435023845fa8762b7f527268ba34fc2d3841d504309c8c068adbc38d6ac41f12b
+  data.tar.gz: 4283ba15ee02985603adbdba0be476adec35efc9fa6730a01beef1eac50d068647f3560aa03d75fcdb24ffc102e742bc1c3d9ff53fe95662a20241c711b54ae7

data/README.md

@@ -48,8 +48,8 @@ AIDP provides first-class devcontainer support for sandboxed, secure AI agent ex
 
 - **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
+- **Automatic Management**: AIDP can generate and update your devcontainer configuration
 
 ### For AIDP Development
 
@@ -73,43 +73,54 @@ See [.devcontainer/README.md](.devcontainer/README.md) for complete documentatio
 
 ### Generating Devcontainers for Your Projects
 
-Use `aidp init` to generate a devcontainer for any project:
+AIDP can automatically generate and manage devcontainer configurations through the interactive wizard:
 
 ```bash
-# Initialize project with devcontainer
-aidp init
+# Launch the interactive configuration wizard
+aidp config --interactive
 
-# When prompted:
-# "Generate devcontainer configuration for sandboxed development?" → Yes
+# During the wizard, you'll be asked:
+# - Whether you want AIDP to manage your devcontainer configuration
+# - If you want to add custom ports beyond auto-detected ones
 
-# Or use the flag directly
-aidp init --with-devcontainer
+# The wizard will detect ports based on your project type and generate
+# a complete devcontainer.json configuration
 ```
 
-This creates:
+You can also manage devcontainer configuration manually:
+
+```yaml
+# .aidp/aidp.yml
+devcontainer:
+  manage: true
+  custom_ports:
+    - number: 3000
+      label: "Application Server"
+    - number: 5432
+      label: "PostgreSQL"
+```
 
-- `.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
+Then apply the configuration:
 
-### Elevated Permissions in Devcontainers
+```bash
+# Preview changes
+aidp devcontainer diff
 
-When running inside a devcontainer, you can enable elevated permissions for AI agents:
+# Apply configuration
+aidp devcontainer apply
 
-```yaml
-# aidp.yml
-devcontainer:
-  enabled: true
-  full_permissions_when_in_devcontainer: true  # Run all providers with full permissions
+# List backups
+aidp devcontainer list-backups
 
-  # Or enable per-provider
-  permissions:
-    skip_permission_checks:
-      - claude  # Adds --dangerously-skip-permissions for Claude Code
+# Restore from backup
+aidp devcontainer restore 0
 ```
 
-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.
+See [docs/DEVELOPMENT_CONTAINER.md](docs/DEVELOPMENT_CONTAINER.md) for complete devcontainer management documentation.
+
+### Devcontainer Detection
+
+AIDP automatically detects when it's running inside a devcontainer and adjusts its behavior accordingly. This detection uses multiple heuristics including environment variables, filesystem markers, and cgroup information. See [DevcontainerDetector](lib/aidp/utils/devcontainer_detector.rb) for implementation details.
 
 ## Core Features
 
@@ -190,6 +201,101 @@ aidp ws rm issue-123-fix-auth --delete-branch
 
 See [Workstreams Guide](docs/WORKSTREAMS.md) for detailed usage.
 
+### Watch Mode (Automated GitHub Integration)
+
+AIDP can automatically monitor GitHub repositories and respond to labeled issues, creating plans and executing implementations autonomously:
+
+```bash
+# Start watch mode for a repository
+aidp watch https://github.com/owner/repo/issues
+
+# Optional: specify polling interval, provider, and verbose output
+aidp watch owner/repo --interval 60 --provider claude --verbose
+
+# Run a single cycle (useful for CI/testing)
+aidp watch owner/repo --once
+```
+
+**Label Workflow:**
+
+AIDP uses a smart label-based workflow to manage the lifecycle of automated issue resolution:
+
+1. **Planning Phase** (`aidp-plan` label):
+   - Add this label to an issue to trigger plan generation
+   - AIDP generates an implementation plan with task breakdown and clarifying questions
+   - Posts the plan as a comment on the issue
+   - Automatically removes the `aidp-plan` label
+
+2. **Review & Clarification**:
+   - **If questions exist**: AIDP adds `aidp-needs-input` label and waits for user response
+     - User responds to questions in a comment
+     - User manually removes `aidp-needs-input` and adds `aidp-build` to proceed
+   - **If no questions**: AIDP adds `aidp-ready` label, indicating it's ready to build
+     - User can review the plan before proceeding
+     - User manually adds `aidp-build` label when ready
+
+3. **Implementation Phase** (`aidp-build` label):
+   - Triggers autonomous implementation via work loops
+   - Creates a feature branch and commits changes
+   - Runs tests and linters with automatic fixes
+   - **If clarification needed during implementation**:
+     - Posts clarification questions as a comment
+     - Automatically removes `aidp-build` label and adds `aidp-needs-input`
+     - Preserves work-in-progress for later resumption
+     - User responds to questions, then manually removes `aidp-needs-input` and re-adds `aidp-build`
+   - **On success**:
+     - Posts completion comment with summary
+     - Automatically removes the `aidp-build` label
+
+**Customizable Labels:**
+
+All label names are configurable to match your repository's existing label scheme. Configure via the interactive wizard or manually in `aidp.yml`:
+
+```yaml
+# .aidp/aidp.yml
+watch:
+  labels:
+    plan_trigger: aidp-plan        # Label to trigger plan generation
+    needs_input: aidp-needs-input  # Label when plan needs user input
+    ready_to_build: aidp-ready     # Label when plan is ready to build
+    build_trigger: aidp-build      # Label to trigger implementation
+```
+
+Run `aidp config --interactive` and enable watch mode to configure labels interactively.
+
+**Safety Features:**
+
+- **Public Repository Protection**: Disabled by default for public repos (require explicit opt-in)
+- **Author Allowlist**: Restrict automation to trusted GitHub users only
+- **Container Requirement**: Optionally require sandboxed environment
+- **Force Override**: `--force` flag to bypass safety checks (dangerous!)
+
+**Safety Configuration:**
+
+```yaml
+# .aidp/aidp.yml
+watch:
+  safety:
+    allow_public_repos: true  # Required for public repositories
+    author_allowlist:          # Only these users can trigger automation
+      - trusted-maintainer
+      - team-member
+    require_container: true    # Require devcontainer/Docker environment
+```
+
+Run `aidp config --interactive` and enable watch mode to configure safety settings interactively.
+
+**Clarification Requests:**
+
+AIDP can automatically request clarification when it needs more information during implementation. This works in both watch mode and interactive mode:
+
+- **Watch Mode**: Posts clarification questions as a GitHub comment, updates labels to `aidp-needs-input`, and waits for user response
+- **Interactive Mode**: Prompts the user directly in the terminal to answer questions before continuing
+
+This ensures AIDP never gets stuck - if it needs more information, it will ask for it rather than making incorrect assumptions or failing silently.
+
+See [Watch Mode Guide](docs/FULLY_AUTOMATIC_MODE.md) and [Watch Mode Safety](docs/WATCH_MODE_SAFETY.md) for complete documentation.
+
 ## Command Reference
 
 ### Copilot Mode
@@ -263,6 +369,20 @@ aidp ws rm <slug> --delete-branch  # Also delete git branch
 aidp ws rm <slug> --force          # Skip confirmation
 ```
 
+### Configuration Commands
+
+```bash
+# Interactive configuration wizard (recommended)
+aidp config --interactive       # Configure all settings including watch mode
+
+# Legacy setup wizard
+aidp --setup-config             # Re-run basic setup wizard
+
+# Help and version
+aidp --help                     # Show all commands
+aidp --version                  # Show version
+```
+
 ### System Commands
 
 ```bash
@@ -275,11 +395,6 @@ aidp providers
 # Harness state management
 aidp harness status
 aidp harness reset
-
-# Configuration
-aidp --setup-config             # Re-run setup wizard
-aidp --help                     # Show all commands
-aidp --version                  # Show version
 ```
 
 ## AI Providers
@@ -291,7 +406,6 @@ AIDP intelligently manages multiple providers with automatic switching:
 - **Cursor CLI** - IDE-integrated provider for code-specific tasks
 - **Gemini CLI** - Google's Gemini command-line interface for general tasks
 - **GitHub Copilot CLI** - GitHub's AI pair programmer command-line interface
-- **macOS UI** - macOS-specific UI automation provider
 - **OpenCode** - Alternative open-source code generation provider
 
 The system automatically switches providers when:

data/lib/aidp/cli.rb

@@ -1231,7 +1231,7 @@ module Aidp
 
       def run_watch_command(args)
         if args.empty?
-          display_message("Usage: aidp watch <issues_url> [--interval SECONDS] [--provider NAME] [--once] [--no-workstreams]", type: :info)
+          display_message("Usage: aidp watch <issues_url> [--interval SECONDS] [--provider NAME] [--once] [--no-workstreams] [--force] [--verbose]", type: :info)
           return
         end
 
@@ -1240,6 +1240,8 @@ module Aidp
         provider_name = nil
         once = false
         use_workstreams = true # Default to using workstreams
+        force = false
+        verbose = false
 
         until args.empty?
           token = args.shift
@@ -1253,11 +1255,23 @@ module Aidp
             once = true
           when "--no-workstreams"
             use_workstreams = false
+          when "--force"
+            force = true
+          when "--verbose"
+            verbose = true
           else
             display_message("⚠️  Unknown watch option: #{token}", type: :warn)
           end
         end
 
+        # Initialize logger for watch mode
+        setup_logging(Dir.pwd)
+
+        # Load watch safety configuration
+        config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
+        config = config_manager.config || {}
+        watch_config = config[:watch] || config["watch"] || {}
+
         runner = Aidp::Watch::Runner.new(
           issues_url: issues_url,
           interval: interval.positive? ? interval : Aidp::Watch::Runner::DEFAULT_INTERVAL,
@@ -1265,7 +1279,10 @@ module Aidp
           project_dir: Dir.pwd,
           once: once,
           use_workstreams: use_workstreams,
-          prompt: create_prompt
+          prompt: create_prompt,
+          safety_config: watch_config,
+          force: force,
+          verbose: verbose
         )
         runner.start
       rescue ArgumentError => e

data/lib/aidp/execute/work_loop_runner.rb

@@ -77,7 +77,7 @@ module Aidp
         display_guard_policy_status
         display_pending_tasks
 
-        @unit_scheduler = WorkLoopUnitScheduler.new(units_config)
+        @unit_scheduler = WorkLoopUnitScheduler.new(units_config, project_dir: @project_dir)
         base_context = context.dup
 
         loop do
@@ -97,6 +97,8 @@ module Aidp
 
           agentic_payload = if unit.name == :decide_whats_next
             run_decider_agentic_unit(enriched_context)
+          elsif unit.name == :diagnose_failures
+            run_diagnose_agentic_unit(enriched_context)
           else
             run_primary_agentic_unit(step_spec, enriched_context)
           end
@@ -148,7 +150,27 @@ module Aidp
           transition_to(:ready) unless @current_state == :ready
 
           transition_to(:apply_patch)
-          agent_result = apply_patch
+
+          # Wrap agent call in exception handling for true fix-forward
+          begin
+            agent_result = apply_patch
+          rescue => e
+            # Convert exception to error result for fix-forward handling
+            Aidp.logger.error("work_loop", "Exception during agent call",
+              step: @step_name,
+              iteration: @iteration_count,
+              error: e.message,
+              error_class: e.class.name,
+              backtrace: e.backtrace&.first(5))
+
+            display_message("  ⚠️  Exception during agent call: #{e.class.name}: #{e.message}", type: :error)
+
+            # Append exception to PROMPT.md so agent can see and fix it
+            append_exception_to_prompt(e)
+
+            # Continue to next iteration with fix-forward pattern
+            next
+          end
 
           # Process agent output for task filing signals
           process_task_filing(agent_result)
@@ -223,6 +245,34 @@ module Aidp
         )
       end
 
+      def run_diagnose_agentic_unit(context)
+        Aidp.logger.info("work_loop", "Running diagnose_failures agentic unit", step: @step_name)
+
+        prompt = build_diagnose_prompt(context)
+
+        agent_result = @provider_manager.execute_with_provider(
+          @provider_manager.current_provider,
+          prompt,
+          {
+            step_name: @step_name,
+            iteration: @iteration_count,
+            project_dir: @project_dir,
+            mode: :diagnose_failures
+          }
+        )
+
+        requested = AgentSignalParser.extract_next_unit(agent_result[:output])
+
+        build_agentic_payload(
+          agent_result: agent_result,
+          response: agent_result,
+          summary: agent_result[:output],
+          completed: false,
+          terminate: false,
+          requested_next: requested
+        )
+      end
+
       def units_config
         if @config.respond_to?(:work_loop_units_config)
           @config.work_loop_units_config
@@ -243,41 +293,94 @@ module Aidp
       end
 
       def build_decider_prompt(context)
-        outputs = Array(context[:deterministic_outputs])
-        summary = context[:previous_agent_summary]
-
-        sections = []
-        sections << "# Decide Next Work Loop Unit"
-        sections << ""
-        sections << "You are operating in the Aidp work loop. Determine what should happen next."
-        sections << ""
-        sections << "## Recent Deterministic Outputs"
-
-        if outputs.empty?
-          sections << "- None recorded yet."
-        else
-          outputs.each do |entry|
-            sections << "- #{entry[:name]} (status: #{entry[:status]}, finished_at: #{entry[:finished_at]})"
-            sections << "  Output: #{entry[:output_path] || "n/a"}"
-          end
-        end
+        template = load_work_loop_template("decide_whats_next.md", default_decider_template)
+        replacements = {
+          "{{DETERMINISTIC_OUTPUTS}}" => format_deterministic_outputs(context[:deterministic_outputs]),
+          "{{PREVIOUS_AGENT_SUMMARY}}" => format_previous_agent_summary(context[:previous_agent_summary])
+        }
+        replacements.reduce(template) { |body, (token, value)| body.gsub(token, value) }
+      end
 
-        if summary
-          sections << ""
-          sections << "## Previous Agent Summary"
-          sections << summary
-        end
+      def build_diagnose_prompt(context)
+        template = load_work_loop_template("diagnose_failures.md", default_diagnose_template)
+        replacements = {
+          "{{DETERMINISTIC_OUTPUTS}}" => format_deterministic_outputs(context[:deterministic_outputs]),
+          "{{PREVIOUS_AGENT_SUMMARY}}" => format_previous_agent_summary(context[:previous_agent_summary])
+        }
+        replacements.reduce(template) { |body, (token, value)| body.gsub(token, value) }
+      end
+
+      def load_work_loop_template(relative_path, fallback)
+        template_path = File.join(@project_dir, "templates", "work_loop", relative_path)
+        return File.read(template_path) if File.exist?(template_path)
 
-        sections << ""
-        sections << "## Instructions"
-        sections << "- Decide whether to run another deterministic unit or resume agentic editing."
-        sections << "- Announce your decision with `NEXT_UNIT: <unit_name>`."
-        sections << "- Valid values: names defined in configuration, `agentic`, or `wait_for_github`."
-        sections << "- Provide a concise rationale below."
-        sections << ""
-        sections << "## Rationale"
+        fallback
+      rescue => e
+        Aidp.logger.warn("work_loop", "Unable to load #{relative_path}", error: e.message)
+        fallback
+      end
+
+      def default_decider_template
+        <<~TEMPLATE
+          # Decide Next Work Loop Unit
+
+          ## Deterministic Outputs
+
+          {{DETERMINISTIC_OUTPUTS}}
+
+          ## Previous Agent Summary
+
+          {{PREVIOUS_AGENT_SUMMARY}}
+
+          ## Guidance
+          - Decide whether to run another deterministic unit or resume agentic editing.
+          - Announce your decision with `NEXT_UNIT: <unit_name>`.
+          - Valid values: names defined in configuration, `agentic`, or `wait_for_github`.
+          - Provide a concise rationale below.
 
-        sections.join("\n")
+          ## Rationale
+        TEMPLATE
+      end
+
+      def default_diagnose_template
+        <<~TEMPLATE
+          # Diagnose Failures
+
+          ## Recent Deterministic Outputs
+
+          {{DETERMINISTIC_OUTPUTS}}
+
+          ## Previous Agent Summary
+
+          {{PREVIOUS_AGENT_SUMMARY}}
+
+          ## Instructions
+          - Identify the root cause of the failures above.
+          - Recommend the next concrete action (another deterministic unit, agentic editing, or waiting).
+          - Emit `NEXT_UNIT: <unit_name>` on its own line.
+
+          ## Analysis
+        TEMPLATE
+      end
+
+      def format_deterministic_outputs(entries)
+        data = Array(entries)
+        return "- None recorded yet." if data.empty?
+
+        data.map do |entry|
+          name = entry[:name] || "unknown_unit"
+          status = entry[:status] || "unknown"
+          finished_at = entry[:finished_at]&.to_s || "unknown"
+          output = entry[:output_path] || "n/a"
+          "- #{name} (status: #{status}, finished_at: #{finished_at})\n  Output: #{output}"
+        end.join("\n")
+      end
+
+      def format_previous_agent_summary(summary)
+        content = summary.to_s.strip
+        return "_No previous agent summary._" if content.empty?
+
+        content
       end
 
       # Transition to a new state in the fix-forward state machine
@@ -544,16 +647,50 @@ module Aidp
         prompt_content = @prompt_manager.read
         return {status: "error", message: "PROMPT.md not found"} unless prompt_content
 
-        # Send to provider via provider_manager
-        @provider_manager.execute_with_provider(
-          @provider_manager.current_provider,
-          prompt_content,
-          {
-            step_name: @step_name,
-            iteration: @iteration_count,
-            project_dir: @project_dir
-          }
-        )
+        # Prepend work loop instructions to every iteration
+        full_prompt = build_work_loop_header(@step_name, @iteration_count) + "\n\n" + prompt_content
+
+        # CRITICAL: Change to project directory before calling provider
+        # This ensures Claude CLI runs in the correct directory and can create files
+        Dir.chdir(@project_dir) do
+          # Send to provider via provider_manager
+          @provider_manager.execute_with_provider(
+            @provider_manager.current_provider,
+            full_prompt,
+            {
+              step_name: @step_name,
+              iteration: @iteration_count,
+              project_dir: @project_dir
+            }
+          )
+        end
+      end
+
+      def build_work_loop_header(step_name, iteration)
+        parts = []
+        parts << "# Work Loop: #{step_name} (Iteration #{iteration})"
+        parts << ""
+        parts << "## Instructions"
+        parts << "You are working in a work loop. Your responsibilities:"
+        parts << "1. Read the task description below to understand what needs to be done"
+        parts << "2. **Write/edit code files** to implement the required changes"
+        parts << "3. Run tests to verify your changes work correctly"
+        parts << "4. Update the task list in PROMPT.md as you complete items"
+        parts << "5. When ALL tasks are complete and tests pass, mark the step COMPLETE"
+        parts << ""
+        parts << "## Important Notes"
+        parts << "- You have full file system access - create and edit files as needed"
+        parts << "- The working directory is: #{@project_dir}"
+        parts << "- After you finish, tests and linters will run automatically"
+        parts << "- If tests/linters fail, you'll see the errors in the next iteration and can fix them"
+        parts << ""
+        parts << "## Completion Criteria"
+        parts << "Mark this step COMPLETE by adding this line to PROMPT.md:"
+        parts << "```"
+        parts << "STATUS: COMPLETE"
+        parts << "```"
+        parts << ""
+        parts.join("\n")
       end
 
       def prompt_marked_complete?
@@ -598,6 +735,9 @@ module Aidp
           failures << ""
         end
 
+        strategy = build_failure_strategy(test_results, lint_results)
+        failures.concat(strategy) unless strategy.empty?
+
         failures << "**Fix-forward instructions**: Do not rollback changes. Build on what exists and fix the failures above."
         failures << ""
 
@@ -608,7 +748,48 @@ module Aidp
         updated_prompt = current_prompt + "\n\n---\n\n" + failures.join("\n")
         @prompt_manager.write(updated_prompt, step_name: @step_name)
 
-        display_message("  [NEXT_PATCH] Added failure reports and diagnostic to PROMPT.md", type: :warning)
+        display_message("  [NEXT_PATCH] Added failure reports, strategy, and diagnostic to PROMPT.md", type: :warning)
+      end
+
+      # Append exception details to PROMPT.md for fix-forward handling
+      # This allows the agent to see and fix errors that occur during execution
+      def append_exception_to_prompt(exception)
+        error_report = []
+
+        error_report << "## Fix-Forward Exception in Iteration #{@iteration_count}"
+        error_report << ""
+        error_report << "**CRITICAL**: An exception occurred during this iteration. Please analyze and fix the underlying issue."
+        error_report << ""
+        error_report << "### Exception Details"
+        error_report << "- **Type**: `#{exception.class.name}`"
+        error_report << "- **Message**: #{exception.message}"
+        error_report << ""
+
+        if exception.backtrace && !exception.backtrace.empty?
+          error_report << "### Stack Trace (First 10 lines)"
+          error_report << "```"
+          exception.backtrace.first(10).each do |line|
+            error_report << line
+          end
+          error_report << "```"
+          error_report << ""
+        end
+
+        error_report << "### Required Action"
+        error_report << "1. Analyze the exception type and message"
+        error_report << "2. Review the stack trace to identify the source"
+        error_report << "3. Fix the underlying code issue"
+        error_report << "4. Ensure the fix doesn't break existing functionality"
+        error_report << ""
+        error_report << "**Fix-forward instructions**: Do not rollback changes. Identify the root cause and fix it in the next iteration."
+        error_report << ""
+
+        # Append to PROMPT.md
+        current_prompt = @prompt_manager.read
+        updated_prompt = current_prompt + "\n\n---\n\n" + error_report.join("\n")
+        @prompt_manager.write(updated_prompt, step_name: @step_name)
+
+        display_message("  [EXCEPTION] Added exception details to PROMPT.md for fix-forward", type: :error)
       end
 
       # Check if we should reinject the style guide at this iteration
@@ -651,6 +832,32 @@ module Aidp
         reminder.join("\n")
       end
 
+      def build_failure_strategy(test_results, lint_results)
+        return [] if test_results[:success] && lint_results[:success]
+
+        lines = ["### Recovery Strategy", ""]
+
+        unless test_results[:success]
+          commands = format_command_list(test_results[:failures])
+          lines << "- Re-run #{commands} locally to reproduce the failing specs listed above."
+          lines << "- Triage the exact failures before moving on to new work."
+        end
+
+        unless lint_results[:success]
+          commands = format_command_list(lint_results[:failures])
+          lines << "- Execute #{commands} and fix each reported offense."
+        end
+
+        lines << ""
+        lines
+      end
+
+      def format_command_list(failures)
+        commands = Array(failures).map { |failure| failure[:command] }.compact
+        commands = ["the configured command"] if commands.empty?
+        commands.map { |cmd| "`#{cmd}`" }.join(" or ")
+      end
+
       # Load current step's template content
       def load_current_template
         return nil unless @step_name