ace-task 0.38.0 → 0.39.0

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

@@ -110,7 +110,7 @@ module Ace
               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)
+            validate_issue_fields(frontmatter, file_path, issues)
           end
 
           def validate_recommended_fields(frontmatter, file_path, issues)
@@ -134,24 +134,50 @@ module Ace
             end
           end
 
-          def validate_github_fields(frontmatter, file_path, issues)
-            linked = frontmatter["github_issue"]
-            unless linked.nil? || (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
-
-            pending = frontmatter["github_sync_pending"]
-            return if pending.nil? || pending == true || pending == false
+          def validate_issue_fields(frontmatter, file_path, issues)
+            %w[github_issue github_sync_pending].each do |key|
+              next unless frontmatter.key?(key)
 
-            issues << {
-              type: :error,
-              message: "Invalid github_sync_pending value (expected boolean)",
-              location: file_path
-            }
+              issues << {type: :error, message: "Obsolete #{key}; use remote_issue/issue_sync_pending",
+                         location: file_path}
+            end
+            if frontmatter.key?("remote_issue")
+              linked = frontmatter["remote_issue"]
+              valid = linked.is_a?(Hash) && linked.keys.all? { |key| key.is_a?(String) } &&
+                linked.keys.sort ==
+                %w[number provider repository_url server_name url] &&
+                linked["number"].is_a?(Integer) && linked["number"].positive? &&
+                %w[server_name provider repository_url url].all? { |key| linked[key].is_a?(String) && !linked[key].empty? } &&
+                linked["url"] == "#{Ace::Git::Atoms::ServerUrl.web_base(linked["repository_url"])}/issues/#{linked["number"]}"
+              unless valid
+                issues << {type: :error, message: "Invalid complete remote_issue identity", location: file_path}
+              end
+            end
+            pending = frontmatter["issue_sync_pending"]
+            unless pending.nil? || pending == true || pending == false
+              issues << {type: :error, message: "Invalid issue_sync_pending value (expected boolean)",
+                         location: file_path}
+            end
+            if pending == true && !frontmatter.key?("remote_issue")
+              issues << {type: :error, message: "issue_sync_pending requires a complete remote_issue identity",
+                         location: file_path}
+            end
+            operation = frontmatter["issue_sync_operation"]
+            valid_operation = operation.nil? ||
+              (%w[clear reconcile-create].include?(operation) && pending == true && frontmatter["remote_issue"].is_a?(Hash))
+            unless valid_operation
+              issues << {type: :error, message: "Invalid issue_sync_operation", location: file_path}
+            end
+            previous_id = frontmatter["issue_sync_previous_id"]
+            unless previous_id.nil? || (previous_id.is_a?(String) && !previous_id.empty?)
+              issues << {type: :error, message: "Invalid issue_sync_previous_id value (expected task ID string)",
+                         location: file_path}
+            end
+            reconcile_flag = frontmatter["issue_sync_reconcile_create"]
+            unless reconcile_flag.nil? || reconcile_flag == true
+              issues << {type: :error, message: "Invalid issue_sync_reconcile_create value (expected boolean)",
+                         location: file_path}
+            end
           end
         end
       end

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

@@ -76,9 +76,9 @@ module Ace
         end
 
         def run_ace_bundle(input, output_path)
-          _stdout, status = Open3.capture2(
-            "ace-bundle", input, "--format", "markdown-xml", "--output", output_path
-          )
+          checkout_binstub = File.expand_path("../../../../../bin/ace-bundle", __dir__)
+          executable = File.file?(checkout_binstub) ? checkout_binstub : Gem.bin_path("ace-bundle", "ace-bundle")
+          _stdout, status = Open3.capture2(executable, input, "--format", "markdown-xml", "--output", output_path)
           unless status.success?
             raise Ace::Support::Cli::Error.new("ace-bundle failed for: #{input}")
           end

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

@@ -75,6 +75,11 @@ module Ace
             fm.delete("parent")
           end
 
+          # Promoted descendants rebase from the standalone ID.
+          id_map = {task.id => new_id}
+          rewrite_descendants(new_dir, old_parent_id: task.id, new_parent_id: new_id, id_map: id_map)
+          rewrite_dependency_references(id_map)
+
           loader = TaskLoader.new
           loader.load(new_dir, id: new_id)
         end
@@ -164,10 +169,71 @@ module Ace
             fm["parent"] = parent_task.id
           end
 
+          # Descendant identities hang off the parent ID: rewrite their
+          # frontmatter and spec filenames so persisted IDs stay authoritative.
+          id_map = {task.id => new_id}
+          rewrite_descendants(new_dir, old_parent_id: task.id, new_parent_id: new_id, id_map: id_map)
+          rewrite_dependency_references(id_map)
+
           loader = TaskLoader.new
           loader.load(new_dir, id: new_id)
         end
 
+        # Rewrite dependency references in every task spec after an ID map
+        # changes (stale references would read as unmet dependencies).
+        def rewrite_dependency_references(id_map)
+          return if id_map.empty?
+
+          Dir.glob(File.join(@root_dir, "**", "*.s.md")).sort.each do |spec|
+            content = File.read(spec)
+            frontmatter, body = Ace::Support::Items::Atoms::FrontmatterParser.parse(content)
+            deps = frontmatter["dependencies"]
+            next unless deps.is_a?(Array)
+
+            mapped = deps.map { |dep| id_map.fetch(dep, dep) }
+            next if mapped == deps
+
+            frontmatter["dependencies"] = mapped
+            tmp_path = "#{spec}.tmp.#{Process.pid}"
+            File.write(tmp_path, Ace::Support::Items::Atoms::FrontmatterSerializer.rebuild(frontmatter, body))
+            File.rename(tmp_path, spec)
+          end
+        end
+
+        # Recursively rewrite descendant frontmatter IDs, parent references and
+        # spec filenames after their ancestor's ID changed.
+        def rewrite_descendants(dir, old_parent_id:, new_parent_id:, id_map: {})
+          return unless Dir.exist?(dir)
+
+          Dir.entries(dir).sort.each do |entry|
+            next if entry.start_with?(".")
+            next unless (short_match = entry.match(/\A([a-z0-9])-(.+)/))
+
+            char = short_match[1]
+            slug = short_match[2]
+            child_dir = File.join(dir, entry)
+            next unless File.directory?(child_dir)
+
+            old_child_id = "#{old_parent_id}.#{char}"
+            new_child_id = "#{new_parent_id}.#{char}"
+            id_map[old_child_id] = new_child_id
+
+            spec = Dir.glob(File.join(child_dir, "*.s.md")).sort.first
+            if spec
+              new_spec = File.join(child_dir, "#{new_child_id}-#{slug}.s.md")
+              File.rename(spec, new_spec) if spec != new_spec && !File.exist?(new_spec)
+              if File.exist?(new_spec)
+                update_frontmatter(new_spec) do |fm|
+                  fm["id"] = new_child_id
+                  fm["parent"] = new_parent_id
+                end
+              end
+            end
+
+            rewrite_descendants(child_dir, old_parent_id: old_child_id, new_parent_id: new_child_id, id_map: id_map)
+          end
+        end
+
         # Extract the base task ID (without subtask char) from a potentially dotted ID
         # "8pp.t.q7w.a" => "8pp.t.q7w"
         def base_task_id(id)

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

@@ -19,8 +19,9 @@ module Ace
         # Short reference pattern: "t.q7w" → extract suffix "q7w"
         SHORT_REF_PATTERN = /^[a-z]\.([0-9a-z]{3})$/
 
-        # Subtask reference pattern: "8pp.t.q7w.a" (parent ID + dot + single char)
-        SUBTASK_REF_PATTERN = /^([0-9a-z]{3}\.[a-z]\.[0-9a-z]{3})\.([a-z0-9])$/
+        # Subtask reference pattern: "8pp.t.q7w.a" or nested "8pp.t.q7w.0.a"
+        # (parent ID + one or more dot-separated subtask chars)
+        SUBTASK_REF_PATTERN = /^([0-9a-z]{3}\.[a-z]\.[0-9a-z]{3}(?:\.[a-z0-9])*)\.([a-z0-9])$/
 
         # Short subtask reference: "q7w.a" or "t.q7w.a" (suffix + subtask char)
         SHORT_SUBTASK_REF_PATTERN = /^(?:[a-z]\.)?([0-9a-z]{3})\.([a-z0-9])$/
@@ -76,7 +77,17 @@ module Ace
         # Resolve a subtask reference by finding the parent's scan result,
         # then looking for the subtask folder within that parent's directory.
         def resolve_subtask(parent_id, subtask_char)
-          parent_result = @scan_results.find { |sr| sr.id == parent_id }
+          parent_result = if parent_id.count(".") >= 3
+            # Nested parent: resolve level by level from the base task.
+            base_id = parent_id.split(".")[0, 3].join(".")
+            nested_chars = parent_id.split(".")[3..]
+            current = resolve_subtask_chain(base_id, nested_chars)
+            return nil unless current
+
+            current
+          else
+            @scan_results.find { |sr| sr.id == parent_id }
+          end
           return nil unless parent_result
 
           subtask_id = "#{parent_id}.#{subtask_char}"
@@ -109,6 +120,23 @@ module Ace
 
           nil
         end
+
+        # Walk nested subtask chars from the base task, returning the final
+        # scan result (ids are rebuilt per level exactly like the folders).
+        def resolve_subtask_chain(base_id, nested_chars)
+          current = @scan_results.find { |sr| sr.id == base_id }
+          return nil unless current
+
+          current_id = base_id
+          nested_chars.each do |char|
+            next_level = resolve_subtask(current_id, char)
+            return nil unless next_level
+
+            current = next_level
+            current_id = next_level.id
+          end
+          current
+        end
       end
     end
   end