ace-task 0.31.9 → 0.36.7

data/lib/ace/task/cli.rb

@@ -10,6 +10,7 @@ require_relative "cli/commands/update"
 require_relative "cli/commands/doctor"
 require_relative "cli/commands/status"
 require_relative "cli/commands/plan"
+require_relative "cli/commands/github_sync"
 
 module Ace
   module Task
@@ -26,7 +27,8 @@ module Ace
         ["update", "Update task metadata (fields, move, reparent)"],
         ["doctor", "Run health checks on tasks"],
         ["status", "Show task status overview"],
-        ["plan", "Resolve or generate implementation plan"]
+        ["plan", "Resolve or generate implementation plan"],
+        ["github-sync", "Sync linked GitHub issues for task(s)"]
       ].freeze
 
       HELP_EXAMPLES = [
@@ -45,7 +47,9 @@ module Ace
         "ace-task status --up-next-limit 5",
         "ace-task plan q7w",
         "ace-task plan q7w --refresh",
-        "ace-task plan q7w --content"
+        "ace-task plan q7w --content",
+        "ace-task github-sync q7w",
+        "ace-task github-sync --all"
       ].freeze
 
       register "create", CLI::Commands::Create
@@ -55,6 +59,7 @@ module Ace
       register "doctor", CLI::Commands::Doctor
       register "status", CLI::Commands::Status
       register "plan", CLI::Commands::Plan
+      register "github-sync", CLI::Commands::GithubSync
 
       version_cmd = Ace::Support::Cli::VersionCommand.build(
         gem_name: "ace-task",

data/lib/ace/task/molecules/github_issue_sync_adapter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Ace
+  module Task
+    module Molecules
+      # Bridges ace-task lifecycle events to reusable ace-git issue sync primitives.
+      class GithubIssueSyncAdapter
+        UNAVAILABLE_MESSAGE = "GitHub issue sync primitives are unavailable. " \
+          "Complete dependency task 8r4.t.ilo.2 or update ace-git."
+
+        CANDIDATE_INTEGRATIONS = [
+          ["Ace::Git::Molecules::GithubIssueSync", :validate_link!],
+          ["Ace::Git::Molecules::IssueSync", :validate_link!],
+          ["Ace::Git::Molecules::GithubIssueSync", :sync_task],
+          ["Ace::Git::Molecules::IssueSync", :sync_task]
+        ].freeze
+
+        def validate_link!(issue_id:, previous_task: nil)
+          return unless issue_id.to_i.positive?
+
+          receiver, method_name = resolve_integration(:validate_link!)
+          raise UNAVAILABLE_MESSAGE unless receiver && method_name
+
+          receiver.public_send(
+            method_name,
+            issue_id: issue_id.to_i,
+            task_id: previous_task&.id,
+            previous_task_id: previous_task&.id
+          )
+        end
+
+        def sync_task(task:, reason:, previous_task: nil)
+          current_issue_ids = [task.metadata["github_issue"]].compact.map(&:to_i).uniq
+          previous_issue_ids = [previous_task&.metadata&.[]("github_issue")].compact.map(&:to_i).uniq
+          issue_ids = (current_issue_ids + previous_issue_ids).uniq
+          return {synced: 0, issues: []} if issue_ids.empty?
+
+          receiver, method_name = resolve_integration(:sync_task)
+          raise UNAVAILABLE_MESSAGE unless receiver && method_name
+
+          payload = {
+            task_id: task.id,
+            task_title: task.title,
+            task_status: task.status,
+            task_path: task.file_path || task.path,
+            issue_ids: issue_ids,
+            current_issue_ids: current_issue_ids,
+            reason: reason,
+            previous: previous_task ? {
+              id: previous_task.id,
+              title: previous_task.title,
+              status: previous_task.status,
+              path: previous_task.file_path || previous_task.path
+            } : nil
+          }
+          receiver.public_send(method_name, **payload)
+          {synced: issue_ids.length, issues: issue_ids}
+        end
+
+        private
+
+        def resolve_integration(expected_method = nil)
+          CANDIDATE_INTEGRATIONS.each do |constant_name, method_name|
+            next if expected_method && method_name != expected_method
+
+            klass = constant_name.split("::").reject(&:empty?).inject(Object) { |ctx, name| ctx.const_get(name) }
+            return [klass, method_name] if klass.respond_to?(method_name)
+          rescue NameError
+            next
+          end
+
+          [nil, nil]
+        end
+      end
+    end
+  end
+end

data/lib/ace/task/molecules/subtask_creator.rb

@@ -32,7 +32,16 @@ module Ace
         # @param time [Time] Creation time (default: now)
         # @return [Models::Task] Created subtask
         # @raise [RangeError] If parent already has 36 subtasks
-        def create(parent_task, title, status: nil, priority: nil, tags: [], time: Time.now.utc, estimate: nil)
+        def create(
+          parent_task,
+          title,
+          status: nil,
+          priority: nil,
+          tags: [],
+          time: Time.now.utc,
+          estimate: nil,
+          github_issue: nil
+        )
           raise ArgumentError, "Title is required" if title.nil? || title.strip.empty?
 
           # Find next available subtask character
@@ -60,7 +69,8 @@ module Ace
             tags: tags,
             created_at: time,
             parent: parent_task.id,
-            estimate: estimate
+            estimate: estimate,
+            github_issue: github_issue
           )
 
           # Write spec file

data/lib/ace/task/molecules/task_creator.rb

@@ -13,6 +13,8 @@ module Ace
       # Generates folder structure and spec file with full frontmatter.
       # Optionally uses LLM for slug generation with deterministic fallback.
       class TaskCreator
+        class IdCollisionError < StandardError; end
+
         # @param root_dir [String] Root directory for tasks
         # @param config [Hash] Configuration hash
         def initialize(root_dir:, config: {})
@@ -29,52 +31,90 @@ module Ace
         # @param time [Time] Creation time (default: now)
         # @param use_llm_slug [Boolean] Whether to attempt LLM slug generation
         # @return [Models::Task] Created task
-        def create(title, status: nil, priority: nil, tags: [], dependencies: [], time: Time.now.utc, use_llm_slug: false, estimate: nil)
+        def create(
+          title,
+          status: nil,
+          priority: nil,
+          tags: [],
+          dependencies: [],
+          time: Time.now.utc,
+          use_llm_slug: false,
+          estimate: nil,
+          github_issue: nil
+        )
           raise ArgumentError, "Title is required" if title.nil? || title.strip.empty?
 
           # Generate task ID
           item_id = Atoms::TaskIdFormatter.generate(time)
           formatted_id = item_id.formatted_id
 
-          # Generate slugs
-          slugs = if use_llm_slug
-            generate_llm_slugs(title) || generate_slugs(title)
-          else
-            generate_slugs(title)
+          with_id_reservation(formatted_id) do
+            raise IdCollisionError, "Task ID collision detected for #{formatted_id}" if task_id_exists?(formatted_id)
+
+            # Generate slugs
+            slugs = if use_llm_slug
+              generate_llm_slugs(title) || generate_slugs(title)
+            else
+              generate_slugs(title)
+            end
+            folder_slug = slugs[:folder]
+            file_slug = slugs[:file]
+
+            # Create folder with folder_slug
+            folder_name = Atoms::TaskIdFormatter.folder_name(formatted_id, folder_slug)
+            task_dir = File.join(@root_dir, folder_name)
+            FileUtils.mkdir_p(task_dir)
+
+            begin
+              # Build frontmatter with all fields
+              effective_status = status || @config.dig("task", "default_status") || "pending"
+              frontmatter = Atoms::TaskFrontmatterDefaults.build(
+                id: formatted_id,
+                status: effective_status,
+                priority: priority,
+                tags: tags,
+                dependencies: dependencies,
+                created_at: time,
+                estimate: estimate,
+                github_issue: github_issue
+              )
+
+              # Write spec file with file_slug
+              spec_filename = Atoms::TaskIdFormatter.spec_filename(formatted_id, file_slug)
+              spec_file = File.join(task_dir, spec_filename)
+              content = build_spec_content(frontmatter: frontmatter, title: title)
+              File.write(spec_file, content)
+
+              # Load and return the created task
+              loader = TaskLoader.new
+              loader.load(task_dir, id: formatted_id)
+            rescue StandardError
+              FileUtils.rm_rf(task_dir) if Dir.exist?(task_dir)
+              raise
+            end
           end
-          folder_slug = slugs[:folder]
-          file_slug = slugs[:file]
-
-          # Create folder with folder_slug
-          folder_name = Atoms::TaskIdFormatter.folder_name(formatted_id, folder_slug)
-          task_dir = File.join(@root_dir, folder_name)
-          FileUtils.mkdir_p(task_dir)
-
-          # Build frontmatter with all fields
-          effective_status = status || @config.dig("task", "default_status") || "pending"
-          frontmatter = Atoms::TaskFrontmatterDefaults.build(
-            id: formatted_id,
-            status: effective_status,
-            priority: priority,
-            tags: tags,
-            dependencies: dependencies,
-            created_at: time,
-            estimate: estimate
-          )
-
-          # Write spec file with file_slug
-          spec_filename = Atoms::TaskIdFormatter.spec_filename(formatted_id, file_slug)
-          spec_file = File.join(task_dir, spec_filename)
-          content = build_spec_content(frontmatter: frontmatter, title: title)
-          File.write(spec_file, content)
-
-          # Load and return the created task
-          loader = TaskLoader.new
-          loader.load(task_dir, id: formatted_id)
         end
 
         private
 
+        def task_id_exists?(formatted_id)
+          Dir.glob(File.join(@root_dir, "**", "#{formatted_id}-*")).any? do |path|
+            File.directory?(path)
+          end
+        end
+
+        def with_id_reservation(formatted_id)
+          reservation_path = File.join(@root_dir, ".ace-task-id-lock-#{formatted_id}")
+          acquired = false
+          Dir.mkdir(reservation_path)
+          acquired = true
+          yield
+        rescue Errno::EEXIST
+          raise IdCollisionError, "Task ID collision detected for #{formatted_id}"
+        ensure
+          FileUtils.rm_rf(reservation_path) if acquired && reservation_path && Dir.exist?(reservation_path)
+        end
+
         def generate_folder_slug(title)
           sanitized = Ace::Support::Items::Atoms::SlugSanitizer.sanitize(title)
           words = sanitized.split("-")

data/lib/ace/task/molecules/task_frontmatter_validator.rb

@@ -109,6 +109,8 @@ module Ace
             if title.length > Atoms::TaskValidationRules::MAX_TITLE_LENGTH
               issues << {type: :warning, message: "Title exceeds #{Atoms::TaskValidationRules::MAX_TITLE_LENGTH} characters (#{title.length} chars)", location: file_path}
             end
+
+            validate_github_fields(frontmatter, file_path, issues)
           end
 
           def validate_recommended_fields(frontmatter, file_path, issues)
@@ -131,6 +133,19 @@ module Ace
               issues << issue.merge(location: file_path)
             end
           end
+
+          def validate_github_fields(frontmatter, file_path, issues)
+            linked = frontmatter["github_issue"]
+            return if linked.nil?
+
+            unless linked.is_a?(Integer) && linked.positive?
+              issues << {
+                type: :error,
+                message: "Invalid GitHub issue ID '#{linked}' in github_issue (expected positive integer)",
+                location: file_path
+              }
+            end
+          end
         end
       end
     end

data/lib/ace/task/molecules/task_plan_generator.rb

@@ -35,7 +35,9 @@ module Ace
           )
         rescue Ace::Support::Cli::Error
           raise
-        rescue RuntimeError, IOError, Errno::ENOENT, Errno::ECONNREFUSED, Timeout::Error => e
+        rescue StandardError => e
+          raise unless recoverable_query_error?(e)
+
           raise Ace::Support::Cli::Error.new(
             "Plan generation failed: #{e.message}. Retry with --refresh or choose a working --model."
           )
@@ -135,6 +137,16 @@ module Ace
           require "ace/llm"
           Ace::LLM::QueryInterface
         end
+
+        def recoverable_query_error?(error)
+          return true if error.class.name == "Ace::LLM::ProviderError"
+
+          error.is_a?(RuntimeError) ||
+            error.is_a?(IOError) ||
+            error.is_a?(Errno::ENOENT) ||
+            error.is_a?(Errno::ECONNREFUSED) ||
+            error.is_a?(Timeout::Error)
+        end
       end
     end
   end

data/lib/ace/task/organisms/task_doctor.rb

@@ -3,6 +3,7 @@
 require_relative "../molecules/task_scanner"
 require_relative "../molecules/task_frontmatter_validator"
 require_relative "../molecules/task_structure_validator"
+require_relative "../molecules/task_doctor_fixer"
 require_relative "../atoms/task_validation_rules"
 
 module Ace
@@ -108,13 +109,20 @@ module Ace
           scanner = Molecules::TaskScanner.new(@root_path)
           return unless scanner.root_exists?
 
-          scan_results = scanner.scan
+          scan_results = frontmatter_scan_results(scanner)
           @stats[:tasks_scanned] = scan_results.size
+          id_locations = Hash.new { |hash, key| hash[key] = [] }
 
           scan_results.each do |scan_result|
             spec_file = scan_result.file_path
             next unless spec_file && File.exist?(spec_file)
 
+            content = File.read(spec_file)
+            frontmatter, _body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
+            if frontmatter.is_a?(Hash) && frontmatter["id"] && !frontmatter["id"].to_s.strip.empty?
+              id_locations[frontmatter["id"]] << spec_file
+            end
+
             issues = Molecules::TaskFrontmatterValidator.validate(
               spec_file,
               special_folder: scan_result.special_folder
@@ -127,6 +135,8 @@ module Ace
               add_issue(issue[:type], issue[:message], issue[:location])
             end
           end
+
+          add_duplicate_id_issues(id_locations)
         end
 
         def run_scope_check
@@ -175,6 +185,26 @@ module Ace
           count
         end
 
+        def frontmatter_scan_results(scanner)
+          top_level_results = scanner.scan
+          subtask_results = top_level_results.flat_map { |scan_result|
+            scanner.scan_subtasks(scan_result.dir_path, parent_id: scan_result.id)
+          }
+          top_level_results + subtask_results
+        end
+
+        def add_duplicate_id_issues(id_locations)
+          id_locations.each do |id, locations|
+            next unless locations.size > 1
+
+            add_issue(
+              :error,
+              "Duplicate task ID '#{id}' found in: #{locations.sort.join(', ')}",
+              locations.first
+            )
+          end
+        end
+
         def add_issue(type, message, location = nil)
           issue = {type: type, message: message}
           issue[:location] = location if location