aidp 0.43.0 → 0.45.0

data/lib/aidp/watch/repository_client.rb

@@ -303,11 +303,35 @@ module Aidp
         create_project_field_via_gh(project_id, name, field_type, options: options)
       end
 
+      def create_project(title:, repository_id: nil)
+        raise "GitHub CLI not available - Projects API requires gh CLI" unless gh_available?
+        create_project_via_gh(title: title, repository_id: repository_id)
+      end
+
+      def find_active_project
+        raise "GitHub CLI not available - Projects API requires gh CLI" unless gh_available?
+        find_active_project_via_gh
+      end
+
+      def repository_node_data
+        raise "GitHub CLI not available - Projects API requires gh CLI" unless gh_available?
+        repository_node_data_via_gh
+      end
+
       def create_issue(title:, body:, labels: [], assignees: [])
         raise "GitHub CLI not available - cannot create issue" unless gh_available?
         create_issue_via_gh(title: title, body: body, labels: labels, assignees: assignees)
       end
 
+      def close_issue(number)
+        raise "GitHub CLI not available - cannot close issue" unless gh_available?
+        close_issue_via_gh(number)
+      end
+
+      def update_issue(number, title:, body:, labels:, assignees:)
+        gh_available? ? update_issue_via_gh(number, title: title, body: body, labels: labels, assignees: assignees) : update_issue_via_api(number, title: title, body: body, labels: labels, assignees: assignees)
+      end
+
       def merge_pull_request(number, merge_method: "squash")
         raise "GitHub CLI not available - cannot merge PR" unless gh_available?
         merge_pull_request_via_gh(number, merge_method: merge_method)
@@ -430,6 +454,47 @@ module Aidp
         end
       end
 
+      def update_issue_via_gh(number, title:, body:, labels:, assignees:)
+        with_gh_retry("update_issue") do
+          existing_issue = fetch_issue_via_gh(number)
+          cmd = ["gh", "issue", "edit", number.to_s, "--repo", full_repo, "--title", title, "--body", body]
+
+          label_changes(existing_issue[:labels], labels).each do |flag, values|
+            values.each { |value| cmd.concat([flag, value]) }
+          end
+
+          assignee_changes(existing_issue[:assignees], assignees).each do |flag, values|
+            values.each { |value| cmd.concat([flag, value]) }
+          end
+
+          _stdout, stderr, status = Open3.capture3(*cmd)
+          raise "Failed to update issue via gh: #{stderr.strip}" unless status.success?
+
+          true
+        end
+      end
+
+      def update_issue_via_api(number, title:, body:, labels:, assignees:)
+        uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}")
+        request = Net::HTTP::Patch.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/vnd.github.v3+json"
+        request.body = JSON.dump({
+          title: title,
+          body: body,
+          labels: labels,
+          assignees: assignees
+        })
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        raise "GitHub API issue update failed (#{response.code})" unless response.code.start_with?("2")
+
+        true
+      end
+
       def post_comment_via_api(number, body)
         uri = URI("https://api.github.com/repos/#{full_repo}/issues/#{number}/comments")
         request = Net::HTTP::Post.new(uri)
@@ -1358,6 +1423,20 @@ module Aidp
         end
       end
 
+      def label_changes(existing_labels, next_labels)
+        {
+          "--remove-label" => Array(existing_labels) - Array(next_labels),
+          "--add-label" => Array(next_labels) - Array(existing_labels)
+        }
+      end
+
+      def assignee_changes(existing_assignees, next_assignees)
+        {
+          "--remove-assignee" => Array(existing_assignees) - Array(next_assignees),
+          "--add-assignee" => Array(next_assignees) - Array(existing_assignees)
+        }
+      end
+
       def normalize_pr_comment(raw)
         {
           id: raw["id"],
@@ -1565,6 +1644,21 @@ module Aidp
               }
             }
           GRAPHQL
+        elsif value.is_a?(Hash) && value[:date]
+          <<~GRAPHQL
+            mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $date: Date!) {
+              updateProjectV2ItemFieldValue(input: {
+                projectId: $projectId
+                itemId: $itemId
+                fieldId: $fieldId
+                value: {date: $date}
+              }) {
+                projectV2Item {
+                  id
+                }
+              }
+            }
+          GRAPHQL
         else
           # Text field
           <<~GRAPHQL
@@ -1596,8 +1690,10 @@ module Aidp
 
         if value.is_a?(Hash) && value[:option_id]
           variables[:optionId] = value[:option_id]
+        elsif value.is_a?(Hash) && value[:date]
+          variables[:date] = value[:date]
         else
-          variables[:text] = value.to_s
+          variables[:text] = value.is_a?(Hash) ? value[:text].to_s : value.to_s
         end
 
         result = execute_graphql_query(mutation, **variables)
@@ -1716,6 +1812,105 @@ module Aidp
         raise
       end
 
+      def repository_node_data_via_gh
+        Aidp.log_debug("repository_client", "repository_node_data", repo: full_repo)
+
+        query = <<~GRAPHQL
+          query($owner: String!, $repo: String!) {
+            repository(owner: $owner, name: $repo) {
+              id
+              owner {
+                __typename
+                login
+                ... on Organization {
+                  id
+                }
+                ... on User {
+                  id
+                }
+              }
+            }
+          }
+        GRAPHQL
+
+        result = execute_graphql_query(query, owner: owner, repo: repo)
+        repo_data = result.dig("data", "repository")
+        raise "Repository not found: #{full_repo}" unless repo_data
+
+        {
+          repository_id: repo_data["id"],
+          owner_id: repo_data.dig("owner", "id"),
+          owner_login: repo_data.dig("owner", "login"),
+          owner_type: repo_data.dig("owner", "__typename")
+        }
+      rescue => e
+        Aidp.log_error("repository_client", "repository_node_data_failed", repo: full_repo, error: e.message)
+        raise
+      end
+
+      def create_project_via_gh(title:, repository_id: nil)
+        owner_data = repository_node_data_via_gh
+
+        mutation = <<~GRAPHQL
+          mutation($ownerId: ID!, $title: String!, $repositoryId: ID) {
+            createProjectV2(input: {
+              ownerId: $ownerId
+              title: $title
+              repositoryId: $repositoryId
+            }) {
+              projectV2 {
+                id
+                title
+                number
+                url
+              }
+            }
+          }
+        GRAPHQL
+
+        result = execute_graphql_query(
+          mutation,
+          ownerId: owner_data[:owner_id],
+          title: title,
+          repositoryId: repository_id || owner_data[:repository_id]
+        )
+        project_data = result.dig("data", "createProjectV2", "projectV2")
+        raise "Failed to create project: #{title}" unless project_data
+
+        normalize_project(project_data)
+      rescue => e
+        Aidp.log_error("repository_client", "create_project_failed", repo: full_repo, title: title, error: e.message)
+        raise
+      end
+
+      def find_active_project_via_gh
+        Aidp.log_debug("repository_client", "find_active_project", repo: full_repo)
+
+        query = <<~GRAPHQL
+          query($owner: String!, $repo: String!) {
+            repository(owner: $owner, name: $repo) {
+              projectsV2(first: 20, orderBy: {field: UPDATED_AT, direction: DESC}) {
+                nodes {
+                  id
+                  title
+                  number
+                  url
+                  closed
+                }
+              }
+            }
+          }
+        GRAPHQL
+
+        result = execute_graphql_query(query, owner: owner, repo: repo)
+        projects = Array(result.dig("data", "repository", "projectsV2", "nodes"))
+        active_project = projects.find { |project| !project["closed"] }
+        normalize_project(active_project) if active_project
+      rescue => e
+        Aidp.log_error("repository_client", "find_active_project_failed", repo: full_repo, error: e.message)
+        raise
+      end
+
       def create_issue_via_gh(title:, body:, labels: [], assignees: [])
         Aidp.log_debug("repository_client", "create_issue", title: title, label_count: labels.size, assignee_count: assignees.size)
 
@@ -1737,6 +1932,19 @@ module Aidp
         raise
       end
 
+      def close_issue_via_gh(number)
+        Aidp.log_debug("repository_client", "close_issue", issue_number: number)
+
+        cmd = ["gh", "issue", "close", number.to_s, "--repo", full_repo]
+        _stdout, stderr, status = Open3.capture3(*cmd)
+        raise "Failed to close issue via gh: #{stderr.strip}" unless status.success?
+
+        Aidp.log_debug("repository_client", "close_issue_complete", issue_number: number)
+      rescue => e
+        Aidp.log_error("repository_client", "Failed to close issue", issue_number: number, error: e.message)
+        raise
+      end
+
       def merge_pull_request_via_gh(number, merge_method: "squash")
         Aidp.log_debug("repository_client", "merge_pull_request", number: number, merge_method: merge_method)
 
@@ -1785,11 +1993,14 @@ module Aidp
       end
 
       def normalize_project(raw)
+        return nil unless raw
+
         {
           id: raw["id"],
           title: raw["title"],
           number: raw["number"],
           url: raw["url"],
+          closed: raw["closed"],
           fields: Array(raw.dig("fields", "nodes")).map { |field| normalize_project_field(field) }
         }
       end

data/lib/aidp/watch/runner.rb

@@ -3,6 +3,7 @@
 require "tty-prompt"
 require_relative "feedback_collector"
 require_relative "github_state_extractor"
+require_relative "projects_processor"
 require_relative "round_robin_scheduler"
 require_relative "work_item"
 require_relative "worktree_cleanup_job"
@@ -43,6 +44,7 @@ module Aidp
 
         # Extract label configuration from safety_config (it's actually the full watch config)
         label_config = safety_config[:labels] || safety_config["labels"] || {}
+        @project_config = safety_config[:projects] || safety_config["projects"] || {}
 
         # Extract detection comment configuration (issue #280)
         # Enabled by default, can be disabled in config
@@ -58,7 +60,8 @@ module Aidp
           repository_client: @repository_client,
           state_store: @state_store,
           plan_generator: PlanGenerator.new(provider_name: provider_name, verbose: verbose),
-          label_config: label_config
+          label_config: label_config,
+          project_config: @project_config
         )
         @build_processor = BuildProcessor.new(
           repository_client: @repository_client,
@@ -269,7 +272,7 @@ module Aidp
         # Dispatch to processor
         case item.processor_type
         when :plan
-          @plan_processor.process(detailed)
+          @plan_processor.process(detailed, trigger_label: item.label)
         when :build
           # Check build completion at dispatch time (moved from collection for API efficiency)
           if @state_extractor.build_completed?(detailed)
@@ -336,6 +339,7 @@ module Aidp
         items = []
 
         items.concat(collect_plan_work_items)
+        items.concat(collect_project_work_items)
         items.concat(collect_build_work_items)
         items.concat(collect_auto_issue_work_items)
         items.concat(collect_review_work_items)
@@ -353,10 +357,12 @@ module Aidp
       # @return [Array<WorkItem>]
       def collect_plan_work_items
         label = @plan_processor.plan_label
+        project_label = @plan_processor.project_label
         issues = @repository_client.list_issues(labels: [label], state: "open")
 
         issues.filter_map do |issue|
           next unless issue_has_label?(issue, label)
+          next if issue_has_label?(issue, project_label)
 
           WorkItem.new(
             number: issue[:number],
@@ -371,30 +377,56 @@ module Aidp
         []
       end
 
-      # Collect work items for build triggers.
-      # @return [Array<WorkItem>]
-      def collect_build_work_items
-        label = @build_processor.build_label
+      def collect_project_work_items
+        label = @plan_processor.project_label
         issues = @repository_client.list_issues(labels: [label], state: "open")
 
         issues.filter_map do |issue|
           next unless issue_has_label?(issue, label)
 
-          # Note: build_completed check moved to dispatch phase to avoid
-          # API calls during collection (addresses rate limiting concerns)
           WorkItem.new(
             number: issue[:number],
             item_type: :issue,
-            processor_type: :build,
+            processor_type: :plan,
             label: label,
             data: issue
           )
         end
+      rescue => e
+        Aidp.log_error("watch_runner", "collect_project_items_failed", error: e.message)
+        []
+      end
+
+      # Collect work items for build triggers.
+      # @return [Array<WorkItem>]
+      def collect_build_work_items
+        unblock_dependency_ready_items
+
+        standard_build_work_items + ready_project_work_items
       rescue => e
         Aidp.log_error("watch_runner", "collect_build_items_failed", error: e.message)
         []
       end
 
+      def unblock_dependency_ready_items
+        blocked_label = @plan_processor.blocked_label
+        blocked_issues = @repository_client.list_issues(labels: [blocked_label], state: "open")
+
+        blocked_issues.each do |issue|
+          next unless issue_has_label?(issue, blocked_label)
+          next unless dependencies_met_for_issue?(issue[:number])
+
+          @repository_client.replace_labels(
+            issue[:number],
+            old_labels: [blocked_label],
+            new_labels: [unblocked_label_for(issue[:number])]
+          )
+          sync_project_status_for_unblocked_issue(issue[:number])
+        end
+      rescue => e
+        Aidp.log_error("watch_runner", "unblock_dependency_ready_items_failed", error: e.message)
+      end
+
       # Collect work items for auto issue triggers.
       # @return [Array<WorkItem>]
       def collect_auto_issue_work_items
@@ -529,6 +561,82 @@ module Aidp
         end
       end
 
+      def standard_build_work_items
+        label = @build_processor.build_label
+        project_label = @plan_processor.project_label
+        issues = @repository_client.list_issues(labels: [label], state: "open")
+
+        issues.filter_map do |issue|
+          next unless issue_has_label?(issue, label)
+          next if issue_has_label?(issue, project_label)
+
+          build_work_item_for(issue, label: label)
+        end
+      end
+
+      def ready_project_work_items
+        label = @plan_processor.ready_label
+        issues = @repository_client.list_issues(labels: [label], state: "open")
+
+        issues.filter_map do |issue|
+          next unless issue_has_label?(issue, label)
+          next unless @state_store.sub_issues(issue[:number]).any?
+
+          build_work_item_for(issue, label: label)
+        end
+      end
+
+      def build_work_item_for(issue, label:)
+        # Note: build_completed check moved to dispatch phase to avoid
+        # API calls during collection (addresses rate limiting concerns)
+        WorkItem.new(
+          number: issue[:number],
+          item_type: :issue,
+          processor_type: :build,
+          label: label,
+          data: issue
+        )
+      end
+
+      def dependencies_met_for_issue?(issue_number)
+        blocking_status = @state_store.blocking_status(issue_number)
+        return false unless blocking_status[:blocked]
+
+        blocking_status[:blockers].all? do |blocker_number|
+          blocker = @repository_client.fetch_issue(blocker_number)
+          blocker[:state].to_s.casecmp("closed").zero?
+        end
+      rescue => e
+        Aidp.log_warn("watch_runner", "dependency_check_failed",
+          issue: issue_number, error: e.message)
+        false
+      end
+
+      def unblocked_label_for(issue_number)
+        return @plan_processor.ready_label if @state_store.sub_issues(issue_number).any?
+
+        @build_processor.build_label
+      end
+
+      def sync_project_status_for_unblocked_issue(issue_number)
+        project_id = @state_store.project_sync_data(issue_number)["project_id"]
+        return unless project_id
+
+        projects_processor = ProjectsProcessor.new(
+          repository_client: @repository_client,
+          state_store: @state_store,
+          project_id: project_id,
+          config: @project_config
+        )
+        return if projects_processor.sync_issue_to_project(issue_number, status: ProjectsProcessor::STATUS_VALUES[:todo])
+
+        Aidp.log_warn("watch_runner", "project_status_sync_failed",
+          issue: issue_number, project_id: project_id)
+      rescue => e
+        Aidp.log_warn("watch_runner", "project_status_sync_failed",
+          issue: issue_number, project_id: project_id, error: e.message)
+      end
+
       # Restore from checkpoint if one exists (after auto-update)
       def restore_from_checkpoint_if_exists
         return unless @auto_update_coordinator.policy.enabled

data/lib/aidp/watch/state_store.rb

@@ -373,6 +373,7 @@ module Aidp
 
       def record_sub_issues(parent_number, sub_issue_numbers)
         hierarchies[parent_number.to_s] ||= {}
+        clear_stale_sub_issue_tracking(parent_number, Array(sub_issue_numbers))
         hierarchies[parent_number.to_s]["sub_issues"] = Array(sub_issue_numbers)
         hierarchies[parent_number.to_s]["created_at"] = Time.now.utc.iso8601
 
@@ -385,8 +386,47 @@ module Aidp
         save!
       end
 
+      def clear_sub_issues(parent_number)
+        record_sub_issues(parent_number, [])
+      end
+
+      def issue_dependencies(issue_number)
+        Array(hierarchies[issue_number.to_s]&.dig("dependencies"))
+      end
+
+      def record_issue_dependencies(issue_number, dependency_numbers)
+        hierarchies[issue_number.to_s] ||= {}
+        hierarchies[issue_number.to_s]["dependencies"] = Array(dependency_numbers)
+        hierarchies[issue_number.to_s]["dependencies_updated_at"] = Time.now.utc.iso8601
+        save!
+      end
+
+      private
+
+      def clear_stale_sub_issue_tracking(parent_number, next_sub_issue_numbers)
+        stale_numbers = sub_issues(parent_number) - next_sub_issue_numbers
+        stale_numbers.each do |sub_number|
+          hierarchy = hierarchies[sub_number.to_s]
+          next unless hierarchy
+
+          hierarchy.delete("parent")
+          hierarchy.delete("dependencies")
+          hierarchy.delete("dependencies_updated_at")
+        end
+      end
+
+      public
+
       def blocking_status(issue_number)
-        # Check if this issue is blocked by any open sub-issues
+        dependency_numbers = issue_dependencies(issue_number)
+        if dependency_numbers.any?
+          return {
+            blocked: true,
+            blockers: dependency_numbers,
+            blocker_count: dependency_numbers.size
+          }
+        end
+
         sub_issue_numbers = sub_issues(issue_number)
         return {blocked: false, blockers: []} if sub_issue_numbers.empty?