ace-task 0.38.1 → 0.39.0

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