ace-task 0.31.9 → 0.36.7

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

@@ -7,6 +7,7 @@ require_relative "../molecules/task_loader"
 require_relative "../molecules/task_creator"
 require_relative "../molecules/subtask_creator"
 require_relative "../molecules/task_reparenter"
+require_relative "../molecules/github_issue_sync_adapter"
 require_relative "../atoms/task_validation_rules"
 
 module Ace
@@ -15,6 +16,9 @@ module Ace
       # Orchestrates all task CRUD operations.
       # Entry point for task management with config-driven root directory.
       class TaskManager
+        CREATE_RETRY_LIMIT = 3
+        class CreateRetriesExhaustedError < StandardError; end
+
         attr_reader :last_list_total, :last_folder_counts
 
         # @param root_dir [String, nil] Override root directory for tasks
@@ -35,11 +39,41 @@ module Ace
         # @param dependencies [Array<String>] Dependency task IDs
         # @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: [], use_llm_slug: false, estimate: nil)
+        def create(
+          title,
+          status: nil,
+          priority: nil,
+          tags: [],
+          dependencies: [],
+          use_llm_slug: false,
+          estimate: nil,
+          github_issue: nil
+        )
           ensure_root_dir
+          ensure_github_issue_linkable!(github_issue)
           creator = Molecules::TaskCreator.new(root_dir: @root_dir, config: @config)
-          creator.create(title, status: status, priority: priority, tags: tags,
-            dependencies: dependencies, use_llm_slug: use_llm_slug, estimate: estimate)
+          attempts = 0
+
+          begin
+            attempts += 1
+            created_task = creator.create(
+              title,
+              status: status,
+              priority: priority,
+              tags: tags,
+              dependencies: dependencies,
+              use_llm_slug: use_llm_slug,
+              time: Time.now.utc + ((attempts - 1) * 2),
+              estimate: estimate,
+              github_issue: github_issue
+            )
+            sync_linked_issues_for(created_task, reason: "create")
+            created_task
+          rescue Molecules::TaskCreator::IdCollisionError
+            retry if attempts < CREATE_RETRY_LIMIT
+            raise CreateRetriesExhaustedError,
+              "Failed to create task: unable to generate a unique ID after #{CREATE_RETRY_LIMIT} attempts"
+          end
         end
 
         # Show (load) a single task by reference, including subtasks.
@@ -109,6 +143,8 @@ module Ace
 
           # Apply field updates if any
           has_field_updates = [set, add, remove].any? { |h| h && !h.empty? }
+          desired_issue = extract_desired_github_issue(task, set: set, remove: remove)
+          ensure_github_issue_linkable!(desired_issue, previous_task: task) if desired_issue
           if has_field_updates
             Ace::Support::Items::Molecules::FieldUpdater.update(
               task.file_path, set: set, add: add, remove: remove
@@ -146,7 +182,9 @@ module Ace
             resolve_fn = ->(r) { show(r) }
             # Reload task from current path before reparenting (may have been field-updated)
             task_for_reparent = loader.load(current_path, id: task.id, special_folder: current_special)
-            return reparenter.reparent(task_for_reparent, target: move_as_child_of, resolve_ref: resolve_fn)
+            reparented = reparenter.reparent(task_for_reparent, target: move_as_child_of, resolve_ref: resolve_fn)
+            sync_linked_issues_for(reparented, reason: "reparent", previous_task: task)
+            return reparented
           end
 
           # Auto-archive hook: if a subtask status was set to terminal,
@@ -156,7 +194,11 @@ module Ace
           end
 
           # Reload and return updated task
-          loader.load(current_path, id: current_id, special_folder: current_special)
+          updated_task = loader.load(current_path, id: current_id, special_folder: current_special)
+          if sync_needed_after_update?(task, updated_task, set: set, add: add, remove: remove, move_to: move_to)
+            sync_linked_issues_for(updated_task, reason: "update", previous_task: task)
+          end
+          updated_task
         end
 
         # Create a subtask within a parent task.
@@ -166,12 +208,45 @@ module Ace
         # @param priority [String, nil] Priority level
         # @param tags [Array<String>] Tags
         # @return [Models::Task, nil] Created subtask or nil if parent not found
-        def create_subtask(parent_ref, title, status: nil, priority: nil, tags: [], estimate: nil)
+        def create_subtask(parent_ref, title, status: nil, priority: nil, tags: [], estimate: nil, github_issue: nil)
           parent = show(parent_ref)
           return nil unless parent
 
+          ensure_github_issue_linkable!(github_issue)
           subtask_creator = Molecules::SubtaskCreator.new(config: @config)
-          subtask_creator.create(parent, title, status: status, priority: priority, tags: tags, estimate: estimate)
+          created_subtask = subtask_creator.create(
+            parent,
+            title,
+            status: status,
+            priority: priority,
+            tags: tags,
+            estimate: estimate,
+            github_issue: github_issue
+          )
+          sync_linked_issues_for(created_subtask, reason: "create")
+          created_subtask
+        end
+
+        def github_sync(ref: nil, all: false)
+          raise ArgumentError, "Provide --all or a task reference" if !all && (ref.nil? || ref.strip.empty?)
+
+          if all
+            tasks = list(in_folder: "all")
+            linked_tasks = tasks.select { |t| linked_issue_id(t) }
+            results = linked_tasks.map { |task| sync_linked_issues_for(task, reason: "manual-sync") }
+            return summarize_manual_sync_results(results, skipped: tasks.length - linked_tasks.length)
+          end
+
+          task = show(ref)
+          return nil unless task
+
+          unless linked_issue_id(task)
+            return {synced: 0, failed: 0, skipped: 1, task_id: task.id, failures: []}
+          end
+
+          result = sync_linked_issues_for(task, reason: "manual-sync")
+          summary = summarize_manual_sync_results([result], skipped: 0)
+          summary.merge(task_id: task.id)
         end
 
         # Get the root directory.
@@ -261,10 +336,10 @@ module Ace
             parent_dir, recursive: true
           )
 
-          # Auto-move the parent folder to archive
-          parent_stub = Struct.new(:path).new(parent_dir)
-          mover = Ace::Support::Items::Molecules::FolderMover.new(@root_dir)
-          mover.move(parent_stub, to: "archive")
+          parent = load_parent_from_directory(parent_dir, loader)
+          return unless parent
+
+          archive_parent_via_update(parent)
         end
 
         def parse_archive_date(task)
@@ -312,27 +387,46 @@ module Ace
             }
           end
 
-          unless Atoms::TaskValidationRules.terminal_status?(parent.status.to_s.downcase)
-            Ace::Support::Items::Molecules::FieldUpdater.update(
-              parent.file_path, set: {"status" => "done"}
-            )
-            parent = loader.load(parent.path, id: parent.id, special_folder: parent.special_folder)
-          end
-
-          mover = Ace::Support::Items::Molecules::FolderMover.new(@root_dir)
-          new_parent_path = mover.move(parent, to: "archive", date: parse_archive_date(parent))
-          new_special_folder = Ace::Support::Items::Atoms::SpecialFolderDetector.detect_in_path(
-            new_parent_path, root: @root_dir
-          )
+          archived_parent = archive_parent_via_update(parent)
+          return {
+            path: task.path,
+            special_folder: task.special_folder,
+            id: task.id
+          } unless archived_parent
 
           @last_update_note = "Archived parent task #{parent.id} because all subtasks are terminal."
           {
-            path: File.join(new_parent_path, File.basename(task.path)),
-            special_folder: new_special_folder,
+            path: File.join(archived_parent.path, File.basename(task.path)),
+            special_folder: archived_parent.special_folder,
             id: task.id
           }
         end
 
+        def archive_parent_via_update(parent)
+          previous_note = @last_update_note
+          archived_parent = update(
+            parent.id,
+            set: {"status" => "done"},
+            move_to: "archive"
+          )
+
+          if archived_parent && @last_update_note == previous_note
+            @last_update_note = "Archived parent task #{parent.id} because all subtasks are terminal."
+          end
+
+          archived_parent
+        end
+
+        def load_parent_from_directory(parent_dir, loader)
+          parent_id = File.basename(parent_dir).split("-", 2).first
+          return nil unless parent_id
+
+          parent_special = Ace::Support::Items::Atoms::SpecialFolderDetector.detect_in_path(
+            parent_dir, root: @root_dir
+          )
+          loader.load(parent_dir, id: parent_id, special_folder: parent_special)
+        end
+
         # Value accessor for FilterApplier
         def task_value_accessor(item, key)
           case key
@@ -347,6 +441,80 @@ module Ace
             item.metadata[key] || item.metadata[key.to_sym] if item.respond_to?(:metadata) && item.metadata
           end
         end
+
+        def sync_needed_after_update?(before_task, after_task, set:, add:, remove:, move_to:)
+          return false unless after_task
+          return true if move_to
+          return true if before_task.path != after_task.path
+          return true if linked_issue_id(before_task) != linked_issue_id(after_task)
+
+          touched_keys = [set, add, remove].compact.flat_map(&:keys).map(&:to_s)
+          touched_keys.any? do |key|
+            key == "title" || key == "status" || key == "github_issue"
+          end
+        end
+
+        def linked_issue_id(task)
+          return nil unless task&.metadata
+
+          issue_id = task.metadata["github_issue"]
+          return nil unless issue_id.to_i.positive?
+
+          issue_id.to_i
+        end
+
+        def extract_desired_github_issue(task, set:, remove:)
+          return nil if set&.key?("github_issue") && !set["github_issue"].to_i.positive?
+          return set["github_issue"].to_i if set&.key?("github_issue") && set["github_issue"].to_i.positive?
+          return nil if Array(remove&.keys).map(&:to_s).include?("github_issue")
+
+          linked_issue_id(task)
+        end
+
+        def ensure_github_issue_linkable!(github_issue, previous_task: nil)
+          return unless github_issue
+
+          Molecules::GithubIssueSyncAdapter.new.validate_link!(issue_id: github_issue, previous_task: previous_task)
+        end
+
+        def sync_linked_issues_for(task, reason:, previous_task: nil)
+          issue_ids = [linked_issue_id(task), linked_issue_id(previous_task)].compact.uniq
+          return sync_result_for(task: task, issues: issue_ids, success: true, reason: reason) if issue_ids.empty?
+
+          adapter = Molecules::GithubIssueSyncAdapter.new
+          adapter.sync_task(task: task, reason: reason, previous_task: previous_task)
+          sync_result_for(task: task, issues: issue_ids, success: true, reason: reason)
+        rescue StandardError => e
+          @last_update_note = "GitHub sync warning for task #{task&.id}: #{e.message}"
+          sync_result_for(task: task, issues: issue_ids, success: false, reason: reason, error: e.message)
+        end
+
+        def sync_result_for(task:, issues:, success:, reason:, error: nil)
+          {
+            task_id: task&.id,
+            issue_ids: issues,
+            success: success,
+            reason: reason,
+            error: error
+          }
+        end
+
+        def summarize_manual_sync_results(results, skipped:)
+          failures = results.reject { |result| result[:success] }.map do |result|
+            {
+              task_id: result[:task_id],
+              issue_ids: result[:issue_ids],
+              error: result[:error]
+            }
+          end
+
+          {
+            synced: results.length - failures.length,
+            failed: failures.length,
+            skipped: skipped,
+            failures: failures
+          }
+        end
       end
     end
   end

data/lib/ace/task/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Task
-    VERSION = '0.31.9'
+    VERSION = '0.36.7'
   end
 end

data/lib/ace/task.rb

@@ -5,6 +5,7 @@ require_relative "task/version"
 # Dependencies
 require "ace/support/items"
 require "ace/b36ts"
+require "ace/git"
 
 # Atoms
 require_relative "task/atoms/task_id_formatter"
@@ -23,6 +24,7 @@ require_relative "task/molecules/task_creator"
 require_relative "task/molecules/subtask_creator"
 require_relative "task/molecules/task_display_formatter"
 require_relative "task/molecules/path_utils"
+require_relative "task/molecules/github_issue_sync_adapter"
 require_relative "task/molecules/task_plan_cache"
 require_relative "task/molecules/task_plan_generator"
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-task
 version: !ruby/object:Gem::Version
-  version: 0.31.9
+  version: 0.36.7
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-04-01 00:00:00.000000000 Z
+date: 2026-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-core
@@ -79,6 +79,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: ace-git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
   requirement: !ruby/object:Gem::Requirement
@@ -144,12 +158,14 @@ files:
 - lib/ace/task/cli.rb
 - lib/ace/task/cli/commands/create.rb
 - lib/ace/task/cli/commands/doctor.rb
+- lib/ace/task/cli/commands/github_sync.rb
 - lib/ace/task/cli/commands/list.rb
 - lib/ace/task/cli/commands/plan.rb
 - lib/ace/task/cli/commands/show.rb
 - lib/ace/task/cli/commands/status.rb
 - lib/ace/task/cli/commands/update.rb
 - lib/ace/task/models/task.rb
+- lib/ace/task/molecules/github_issue_sync_adapter.rb
 - lib/ace/task/molecules/path_utils.rb
 - lib/ace/task/molecules/subtask_creator.rb
 - lib/ace/task/molecules/task_config_loader.rb