aidp 0.27.0 → 0.28.0

data/lib/aidp/workstream_cleanup.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require_relative "worktree"
+require_relative "workstream_state"
+require "open3"
+require "tty-prompt"
+
+module Aidp
+  # Service for interactively cleaning up inactive workstreams
+  # Displays comprehensive status and prompts user for deletion decisions
+  class WorkstreamCleanup
+    class Error < StandardError; end
+
+    def initialize(project_dir: Dir.pwd, prompt: TTY::Prompt.new)
+      @project_dir = project_dir
+      @prompt = prompt
+    end
+
+    # Run interactive cleanup workflow
+    def run
+      Aidp.log_debug("workstream_cleanup", "start", project_dir: @project_dir)
+
+      workstreams = Aidp::Worktree.list(project_dir: @project_dir)
+
+      if workstreams.empty?
+        @prompt.say("No workstreams found.")
+        Aidp.log_debug("workstream_cleanup", "no_workstreams")
+        return
+      end
+
+      @prompt.say("Found #{workstreams.size} workstream(s)\n")
+
+      workstreams.each do |ws|
+        process_workstream(ws)
+      end
+
+      @prompt.say("\n✓ Cleanup complete")
+      Aidp.log_debug("workstream_cleanup", "complete")
+    end
+
+    private
+
+    def process_workstream(ws)
+      Aidp.log_debug("workstream_cleanup", "process", slug: ws[:slug])
+
+      status = gather_status(ws)
+      display_status(ws, status)
+
+      choice = prompt_action(ws, status)
+      execute_action(ws, choice, status)
+    end
+
+    def gather_status(ws)
+      Aidp.log_debug("workstream_cleanup", "gather_status", slug: ws[:slug])
+
+      status = {
+        exists: ws[:active],
+        state: Aidp::WorkstreamState.read(slug: ws[:slug], project_dir: @project_dir) || {}
+      }
+
+      return status unless status[:exists]
+
+      # Gather git status information
+      Dir.chdir(ws[:path]) do
+        status[:uncommitted_changes] = uncommitted_changes?
+        status[:unpushed_commits] = unpushed_commits?
+        status[:upstream_exists] = upstream_exists?
+        status[:last_commit_date] = last_commit_date
+        status[:behind_upstream] = behind_upstream? if status[:upstream_exists]
+      end
+
+      status
+    end
+
+    def uncommitted_changes?
+      stdout, _stderr, status = Open3.capture3("git", "status", "--porcelain")
+      status.success? && !stdout.strip.empty?
+    end
+
+    def unpushed_commits?
+      # Check if there are commits not in the upstream branch
+      stdout, _stderr, status = Open3.capture3("git", "log", "@{upstream}..", "--oneline")
+      status.success? && !stdout.strip.empty?
+    rescue
+      # If @{upstream} doesn't exist, check for any commits
+      false
+    end
+
+    def upstream_exists?
+      _stdout, _stderr, status = Open3.capture3("git", "rev-parse", "--abbrev-ref", "@{upstream}")
+      status.success?
+    end
+
+    def behind_upstream?
+      stdout, _stderr, status = Open3.capture3("git", "log", "..@{upstream}", "--oneline")
+      status.success? && !stdout.strip.empty?
+    end
+
+    def last_commit_date
+      stdout, _stderr, status = Open3.capture3("git", "log", "-1", "--format=%ci")
+      status.success? ? stdout.strip : nil
+    end
+
+    def display_status(ws, status)
+      @prompt.say("\n" + "=" * 60)
+      @prompt.say("Workstream: #{ws[:slug]}")
+      @prompt.say("=" * 60)
+      @prompt.say("Branch: #{ws[:branch]}")
+      @prompt.say("Created: #{ws[:created_at]}")
+      @prompt.say("Status: #{status[:state][:status] || "unknown"}")
+      @prompt.say("Iterations: #{status[:state][:iterations] || 0}")
+
+      if status[:state][:task]
+        @prompt.say("Task: #{status[:state][:task]}")
+      end
+
+      unless status[:exists]
+        @prompt.say("\n⚠️  Worktree directory does not exist")
+        return
+      end
+
+      # Display git status
+      @prompt.say("\nGit Status:")
+      @prompt.say("  Uncommitted changes: #{status[:uncommitted_changes] ? "Yes" : "No"}")
+
+      if status[:upstream_exists]
+        @prompt.say("  Upstream: exists")
+        @prompt.say("  Unpushed commits: #{status[:unpushed_commits] ? "Yes" : "No"}")
+        @prompt.say("  Behind upstream: #{status[:behind_upstream] ? "Yes" : "No"}")
+      else
+        @prompt.say("  Upstream: none (local branch)")
+      end
+
+      if status[:last_commit_date]
+        @prompt.say("  Last commit: #{status[:last_commit_date]}")
+      end
+    end
+
+    def prompt_action(ws, status)
+      Aidp.log_debug("workstream_cleanup", "prompt_action", slug: ws[:slug])
+
+      choices = build_choices(ws, status)
+      @prompt.select("\nWhat would you like to do?", choices, per_page: 10)
+    end
+
+    def build_choices(ws, status)
+      choices = [
+        {name: "Keep (skip)", value: :keep},
+        {name: "Delete worktree only", value: :delete_worktree}
+      ]
+
+      if status[:exists]
+        choices << if has_risk_factors?(status)
+          {name: "Delete worktree and local branch (has uncommitted/unpushed work!)", value: :delete_all}
+        else
+          {name: "Delete worktree and local branch", value: :delete_all}
+        end
+
+        if status[:upstream_exists]
+          choices << {name: "Delete worktree, local branch, and remote branch", value: :delete_all_remote}
+        end
+      else
+        choices << {name: "Delete registration (worktree already gone)", value: :delete_worktree}
+      end
+
+      choices
+    end
+
+    def has_risk_factors?(status)
+      status[:uncommitted_changes] || status[:unpushed_commits]
+    end
+
+    def execute_action(ws, choice, status)
+      Aidp.log_debug("workstream_cleanup", "execute_action", slug: ws[:slug], action: choice)
+
+      case choice
+      when :keep
+        @prompt.say("Keeping workstream")
+      when :delete_worktree
+        delete_worktree(ws, delete_branch: false)
+      when :delete_all
+        if confirm_deletion(ws, status, remote: false)
+          delete_worktree(ws, delete_branch: true)
+        else
+          @prompt.say("Deletion cancelled")
+        end
+      when :delete_all_remote
+        if confirm_deletion(ws, status, remote: true)
+          delete_remote_branch(ws)
+          delete_worktree(ws, delete_branch: true)
+        else
+          @prompt.say("Deletion cancelled")
+        end
+      end
+    end
+
+    def confirm_deletion(ws, status, remote:)
+      if has_risk_factors?(status)
+        warning = "⚠️  WARNING: This workstream has uncommitted changes or unpushed commits!"
+        @prompt.say("\n#{warning}")
+      end
+
+      message = if remote
+        "Delete worktree, local branch, AND remote branch for '#{ws[:slug]}'?"
+      else
+        "Delete worktree and local branch for '#{ws[:slug]}'?"
+      end
+
+      @prompt.yes?(message)
+    end
+
+    def delete_remote_branch(ws)
+      Aidp.log_debug("workstream_cleanup", "delete_remote_branch", slug: ws[:slug], branch: ws[:branch])
+
+      # Extract remote and branch name
+      # Branch format is typically "aidp/slug", we need to push to origin
+      Dir.chdir(@project_dir) do
+        _, stderr, status = Open3.capture3("git", "push", "origin", "--delete", ws[:branch])
+        if status.success?
+          @prompt.say("✓ Deleted remote branch: #{ws[:branch]}")
+        else
+          @prompt.say("⚠️  Failed to delete remote branch: #{stderr.strip}")
+          Aidp.log_debug("workstream_cleanup", "delete_remote_failed", branch: ws[:branch], error: stderr.strip)
+        end
+      end
+    end
+
+    def delete_worktree(ws, delete_branch:)
+      Aidp.log_debug("workstream_cleanup", "delete_worktree", slug: ws[:slug], delete_branch: delete_branch)
+
+      begin
+        Aidp::Worktree.remove(
+          slug: ws[:slug],
+          project_dir: @project_dir,
+          delete_branch: delete_branch
+        )
+        @prompt.say("✓ Deleted workstream: #{ws[:slug]}")
+        @prompt.say("  Branch deleted") if delete_branch
+      rescue Aidp::Worktree::Error => e
+        @prompt.say("❌ Error: #{e.message}")
+        Aidp.log_error("workstream_cleanup", "delete_failed", slug: ws[:slug], error: e.message)
+      end
+    end
+  end
+end

data/lib/aidp/worktree.rb

@@ -141,6 +141,25 @@ module Aidp
         !info(slug: slug, project_dir: project_dir).nil?
       end
 
+      # Find a worktree by branch name
+      #
+      # @param branch [String] Branch name to search for
+      # @param project_dir [String] Project root directory
+      # @return [Hash, nil] Worktree info or nil if not found
+      def find_by_branch(branch:, project_dir: Dir.pwd)
+        registry = load_registry(project_dir)
+        slug, data = registry.find { |_slug, info| info["branch"] == branch }
+        return nil unless data
+
+        {
+          slug: slug,
+          path: data["path"],
+          branch: data["branch"],
+          created_at: data["created_at"],
+          active: Dir.exist?(data["path"])
+        }
+      end
+
       private
 
       # Ensure we're in a git repository

data/templates/aidp.yml.example

@@ -239,6 +239,25 @@ providers:
         flags: ["--precise"]
         timeout: 900          # 15 minutes
 
+    # Thinking tier model configuration
+    # Maps thinking depth tiers to specific models for this provider
+    thinking_tiers:
+      mini:
+        models:
+          - cursor-fast       # Fast model for simple tasks
+      standard:
+        models:
+          - cursor-default    # Default model for standard tasks
+      thinking:
+        models:
+          - cursor-precise    # Precise model for complex reasoning
+      pro:
+        models:
+          - cursor-precise    # Use best model for pro tier
+      max:
+        models:
+          - cursor-precise    # Use best model for max tier
+
     # Provider features
     features:
       file_upload: true
@@ -343,6 +362,25 @@ providers:
         max_tokens: 200000
         timeout: 600          # 10 minutes
 
+    # Thinking tier model configuration
+    # Maps thinking depth tiers to specific models for this provider
+    thinking_tiers:
+      mini:
+        models:
+          - claude-3-5-haiku-20241022     # Fastest, cheapest model
+      standard:
+        models:
+          - claude-3-5-sonnet-20241022    # Balanced performance
+      thinking:
+        models:
+          - claude-3-5-sonnet-20241022    # Best balance for complex tasks
+      pro:
+        models:
+          - claude-3-opus-20240229        # Most capable model
+      max:
+        models:
+          - claude-3-opus-20240229        # Maximum capability
+
     # Authentication configuration
     auth:
       api_key_env: "ANTHROPIC_API_KEY"  # Environment variable for API key
@@ -394,6 +432,25 @@ providers:
         max_tokens: 30000
         timeout: 300          # 5 minutes
 
+    # Thinking tier model configuration
+    # Maps thinking depth tiers to specific models for this provider
+    thinking_tiers:
+      mini:
+        models:
+          - gemini-1.5-flash      # Fast model for simple tasks
+      standard:
+        models:
+          - gemini-1.5-pro        # Most capable model
+      thinking:
+        models:
+          - gemini-1.5-pro        # Best model for complex reasoning
+      pro:
+        models:
+          - gemini-1.5-pro        # Use best available
+      max:
+        models:
+          - gemini-1.5-pro        # Use best available
+
     # Authentication configuration
     auth:
       api_key_env: "GEMINI_API_KEY"  # Environment variable for API key

data/templates/implementation/generate_tdd_specs.md

@@ -0,0 +1,213 @@
+# Generate TDD Test Specifications
+
+You are creating **test specifications** following Test-Driven Development (TDD) principles.
+
+## TDD Philosophy
+
+### RED → GREEN → REFACTOR
+
+1. **RED**: Write failing tests that specify desired behavior
+2. **GREEN**: Write minimal code to make tests pass
+3. **REFACTOR**: Improve code while keeping tests green
+
+## Context
+
+Read these artifacts to understand requirements:
+
+- `.aidp/docs/PRD.md` - Product requirements (if exists)
+- `.aidp/docs/TECH_DESIGN.md` - Technical design (if exists)
+- `.aidp/docs/TASK_LIST.md` - Task breakdown (if exists)
+- `.aidp/docs/WBS.md` - Work breakdown structure (if exists)
+
+## Your Task
+
+Generate comprehensive test specifications BEFORE implementation.
+
+## Test Specification Structure
+
+Create `docs/tdd_specifications.md`:
+
+```markdown
+# TDD Test Specifications
+
+Generated: <timestamp>
+
+## Overview
+
+This document defines tests to write BEFORE implementing features.
+Follow TDD: write tests first, watch them fail, then implement.
+
+## Test Categories
+
+### Unit Tests
+
+#### Feature: [Feature Name]
+
+**Test Cases:**
+1. **should handle valid input**
+   - Given: Valid input parameters
+   - When: Feature is invoked
+   - Then: Returns expected output
+   - Status: ⭕ Not yet written
+
+2. **should reject invalid input**
+   - Given: Invalid parameters
+   - When: Feature is invoked
+   - Then: Raises appropriate error
+   - Status: ⭕ Not yet written
+
+3. **should handle edge cases**
+   - Given: Edge case inputs (empty, nil, boundary values)
+   - When: Feature is invoked
+   - Then: Handles gracefully
+   - Status: ⭕ Not yet written
+
+### Integration Tests
+
+#### Integration: [Component A + Component B]
+
+**Test Cases:**
+1. **should integrate successfully**
+   - Given: Both components configured
+   - When: Integration point is called
+   - Then: Data flows correctly
+   - Status: ⭕ Not yet written
+
+### Acceptance Tests
+
+#### User Story: [As a user, I want to...]
+
+**Test Cases:**
+1. **should complete user workflow**
+   - Given: User starts workflow
+   - When: User performs actions
+   - Then: Achieves expected outcome
+   - Status: ⭕ Not yet written
+
+## Test Implementation Order
+
+1. **Phase 1: Critical Path**
+   - Write tests for core functionality first
+   - Focus on happy path
+   - Estimated: X hours
+
+2. **Phase 2: Edge Cases**
+   - Add tests for error conditions
+   - Boundary testing
+   - Estimated: Y hours
+
+3. **Phase 3: Integration**
+   - Test component interactions
+   - End-to-end workflows
+   - Estimated: Z hours
+
+## Coverage Goals
+
+- **Unit Tests:** 90%+ coverage
+- **Integration Tests:** All integration points
+- **Acceptance Tests:** All user stories from PRD
+
+## Notes
+
+- Tests should be **fast** (< 1s per test ideal)
+- Tests should be **isolated** (no shared state)
+- Tests should be **deterministic** (same result every time)
+- Mock external dependencies (APIs, databases, file I/O)
+- Test behavior, not implementation
+
+## Next Steps
+
+1. Review this specification
+2. Write tests (they should fail - RED)
+3. Implement minimal code (make tests pass - GREEN)
+4. Refactor code (keep tests green - REFACTOR)
+```
+
+## TDD Best Practices
+
+### 1. Test One Thing
+
+Each test should verify ONE behavior.
+
+❌ BAD: Testing multiple behaviors in one test
+✅ GOOD: Separate tests for separate behaviors
+
+### 2. Use Descriptive Names
+
+Test names should describe the behavior being tested, not implementation details.
+
+### 3. Follow Given-When-Then
+
+Structure tests clearly:
+
+- **GIVEN**: Setup test data and preconditions
+- **WHEN**: Execute the behavior being tested
+- **THEN**: Verify expected outcomes
+
+### 4. Mock External Dependencies
+
+Don't hit real APIs, databases, or file systems in unit tests.
+Use test doubles/mocks for external dependencies.
+
+### 5. Test Behavior, Not Implementation
+
+❌ BAD: Testing that internal helper methods are called
+✅ GOOD: Testing that public interface returns correct results
+
+## Framework-Specific Implementation
+
+**For language/framework-specific test generation, use the appropriate skill:**
+
+- **Ruby/RSpec**: Use `ruby_rspec_tdd` skill for RSpec-specific test files, fixtures, and syntax
+- **Python/pytest**: Use `python_pytest_tdd` skill for pytest-specific implementation
+- **JavaScript/Jest**: Use `javascript_jest_tdd` skill for Jest-specific implementation
+- **Other frameworks**: Use ZFC skill matching to find appropriate testing skill
+
+## Skill Delegation
+
+After creating the language-agnostic test specification above, delegate to the framework-specific skill to generate:
+
+1. **Skeleton test files** in the framework's directory structure and naming conventions
+2. **Test fixtures** or factories in the framework's format
+3. **Test execution commands** for the specific framework
+4. **Framework-specific examples** and best practices
+
+**Example skill invocation:**
+
+For a Ruby project using RSpec:
+
+```text
+Use the `ruby_rspec_tdd` skill to:
+1. Generate skeleton RSpec test files in spec/ directory
+2. Create FactoryBot factories or fixtures as needed
+3. Provide RSpec-specific examples and matchers
+4. Include bundle exec rspec execution commands
+```
+
+For a Python project using pytest:
+
+```text
+Use the `python_pytest_tdd` skill to:
+1. Generate skeleton pytest test files in tests/ directory
+2. Create pytest fixtures as needed
+3. Provide pytest-specific examples and assertions
+4. Include pytest execution commands
+```
+
+## Output Files
+
+Generate:
+
+1. **`docs/tdd_specifications.md`** - Framework-agnostic test specifications (as shown above)
+2. **Framework-specific test files** - Via appropriate skill delegation
+3. **Test data/fixtures** - Via appropriate skill delegation
+
+## Remember
+
+- **Write tests FIRST** - before any implementation
+- **Watch tests FAIL** - ensure they actually test something
+- **Write minimal code** - just enough to pass tests
+- **Refactor** - improve code with confidence (tests protect you)
+- **Use skills for framework-specific implementation** - keep this template language-agnostic
+
+**TDD gives you confidence, better design, and executable documentation!** 🧪

data/templates/implementation/iterative_implementation.md

@@ -0,0 +1,122 @@
+# Iterative Implementation
+
+You are implementing a feature or fix within the AIDP work loop using an iterative, task-based approach.
+
+## Your Mission
+
+{{task_description}}
+
+## Important Instructions
+
+### 1. Break Down the Work
+
+If this is a multi-step feature, **break it into concrete subtasks** using the persistent tasklist:
+
+```text
+File task: "Subtask description here" priority: high|medium|low tags: tag1,tag2
+```
+
+Examples:
+
+```text
+File task: "Add worktree lookup logic to find existing worktrees" priority: high tags: implementation,git
+File task: "Implement worktree creation for PR branches" priority: high tags: implementation,git
+File task: "Add comprehensive logging using Aidp.log_debug" priority: medium tags: observability
+File task: "Add tests for worktree operations" priority: high tags: testing
+```
+
+### 2. Implement One Subtask at a Time
+
+**Focus on completing ONE subtask per iteration.** Keep changes minimal and focused.
+
+- Read the pending tasks from the tasklist
+- Pick the highest priority task that's ready to implement
+- Implement it completely with tests
+- Mark it done: `Update task: task_id_here status: done`
+
+### 3. Request Next Iteration
+
+When you've completed a subtask and there's more work:
+
+```text
+NEXT_UNIT: agentic
+```
+
+This tells the work loop to continue with the next subtask after running tests/linters.
+
+### 4. Track Progress in PROMPT.md
+
+Update this file to:
+
+- Remove completed items
+- Show current status
+- List what remains
+
+### 5. Mark Complete When Done
+
+When ALL work is complete (all subtasks done, tests passing):
+
+```text
+STATUS: COMPLETE
+```
+
+## Completion Criteria
+
+✅ All subtasks filed and completed
+✅ All tests passing
+✅ All linters passing
+✅ Code follows project style guide
+✅ Comprehensive logging added
+✅ STATUS: COMPLETE added to PROMPT.md
+
+## Context
+
+{{additional_context}}
+
+## Best Practices
+
+- **Small iterations**: Better to do 5 small focused iterations than 1 giant one
+- **Test as you go**: Write tests for each subtask before moving on
+- **Use signals**: `File task:`, `Update task:`, `NEXT_UNIT:` keep the system coordinated
+- **Log extensively**: Use `Aidp.log_debug()` at all important code paths
+- **Fail fast**: Let bugs surface early rather than masking with rescues
+
+## Example Flow
+
+Iteration 1:
+
+```text
+File task: "Create WorktreeBranchManager class" priority: high tags: implementation
+File task: "Add worktree lookup logic" priority: high tags: implementation
+File task: "Add tests for WorktreeBranchManager" priority: high tags: testing
+
+[Implement WorktreeBranchManager class with basic structure]
+
+Update task: task_abc123 status: done
+NEXT_UNIT: agentic
+```
+
+Iteration 2:
+
+```text
+[Implement worktree lookup logic]
+
+Update task: task_def456 status: done
+NEXT_UNIT: agentic
+```
+
+Iteration 3:
+
+```text
+[Add comprehensive tests]
+
+Update task: task_ghi789 status: done
+STATUS: COMPLETE
+```
+
+## Notes
+
+- The work loop will automatically run tests/linters after each iteration
+- If tests fail, you'll see the errors in the next iteration - fix them before continuing
+- Use the persistent tasklist to coordinate work across sessions
+- Each iteration should leave the codebase in a working state