ace-sim 0.13.0

data/lib/ace/sim/molecules/final_synthesis_executor.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ace
+  module Sim
+    module Molecules
+      class FinalSynthesisExecutor
+        class CommandRunner
+          def call(args)
+            command = Ace::Core::Atoms::CommandExecutor.build_command(args[0], *args[1..])
+            result = Ace::Core::Atoms::CommandExecutor.execute(command)
+            {
+              success: result[:success],
+              stdout: result[:stdout].to_s,
+              stderr: result[:stderr].to_s,
+              exit_code: result[:exit_code]
+            }
+          end
+        end
+
+        def initialize(command_runner: nil)
+          @command_runner = command_runner || CommandRunner.new
+        end
+
+        def execute(run_dir:, session:, chains:, source_original_input_path: nil)
+          final_dir = File.join(run_dir, "final")
+          FileUtils.mkdir_p(final_dir)
+
+          source_original_path = File.join(final_dir, "source.original.md")
+          input_path = File.join(final_dir, "input.md")
+          bundle_path = File.join(final_dir, "user.bundle.md")
+          prompt_path = File.join(final_dir, "user.prompt.md")
+          raw_output_path = File.join(final_dir, "output.sequence.md")
+          report_path = File.join(final_dir, "suggestions.report.md")
+          revised_source_path = File.join(final_dir, "source.revised.md")
+
+          copy_source(source_original_path, session: session, source_original_input_path: source_original_input_path)
+          write_input(input_path, session: session, chains: chains)
+          write_bundle(bundle_path, workflow_ref: session.synthesis_workflow)
+
+          bundle_result = command_runner.call(["ace-bundle", bundle_path, "--output", prompt_path])
+          unless bundle_result[:success]
+            return failure("ace-bundle failed", bundle_result, report_path: report_path, raw_output_path: raw_output_path,
+              revised_source_path: revised_source_path)
+          end
+
+          provider = session.synthesis_provider.to_s.strip.empty? ? session.providers.first : session.synthesis_provider
+          llm_result = command_runner.call(["ace-llm", provider, "--prompt", prompt_path, "--output", raw_output_path])
+          unless llm_result[:success]
+            return failure("ace-llm failed", llm_result, report_path: report_path, raw_output_path: raw_output_path,
+              revised_source_path: revised_source_path)
+          end
+
+          sequence = read_non_empty(raw_output_path)
+          if sequence.nil?
+            return missing_output_failure("Final synthesis sequence missing or empty", provider, report_path, raw_output_path,
+              revised_source_path)
+          end
+
+          parsed = parse_sequence(sequence)
+          unless parsed
+            return {
+              "status" => "failed",
+              "provider" => provider,
+              "error" => "Final synthesis output missing required tags: <suggestions-report> and <source-revised>",
+              "source_original_path" => source_original_path,
+              "input_path" => input_path,
+              "bundle_path" => bundle_path,
+              "prompt_path" => prompt_path,
+              "raw_output_path" => raw_output_path,
+              "report_path" => report_path,
+              "revised_source_path" => revised_source_path,
+              "output_path" => report_path
+            }
+          end
+
+          File.write(report_path, parsed.fetch("suggestions_report"))
+          File.write(revised_source_path, parsed.fetch("source_revised"))
+
+          {
+            "status" => "ok",
+            "provider" => provider,
+            "source_original_path" => source_original_path,
+            "input_path" => input_path,
+            "bundle_path" => bundle_path,
+            "prompt_path" => prompt_path,
+            "raw_output_path" => raw_output_path,
+            "report_path" => report_path,
+            "revised_source_path" => revised_source_path,
+            "output_path" => report_path
+          }
+        rescue => e
+          {
+            "status" => "failed",
+            "error" => e.message,
+            "report_path" => report_path,
+            "raw_output_path" => raw_output_path,
+            "revised_source_path" => revised_source_path,
+            "output_path" => report_path
+          }
+        end
+
+        private
+
+        attr_reader :command_runner
+
+        def copy_source(path, session:, source_original_input_path:)
+          origin_path = source_original_input_path || session.source.first
+          FileUtils.cp(origin_path, path)
+        end
+
+        def write_input(path, session:, chains:)
+          sources_display = session.source.is_a?(Array) ? session.source.join(", ") : session.source.to_s
+          content = +"# ace-sim final synthesis input\n\n"
+          content << "Source file(s): #{sources_display}\n\n"
+          content << "## Chain outputs\n\n"
+
+          chains.each do |chain|
+            content << "### Chain #{chain["provider"]}##{chain["iteration"]} (#{chain["status"]})\n\n"
+            chain.fetch("steps", []).each do |step|
+              content << "#### Step #{step["step"]} (#{step["status"]})\n\n"
+              if step["output_path"] && File.exist?(step["output_path"])
+                content << "```markdown\n"
+                content << File.read(step["output_path"])
+                content << "\n```\n\n"
+              else
+                content << "_No output captured_\n\n"
+              end
+            end
+          end
+
+          File.write(path, content)
+        end
+
+        def write_bundle(path, workflow_ref:)
+          content = <<~MD
+            ---
+            description: "ace-sim final suggestions synthesis bundle"
+            bundle:
+              embed_document_source: true
+              sections:
+                synthesis_workflow:
+                  files:
+                    - #{workflow_ref}
+                source_original:
+                  files:
+                    - ./source.original.md
+                simulation_outputs:
+                  files:
+                    - ./input.md
+            ---
+
+            # Goal
+
+            Produce final actionable synthesis from simulation outputs and the original source.
+
+            ## Instructions
+
+            1. Read `<source_original>` completely.
+            2. Read `<simulation_outputs>` completely.
+            3. Follow `<synthesis_workflow>` for evaluation structure.
+            4. Return markdown only with both required tags:
+               - `<suggestions-report>...</suggestions-report>`
+               - `<source-revised>...</source-revised>`
+            5. The revised source must be directly usable as the next source file iteration.
+          MD
+
+          File.write(path, content)
+        end
+
+        def read_non_empty(path)
+          return nil unless File.exist?(path)
+
+          content = File.read(path)
+          return nil if content.strip.empty?
+
+          content
+        end
+
+        def parse_sequence(content)
+          report = extract_tag(content, "suggestions-report")
+          revised = extract_tag(content, "source-revised")
+          return nil if report.nil? || revised.nil?
+
+          {
+            "suggestions_report" => report,
+            "source_revised" => revised
+          }
+        end
+
+        def extract_tag(content, tag_name)
+          match = content.match(%r{<#{Regexp.escape(tag_name)}>(.*?)</#{Regexp.escape(tag_name)}>}m)
+          return nil unless match
+
+          extracted = match[1].to_s.strip
+          return nil if extracted.empty?
+
+          extracted + "\n"
+        end
+
+        def missing_output_failure(message, provider, report_path, raw_output_path, revised_source_path)
+          {
+            "status" => "failed",
+            "provider" => provider,
+            "error" => "#{message}: #{raw_output_path}",
+            "report_path" => report_path,
+            "raw_output_path" => raw_output_path,
+            "revised_source_path" => revised_source_path,
+            "output_path" => report_path
+          }
+        end
+
+        def failure(prefix, result, report_path:, raw_output_path:, revised_source_path:)
+          detail = result[:stderr].to_s.strip
+          detail = result[:stdout].to_s.strip if detail.empty?
+          detail = "command failed" if detail.empty?
+
+          {
+            "status" => "failed",
+            "error" => "#{prefix}: #{detail}",
+            "report_path" => report_path,
+            "raw_output_path" => raw_output_path,
+            "revised_source_path" => revised_source_path,
+            "output_path" => report_path
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ace/sim/molecules/session_store.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Ace
+  module Sim
+    module Molecules
+      class SessionStore
+        class RunDirectoryExistsError < StandardError; end
+
+        attr_reader :cache_root
+
+        def initialize(cache_root: nil)
+          @cache_root = cache_root || Ace::Sim.get("sim", "cache_root") || ".ace-local/sim"
+        end
+
+        def run_dir_for(run_id)
+          File.join(cache_root, "simulations", run_id)
+        end
+
+        def prepare_run(run_id)
+          run_dir = run_dir_for(run_id)
+          raise RunDirectoryExistsError, "Run directory already exists: #{run_dir}" if Dir.exist?(run_dir)
+
+          FileUtils.mkdir_p(File.join(run_dir, "chains"))
+          run_dir
+        end
+
+        def chain_dir(run_dir, provider, iteration)
+          provider_slug = provider.to_s.gsub(/[^a-zA-Z0-9_-]/, "-")
+          File.join(run_dir, "chains", "#{provider_slug}-#{iteration}")
+        end
+
+        def final_dir(run_dir)
+          File.join(run_dir, "final")
+        end
+
+        def prepare_step_dir(run_dir, provider, iteration, step_index, step_name)
+          dirname = format("%02d-%s", step_index, step_name)
+          dir = File.join(chain_dir(run_dir, provider, iteration), dirname)
+          FileUtils.mkdir_p(dir)
+          dir
+        end
+
+        def write_session(run_dir, payload)
+          write_yaml(File.join(run_dir, "session.yml"), payload)
+        end
+
+        def write_synthesis(run_dir, payload)
+          write_yaml(File.join(run_dir, "synthesis.yml"), payload)
+        end
+
+        def write_yaml(path, payload)
+          write_text(path, YAML.dump(payload))
+        end
+
+        def write_text(path, content)
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, content)
+          path
+        end
+      end
+    end
+  end
+end

data/lib/ace/sim/molecules/source_bundler.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ace
+  module Sim
+    module Molecules
+      class SourceBundler
+        class CommandRunner
+          def call(args)
+            command = Ace::Core::Atoms::CommandExecutor.build_command(args[0], *args[1..])
+            result = Ace::Core::Atoms::CommandExecutor.execute(command)
+            {
+              success: result[:success],
+              stdout: result[:stdout].to_s,
+              stderr: result[:stderr].to_s,
+              exit_code: result[:exit_code]
+            }
+          end
+        end
+
+        def initialize(command_runner: nil)
+          @command_runner = command_runner || CommandRunner.new
+        end
+
+        def bundle(sources:, output_path:)
+          raise Ace::Sim::ValidationError, "source cannot be empty" if sources.nil? || sources.empty?
+
+          run_dir = File.dirname(output_path)
+          bundle_path = File.join(run_dir, "input.bundle.md")
+          content_path = File.join(run_dir, "input.md")
+
+          FileUtils.mkdir_p(run_dir)
+          File.write(bundle_path, build_bundle_yaml(sources))
+
+          result = command_runner.call(["ace-bundle", bundle_path, "--output", content_path])
+          return content_path if result[:success]
+
+          detail = result[:stderr].to_s.strip
+          detail = result[:stdout].to_s.strip if detail.empty?
+          detail = "command failed" if detail.empty?
+          raise Ace::Sim::ValidationError, "ace-bundle failed: #{detail}"
+        end
+
+        private
+
+        attr_reader :command_runner
+
+        def build_bundle_yaml(sources)
+          files_yaml = sources.map { |s| "      - #{s}" }.join("\n")
+          <<~YAML
+            ---
+            description: "ace-sim source bundle"
+            bundle:
+              embed_document_source: true
+              sections:
+                source:
+                  files:
+            #{files_yaml}
+            ---
+
+            # Source Files
+
+            Combined input from #{sources.length} source(s).
+          YAML
+        end
+      end
+    end
+  end
+end

data/lib/ace/sim/molecules/stage_executor.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ace
+  module Sim
+    module Molecules
+      class StageExecutor
+        class CommandRunner
+          def call(args)
+            command = Ace::Core::Atoms::CommandExecutor.build_command(args[0], *args[1..])
+            result = Ace::Core::Atoms::CommandExecutor.execute(command)
+            {
+              success: result[:success],
+              stdout: result[:stdout].to_s,
+              stderr: result[:stderr].to_s,
+              exit_code: result[:exit_code]
+            }
+          end
+        end
+
+        def initialize(command_runner: nil)
+          @command_runner = command_runner || CommandRunner.new
+        end
+
+        def execute(step:, provider:, iteration:, step_dir:, step_bundle_path:, input_source_path:)
+          input_path = File.join(step_dir, "input.md")
+          bundle_path = File.join(step_dir, "user.bundle.md")
+          prompt_path = File.join(step_dir, "user.prompt.md")
+          output_path = File.join(step_dir, "output.md")
+
+          FileUtils.cp(input_source_path, input_path)
+          FileUtils.cp(step_bundle_path, bundle_path)
+
+          bundle_result = command_runner.call(["ace-bundle", bundle_path, "--output", prompt_path])
+          return failure(step, provider, iteration, output_path, "ace-bundle failed", bundle_result) unless bundle_result[:success]
+
+          llm_result = command_runner.call(["ace-llm", provider, "--prompt", prompt_path, "--output", output_path])
+          return failure(step, provider, iteration, output_path, "ace-llm failed", llm_result) unless llm_result[:success]
+
+          unless valid_output?(output_path)
+            return {
+              "step" => step,
+              "provider" => provider,
+              "iteration" => iteration,
+              "status" => "failed",
+              "input_path" => input_path,
+              "bundle_path" => bundle_path,
+              "prompt_path" => prompt_path,
+              "output_path" => output_path,
+              "error" => "Step output missing or empty: #{output_path}"
+            }
+          end
+
+          {
+            "step" => step,
+            "provider" => provider,
+            "iteration" => iteration,
+            "status" => "ok",
+            "input_path" => input_path,
+            "bundle_path" => bundle_path,
+            "prompt_path" => prompt_path,
+            "output_path" => output_path
+          }
+        rescue => e
+          {
+            "step" => step,
+            "provider" => provider,
+            "iteration" => iteration,
+            "status" => "failed",
+            "input_path" => input_path,
+            "bundle_path" => bundle_path,
+            "prompt_path" => prompt_path,
+            "output_path" => output_path,
+            "error" => e.message
+          }
+        end
+
+        private
+
+        attr_reader :command_runner
+
+        def valid_output?(output_path)
+          return false unless File.exist?(output_path)
+
+          !File.read(output_path).strip.empty?
+        end
+
+        def failure(step, provider, iteration, output_path, prefix, result)
+          detail = result[:stderr].to_s.strip
+          detail = result[:stdout].to_s.strip if detail.empty?
+          detail = "command failed" if detail.empty?
+
+          {
+            "step" => step,
+            "provider" => provider,
+            "iteration" => iteration,
+            "status" => "failed",
+            "output_path" => output_path,
+            "error" => "#{prefix}: #{detail}"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ace/sim/molecules/synthesis_builder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Ace
+  module Sim
+    module Molecules
+      class SynthesisBuilder
+        def build(session:, sources:, chains:, final_stage: nil)
+          {
+            "run_id" => session.run_id,
+            "preset" => session.preset,
+            "sources" => sources,
+            "providers" => session.providers,
+            "repeat" => session.repeat,
+            "dry_run" => session.dry_run?,
+            "writeback" => session.writeback,
+            "synthesis_workflow" => session.synthesis_workflow,
+            "synthesis_provider" => session.synthesis_provider,
+            "chains" => chains,
+            "final_stage" => final_stage,
+            "status" => overall_status(chains, final_stage: final_stage)
+          }
+        end
+
+        def chain_status(step_results)
+          (step_results.any? { |step| step["status"] == "failed" }) ? "failed" : "ok"
+        end
+
+        private
+
+        def overall_status(chains, final_stage: nil)
+          return "failed" if final_stage && final_stage["status"] == "failed"
+          return "failed" if chains.empty?
+          return "failed" if chains.all? { |chain| chain["status"] == "failed" }
+          return "partial" if chains.any? { |chain| chain["status"] == "failed" }
+
+          "ok"
+        end
+      end
+    end
+  end
+end

data/lib/ace/sim/organisms/simulation_runner.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Ace
+  module Sim
+    module Organisms
+      class SimulationRunner
+        def initialize(session_store: nil, stage_executor: nil, synthesis_builder: nil,
+          final_synthesis_executor: nil, source_bundler: nil)
+          @session_store = session_store || Molecules::SessionStore.new
+          @stage_executor = stage_executor || Molecules::StageExecutor.new
+          @synthesis_builder = synthesis_builder || Molecules::SynthesisBuilder.new
+          @final_synthesis_executor = final_synthesis_executor || Molecules::FinalSynthesisExecutor.new
+          @source_bundler = source_bundler || Molecules::SourceBundler.new
+        end
+
+        def run(session)
+          sources = session.source
+          if session.writeback && sources.length > 1
+            raise Ace::Sim::ValidationError, "writeback requires a single source file"
+          end
+
+          run_id, run_dir = prepare_unique_run(session)
+          bundled_input_path = source_bundler.bundle(
+            sources: sources,
+            output_path: File.join(run_dir, "input.md")
+          )
+
+          chains = []
+          session.providers.each do |provider|
+            1.upto(session.repeat) do |iteration|
+              chains << run_chain(
+                session: session,
+                run_dir: run_dir,
+                provider: provider,
+                iteration: iteration,
+                bundled_input_path: bundled_input_path
+              )
+            end
+          end
+
+          final_stage = nil
+          if session.synthesis_enabled?
+            final_stage = final_synthesis_executor.execute(
+              run_dir: run_dir,
+              session: session,
+              chains: chains,
+              source_original_input_path: bundled_input_path
+            )
+          end
+
+          synthesis = synthesis_builder.build(
+            session: session,
+            sources: sources,
+            chains: chains,
+            final_stage: final_stage
+          )
+          session_store.write_synthesis(run_dir, synthesis)
+
+          session_store.write_session(
+            run_dir,
+            session.to_h.merge(
+              "run_id" => run_id,
+              "sources" => sources,
+              "status" => synthesis["status"],
+              "chain_count" => chains.length,
+              "writeback_applied" => false,
+              "synthesis_report_path" => final_stage && final_stage["report_path"],
+              "synthesis_revised_source_path" => final_stage && final_stage["revised_source_path"]
+            )
+          )
+
+          {
+            success: synthesis["status"] != "failed",
+            status: synthesis["status"],
+            run_id: run_id,
+            run_dir: run_dir,
+            chains: chains,
+            final_stage: final_stage,
+            synthesis: synthesis,
+            error: (synthesis["status"] == "failed") ? failure_reason(chains, final_stage) : nil
+          }
+        rescue Ace::Sim::ValidationError => e
+          {
+            success: false,
+            status: "failed",
+            run_id: session.run_id,
+            run_dir: nil,
+            chains: [],
+            synthesis: nil,
+            error: e.message
+          }
+        rescue => e
+          {
+            success: false,
+            status: "failed",
+            run_id: session.run_id,
+            run_dir: nil,
+            chains: [],
+            synthesis: nil,
+            error: "#{e.class}: #{e.message}"
+          }
+        end
+
+        private
+
+        attr_reader :session_store, :stage_executor, :synthesis_builder, :final_synthesis_executor,
+          :source_bundler
+
+        def run_chain(session:, run_dir:, provider:, iteration:, bundled_input_path:)
+          current_input_path = bundled_input_path
+          step_results = []
+
+          session.steps.each_with_index do |step, index|
+            step_index = case step
+            when "draft"
+              1
+            when "plan"
+              2
+            when "work"
+              3
+            else
+              index + 1
+            end
+
+            step_dir = session_store.prepare_step_dir(run_dir, provider, iteration, step_index, step)
+            result = stage_executor.execute(
+              step: step,
+              provider: provider,
+              iteration: iteration,
+              step_dir: step_dir,
+              step_bundle_path: session.bundle_path_for(step),
+              input_source_path: current_input_path
+            )
+
+            step_results << result
+            break if result["status"] == "failed"
+
+            current_input_path = result["output_path"]
+          end
+
+          {
+            "provider" => provider,
+            "iteration" => iteration,
+            "status" => synthesis_builder.chain_status(step_results),
+            "steps" => step_results
+          }
+        end
+
+        def prepare_unique_run(session)
+          attempts = 0
+          begin
+            attempts += 1
+            run_dir = session_store.prepare_run(session.run_id)
+            [session.run_id, run_dir]
+          rescue Molecules::SessionStore::RunDirectoryExistsError
+            raise Ace::Sim::ValidationError, "Could not allocate unique run id" if attempts >= 5
+
+            session.regenerate_run_id!
+            retry
+          end
+        end
+
+        def failure_reason(chains, final_stage)
+          return "Final synthesis failed" if final_stage && final_stage["status"] == "failed"
+          return "All chains failed" if chains.all? { |chain| chain["status"] == "failed" }
+
+          "Simulation failed"
+        end
+      end
+    end
+  end
+end

data/lib/ace/sim/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ace
+  module Sim
+    VERSION = "0.13.0"
+  end
+end