aidp 0.43.0 → 0.45.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 013dc044889cc320404776d0691d2091f3cddda0d9ba854dc0afb92312396336
-  data.tar.gz: bb1c57bf8e7d87dfa7d7b169d69646ac76c0cb14fe2f72c70ef02b8543b43494
+  metadata.gz: a86b02df6fbe151abffa67c335c73fc3c724de523065f1f03b083bca305c1c6c
+  data.tar.gz: 15cf32cc8d3007f91e7a94a777e1b32d1a10002a63f91f10721bcf7ffe5c3d04
 SHA512:
-  metadata.gz: c7ea760cd1d62424ada60f64acc356cdf4a82db6e2166c203d9d41c489fed936a704afaee17e9a20d588fbf0ead8ebd816a991a3fa01d87644939c872b104b12
-  data.tar.gz: 9c3b34d7474a2f9e899bf50d9b61d1edcb67a1b4a7b41d78abf810517db8cb2082fe889ec7b1fda5266276b6f1406e577644f2ddca16142bcf66e66e79b1e338
+  metadata.gz: dc49aca1c586e8603be81e229ad3ce42663a5d9592995cc593ed7929c48339542cb67d8b9c3056b429d8409b016c2ddcc4619938f9905666d23a3f0ced1cf006
+  data.tar.gz: 1dac0b372011909722cc0d139bee899b4b968d3041fba11114f7314a9ce5b5a7b8037799b3484e1c03f8587312aae507bad44469c29bbb9b102c6035ad45dea0

data/lib/aidp/config.rb

@@ -197,7 +197,9 @@ module Aidp
         polling_interval: 30,
         labels: {
           plan_trigger: "aidp-plan",
+          project_trigger: "aidp-project",
           build_trigger: "aidp-build",
+          blocked_trigger: "aidp-blocked",
           review_trigger: "aidp-review",
           fix_ci_trigger: "aidp-fix-ci",
           change_request_trigger: "aidp-request-changes",
@@ -213,10 +215,17 @@ module Aidp
             priority: "Priority",
             skills: "Skills",
             personas: "Personas",
-            blocking: "Blocking"
+            blocking: "Blocking",
+            start_date: "Start Date",
+            target_date: "Target Date",
+            dependencies: "Dependencies",
+            critical_path: "Critical Path"
           },
           auto_create_fields: true,
           sync_interval: 60,
+          prd_path: nil,
+          auto_sync_gantt: false,
+          gantt_format: "auto",
           default_status_values: ["Backlog", "Todo", "In Progress", "In Review", "Done"],
           default_priority_values: ["Low", "Medium", "High", "Critical"]
         },
@@ -510,6 +519,11 @@ module Aidp
         merged[:security] = deep_merge_hash(merged[:security], symbolize_keys(security_section))
       end
 
+      if config[:watch] || config["watch"]
+        watch_section = config[:watch] || config["watch"]
+        merged[:watch] = deep_merge_hash(merged[:watch], symbolize_keys(watch_section))
+      end
+
       merged
     end
 

data/lib/aidp/setup/wizard.rb

@@ -1649,6 +1649,11 @@ module Aidp
           existing[:plan_trigger] || "aidp-plan"
         )
 
+        project_trigger = ask_with_default(
+          "Label to trigger project planning",
+          existing[:project_trigger] || "aidp-project"
+        )
+
         needs_input = ask_with_default(
           "Label for plans needing user input",
           existing[:needs_input] || "aidp-needs-input"
@@ -1664,6 +1669,11 @@ module Aidp
           existing[:build_trigger] || "aidp-build"
         )
 
+        blocked_trigger = ask_with_default(
+          "Label for blocked project sub-issues",
+          existing[:blocked_trigger] || "aidp-blocked"
+        )
+
         review_trigger = ask_with_default(
           "Label to trigger code review",
           existing[:review_trigger] || "aidp-review"
@@ -1686,9 +1696,11 @@ module Aidp
 
         set(%i[watch labels], {
           plan_trigger: plan_trigger,
+          project_trigger: project_trigger,
           needs_input: needs_input,
           ready_to_build: ready_to_build,
           build_trigger: build_trigger,
+          blocked_trigger: blocked_trigger,
           review_trigger: review_trigger,
           ci_fix_trigger: ci_fix_trigger,
           auto_trigger: auto_trigger,
@@ -1856,9 +1868,11 @@ module Aidp
       def collect_required_labels(labels_config)
         default_colors = {
           plan_trigger: "0E8A16",        # Green
+          project_trigger: "0052CC",     # Deep blue
           needs_input: "D93F0B",         # Red
           ready_to_build: "0075CA",      # Blue
           build_trigger: "5319E7",       # Purple
+          blocked_trigger: "B60205",     # Dark red
           review_trigger: "FBCA04",      # Yellow
           ci_fix_trigger: "D93F0B",      # Red
           auto_trigger: "0C8BD6",        # Blue (distinct from build)

data/lib/aidp/version.rb

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

data/lib/aidp/watch/gantt_synchronizer.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Aidp
+  module Watch
+    # Synchronizes parsed Gantt task data with GitHub Projects and Mermaid docs.
+    class GanttSynchronizer
+      CRITICAL_PATH_VALUES = %w[Yes No].freeze
+
+      def initialize(repository_client:, state_store:, project_id:, field_mappings:, auto_create_fields: true, parser_class: PrdParser)
+        @repository_client = repository_client
+        @state_store = state_store
+        @project_id = project_id
+        @field_mappings = field_mappings
+        @auto_create_fields = auto_create_fields
+        @parser_class = parser_class
+        @project_fields_cache = nil
+      end
+
+      def sync_from_prd(prd_path:, format: nil, issue_numbers_by_title: {})
+        parsed = @parser_class.new(file_path: prd_path, format: format).parse
+        tasks = resolve_issue_numbers(parsed[:tasks], issue_numbers_by_title)
+        critical_path = calculate_critical_path(tasks)
+        tasks_by_id = tasks.each_with_object({}) { |task, memo| memo[task[:id]] = task }
+
+        synced = 0
+        skipped = 0
+
+        tasks.each do |task|
+          if task[:issue_number].nil?
+            skipped += 1
+            next
+          end
+
+          item_id = ensure_project_item(task[:issue_number])
+          update_date_fields(item_id, task)
+          update_dependencies_field(item_id, task, tasks_by_id)
+          update_critical_path_field(item_id, critical_path.include?(task[:id]))
+
+          @state_store.record_project_sync(task[:issue_number], {
+            gantt_task_id: task[:id],
+            gantt_path: prd_path,
+            gantt_format: parsed[:format].to_s,
+            critical_path: critical_path.include?(task[:id])
+          })
+          synced += 1
+        end
+
+        {synced: synced, skipped: skipped, critical_path: critical_path}
+      end
+
+      def sync_issue_status_to_gantt(prd_path:, issue_number:, status:, format: nil)
+        parser = @parser_class.new(file_path: prd_path, format: format)
+        parsed = parser.parse
+        return false unless parsed[:format] == :mermaid
+
+        content = File.read(prd_path)
+        lines = content.lines
+        line_index = mermaid_task_line_index(content, parsed[:tasks], issue_number)
+        return false unless line_index
+
+        lines[line_index] = rewrite_mermaid_status(lines[line_index], status)
+        File.write(prd_path, lines.join)
+        true
+      end
+
+      private
+
+      def resolve_issue_numbers(tasks, issue_numbers_by_title)
+        tasks.map do |task|
+          next task if task[:issue_number]
+
+          resolved_issue_number = issue_numbers_by_title[normalize_title(task[:name])]
+          resolved_issue_number ? task.merge(issue_number: resolved_issue_number) : task
+        end
+      end
+
+      def calculate_critical_path(tasks)
+        explicit = tasks.select { |task| task[:critical] }.map { |task| task[:id] }
+        return explicit if explicit.any?
+
+        durations = tasks.each_with_object({}) { |task, memo| memo[task[:id]] = task[:duration_days].to_i }
+        predecessors = tasks.each_with_object({}) { |task, memo| memo[task[:id]] = task[:dependency_ids] }
+        longest = {}
+        previous = {}
+
+        ordered_ids(tasks, predecessors).each do |task_id|
+          best_predecessor = predecessors[task_id].max_by { |candidate| longest[candidate].to_i }
+          longest[task_id] = durations[task_id] + longest[best_predecessor].to_i
+          previous[task_id] = best_predecessor
+        end
+
+        endpoint = longest.max_by { |_task_id, distance| distance }&.first
+        unwind_path(endpoint, previous)
+      end
+
+      def ordered_ids(tasks, predecessors)
+        task_ids = tasks.map { |task| task[:id] }
+        ordered = []
+        remaining = task_ids.dup
+
+        until remaining.empty?
+          progressed = false
+          remaining.dup.each do |task_id|
+            unmet = predecessors[task_id].reject { |dependency| ordered.include?(dependency) }
+            next if unmet.any?
+
+            ordered << task_id
+            remaining.delete(task_id)
+            progressed = true
+          end
+
+          break unless progressed
+        end
+
+        ordered + remaining
+      end
+
+      def unwind_path(endpoint, previous)
+        path = []
+        current = endpoint
+
+        while current
+          path.unshift(current)
+          current = previous[current]
+        end
+
+        path
+      end
+
+      def ensure_project_item(issue_number)
+        item_id = @state_store.project_item_id(issue_number)
+        return item_id if item_id
+
+        item_id = @repository_client.link_issue_to_project(@project_id, issue_number)
+        @state_store.record_project_item_id(issue_number, item_id)
+        item_id
+      end
+
+      def update_date_fields(item_id, task)
+        update_date_field(item_id, @field_mappings[:start_date], task[:start_date])
+        update_date_field(item_id, @field_mappings[:target_date], task[:end_date] || task[:start_date])
+      end
+
+      def update_date_field(item_id, field_name, date)
+        return unless field_name && date
+
+        field = find_or_create_field(field_name, "DATE")
+        return unless field
+
+        @repository_client.update_project_item_field(
+          item_id,
+          field[:id],
+          {project_id: @project_id, date: date.iso8601}
+        )
+      end
+
+      def update_dependencies_field(item_id, task, tasks_by_id)
+        field_name = @field_mappings[:dependencies]
+        return unless field_name
+
+        dependency_issue_numbers = task[:dependency_ids].filter_map do |dependency_id|
+          tasks_by_id[dependency_id]&.dig(:issue_number)
+        end
+        field = find_or_create_field(field_name, "TEXT")
+        return unless field
+
+        text = dependency_issue_numbers.map { |issue_number| "##{issue_number}" }.join(", ")
+        @repository_client.update_project_item_field(
+          item_id,
+          field[:id],
+          {project_id: @project_id, text: text}
+        )
+      end
+
+      def update_critical_path_field(item_id, critical)
+        field_name = @field_mappings[:critical_path]
+        return unless field_name
+
+        field = find_or_create_field(field_name, "SINGLE_SELECT", CRITICAL_PATH_VALUES)
+        return unless field
+
+        option_id = field[:options]&.find { |option| option[:name].casecmp?(critical ? "Yes" : "No") }&.dig(:id)
+        return unless option_id
+
+        @repository_client.update_project_item_field(
+          item_id,
+          field[:id],
+          {project_id: @project_id, option_id: option_id}
+        )
+      end
+
+      def rewrite_mermaid_status(line, status)
+        match = line.match(/\A(?<name_part>.*?)(?<separator>\s*:\s*)(?<definition>.*?)(?<newline>\r?\n?)\z/)
+        return line unless match
+
+        mapped_status = mermaid_status_for(status)
+
+        tokens = match[:definition].split(",").map(&:strip).reject(&:empty?)
+        tokens.reject! { |token| %w[done active].include?(token) }
+
+        tokens.unshift(mapped_status) if mapped_status
+
+        "#{match[:name_part]}#{match[:separator]}#{tokens.join(", ")}#{match[:newline]}"
+      end
+
+      def mermaid_status_for(status)
+        case status.to_s.downcase
+        when "done", "closed", "completed" then "done"
+        when "in progress", "in_progress", "active" then "active"
+        end
+      end
+
+      def mermaid_task_line_index(content, tasks, issue_number)
+        line_number = find_mermaid_task(tasks, issue_number)&.dig(:line_number)
+        return unless line_number
+
+        line_number + mermaid_chart_line_offset(content) - 1
+      end
+
+      def mermaid_chart_line_offset(content)
+        lines = content.lines
+        mermaid_start = lines.each_index.find do |index|
+          mermaid_gantt_block?(lines, index)
+        end
+        mermaid_start ? mermaid_start + 1 : 0
+      end
+
+      def find_mermaid_task(tasks, issue_number)
+        sync_data = @state_store.project_sync_data(issue_number)
+        gantt_task_id = sync_data["gantt_task_id"]
+
+        tasks.find { |task| task[:id] == gantt_task_id } ||
+          tasks.find { |task| task[:issue_number] == issue_number }
+      end
+
+      def mermaid_gantt_block?(lines, start_index)
+        return false unless lines[start_index].match?(/\A```mermaid\b/)
+
+        block_lines = lines[(start_index + 1)..]
+        return false unless block_lines
+
+        block_lines.take_while { |line| !line.match?(/\A\s*```\s*$/) }.any? do |line|
+          line.strip == "gantt"
+        end
+      end
+
+      def normalize_title(title)
+        title.to_s.gsub(/\s*\(#\d+\)\s*/, " ").strip.downcase
+      end
+
+      def project_fields
+        @project_fields_cache ||= @repository_client.fetch_project_fields(@project_id)
+      end
+
+      def invalidate_fields_cache
+        @project_fields_cache = nil
+      end
+
+      def find_or_create_field(name, field_type, options = nil)
+        field = project_fields.find { |entry| entry[:name].casecmp?(name) }
+        return field if field
+        return nil unless @auto_create_fields
+
+        formatted_options = options&.map { |option| {name: option} } if field_type == "SINGLE_SELECT"
+        field = @repository_client.create_project_field(@project_id, name, field_type, options: formatted_options)
+        invalidate_fields_cache
+        field
+      end
+    end
+  end
+end

data/lib/aidp/watch/plan_generator.rb

@@ -27,7 +27,7 @@ module Aidp
       PROMPT
 
       HIERARCHICAL_PROVIDER_PROMPT = <<~PROMPT
-        You are AIDP's planning specialist for large projects. Read the GitHub issue and existing comments.
+        You are AIDP's project planning specialist for large projects. Read the GitHub issue and existing comments.
         This is a LARGE project that should be broken down into independent sub-issues.
 
         Analyze the requirements and break them into logical sub-tasks that can be worked on independently.
@@ -59,6 +59,7 @@ module Aidp
         - Sub-issues should be sized for 1-3 days of work
         - Include 3-8 sub-issues for a large project
         - Be specific about skills needed (avoid generic terms)
+        - Prefer leaf-node tasks first so dependency order is explicit and mechanically executable
         - Only create sub-issues if the project truly warrants it (complexity, multiple components, etc.)
       PROMPT