textus 0.55.2 → 0.56.0

data/lib/textus/workflow/registry.rb

@@ -1,20 +1,43 @@
+# frozen_string_literal: true
+
 module Textus
   module Workflow
     class Registry
-      def initialize
-        @definitions = []
+      class UnknownWorkflow < KeyError
+      end
+
+      def self.load_all(root)
+        geometry = Textus::Protocol::Layout.new(root)
+        return [] unless File.directory?(geometry.workflow_dir)
+
+        Workflow::DSL::Definition.clear_registered
+        Dir.glob(File.join(geometry.workflow_dir, "**", "*.rb")).each { |path| load path }
+        Workflow::DSL::Definition.definitions
+      end
+
+      attr_reader :definitions
+
+      def initialize(workflow_definitions)
+        @definitions = workflow_definitions
+        @by_event = {}
+        @by_type  = {}
+
+        workflow_definitions.each do |wf|
+          @by_type[wf.type] = wf
+          wf.handled_events.each { |ev| (@by_event[ev] ||= []) << wf }
+        end
       end
 
-      def register(definition)
-        @definitions << definition
+      def workflows_for(event_type)
+        @by_event.fetch(event_type.to_s, [])
       end
 
-      def for(key)
-        @definitions.find { |d| d.match?(key) }
+      def for(workflow_type)
+        @by_type[workflow_type.to_s] or raise(UnknownWorkflow.new("Unknown workflow type: #{workflow_type}"))
       end
 
-      def all
-        @definitions.dup
+      def match_for_key(key)
+        @definitions.find { |wf| wf.match?(key) }
       end
     end
   end

data/lib/textus/workflow/runner.rb

@@ -1,28 +1,38 @@
-require "timeout"
-
 module Textus
   module Workflow
+    class ParallelStepFailed < Textus::Error
+      attr_reader :failures
+
+      def initialize(failures)
+        @failures = failures
+        msgs = failures.map { |f| "#{f[:step]}: #{f[:error]}" }.join("; ")
+        super(:workflow_parallel_step_failed, "parallel step(s) failed: #{msgs}")
+      end
+    end
+
     class Runner
-      DEFAULT_TIMEOUT = 30
+      Context = Data.define(:key, :entry, :config, :lane, :container, :call) do
+        def store_engine = container.store_engine
+        def manifest     = container.manifest
+        def layout       = container.layout
+        def file_system  = container.store.file_system
+        def schemas      = container.schemas
+        def read(key)    = store_engine.read(key:)
+        def repo_root    = File.dirname(container.root)
+        def store_root   = container.root
+      end
 
       def initialize(definition, container:, call:)
         @definition = definition
         @container  = container
         @call       = call
+        @publisher  = Publisher.new(container: container, call: call)
+        @step_executor = StepExecutor.new
       end
 
       def run(key)
-        ctx  = build_context(key)
-        data = execute_steps(ctx)
-        publish(key, data, ctx)
-        data
-      end
-
-      private
-
-      def build_context(key)
         res = @container.manifest.resolver.resolve(key)
-        Context.new(
+        ctx = Context.new(
           key: key,
           entry: res.entry,
           config: {}.freeze,
@@ -30,48 +40,10 @@ module Textus
           container: @container,
           call: @call,
         )
-      end
-
-      def execute_steps(ctx)
-        data = nil
-        @definition.steps.each { |step| data = execute_one(step, data, ctx) }
+        data = @step_executor.execute(@definition.steps, ctx)
+        @publisher.publish(key, data, ctx, @definition) if data
         data
       end
-
-      def execute_one(step, data, ctx)
-        timeout = step.timeout || DEFAULT_TIMEOUT
-        Timeout.timeout(timeout) { step.callable.call(data, ctx) }
-      rescue Timeout::Error => e
-        raise StepFailed.new(step.name, e)
-      rescue Textus::Error
-        raise
-      rescue StandardError => e
-        raise StepFailed.new(step.name, e)
-      end
-
-      def publish(key, data, ctx)
-        blk = @definition.publish_block
-        return blk.call(data, ctx) if blk && blk != :default
-
-        built_in_publish(key, data, ctx)
-      end
-
-      def built_in_publish(key, data, ctx)
-        normalized = Textus::Format.data_to_payload(data, ctx.entry.format)
-        guard_map = @container.manifest.rules.for(key).guard
-        rule_preds = guard_map ? Array(guard_map["converge"]) : []
-        Textus::Manifest::Policy::Predicates.evaluate(
-          manifest: @container.manifest, schemas: @container.schemas,
-          action: :converge, actor: @call.role, key: key,
-          rule_predicates: rule_preds
-        )
-        Textus::Store::Entry::Writer.from(container: @container, call: @call).put(
-          key,
-          mentry: ctx.entry,
-          payload: Textus::Value::Payload.new(**normalized),
-        )
-        Textus::Produce::Publisher.call(container: @container, call: @call, key: key)
-      end
     end
   end
 end

data/lib/textus/workflow/scheduler.rb

@@ -0,0 +1,45 @@
+module Textus
+  module Workflow
+    class Scheduler
+      def initialize(registry:, workflow_queue:, reader:)
+        @registry = registry
+        @workflow_queue = workflow_queue
+        @reader = reader
+      end
+
+      def seed_expired
+        seeded = 0
+        @registry.definitions.each do |wf|
+          next unless wf.ttl && wf.save_to
+
+          lane = wf.save_to.split(".").first
+          next if @workflow_queue.pending?(event_type: "workflow", key: wf.save_to)
+
+          entry = @reader.call(key: wf.save_to)
+          unless entry
+            @workflow_queue.push(
+              event_type: "workflow", workflow_type: wf.type,
+              key: wf.save_to, lane: lane
+            )
+            seeded += 1
+            next
+          end
+
+          meta = entry.respond_to?(:meta) ? entry.meta : (entry["_meta"] || {})
+          generated_at = meta["generated_at"]
+          next unless generated_at
+
+          age = Time.now - Time.parse(generated_at)
+          next unless age > wf.ttl
+
+          @workflow_queue.push(
+            event_type: "workflow", workflow_type: wf.type,
+            key: wf.save_to, lane: lane
+          )
+          seeded += 1
+        end
+        seeded
+      end
+    end
+  end
+end

data/lib/textus/workflow/step_executor.rb

@@ -0,0 +1,78 @@
+require "timeout"
+require "concurrent"
+
+module Textus
+  module Workflow
+    class StepExecutor
+      DEFAULT_TIMEOUT = 30
+      CONCURRENCY_ADAPTER = Textus::Infra::Adapters::ConcurrencyAdapter.new
+
+      class StepScope
+        include Textus::Workflow::StepHelpers
+
+        def initialize(data, ctx)
+          @data = data
+          @ctx  = ctx
+        end
+
+        def call(callable)
+          instance_exec(@data, @ctx, &callable)
+        end
+      end
+
+      def execute(steps, ctx)
+        data = nil
+        steps.each { |step| data = execute_one(step, data, ctx) }
+        data
+      end
+
+      private
+
+      def execute_one(step, data, ctx)
+        case step
+        when DSL::Step then execute_single(step, data, ctx)
+        when DSL::Parallel then execute_parallel(step, ctx)
+        else raise ArgumentError.new("unknown step type: #{step.class}")
+        end
+      end
+
+      def execute_single(step, data, ctx)
+        scope = StepScope.new(data, ctx)
+        timeout = step.timeout || DEFAULT_TIMEOUT
+        Timeout.timeout(timeout) { scope.call(step.callable) }
+      rescue Timeout::Error => e
+        raise StepFailed.new(step.name, e)
+      rescue Textus::Error
+        raise
+      rescue StandardError => e
+        raise StepFailed.new(step.name, e)
+      end
+
+      def execute_parallel(parallel, ctx)
+        scope = StepScope.new(nil, ctx)
+        promises = parallel.steps.map do |step|
+          CONCURRENCY_ADAPTER.future do
+            timeout = step.timeout || DEFAULT_TIMEOUT
+            Timeout.timeout(timeout) { scope.call(step.callable) }
+          end
+        end
+
+        results = CONCURRENCY_ADAPTER.zip_futures(*promises).value!
+        failures = []
+        outputs = {}
+        results.each_with_index do |result, i|
+          step = parallel.steps[i]
+          if result.fulfilled?
+            outputs[step.name] = result.value!
+          else
+            failures << { step: step.name, error: result.reason.message }
+          end
+        end
+
+        raise ParallelStepFailed.new(failures) unless failures.empty?
+
+        outputs
+      end
+    end
+  end
+end

data/lib/textus/workflow/step_helpers.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "erb"
+
+module Textus
+  module Workflow
+    module StepHelpers
+      def fetch_json(url, headers: {})
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 5
+        http.read_timeout = 30
+
+        request = Net::HTTP::Get.new(uri)
+        headers.each { |k, v| request[k] = v }
+        request["Accept"] ||= "application/json"
+
+        response = http.request(request)
+        raise "HTTP #{response.code} for #{url}" unless response.is_a?(Net::HTTPOK)
+
+        JSON.parse(response.body)
+      end
+
+      def render_template(name, data)
+        path = @container.layout.template_path(name)
+        raise "template not found: #{name}" unless File.exist?(path)
+
+        template = File.read(path)
+        ctx = Textus::Protocol::Produce::Render::Context.new(
+          container: @container, call: @call,
+          key: @ctx&.key, entry: @ctx&.entry
+        )
+        renderer = Textus::Protocol::Produce::Render.new(template, ctx)
+        renderer.bytes_for(data)
+      end
+
+      def merge_hashes(*hashes)
+        hashes.reduce({}) { |acc, h| deep_merge(acc, h) }
+      end
+
+      def pluck(source, *keys)
+        source.slice(*keys)
+      end
+
+      def check_naming(entries, pattern:, code:, fix:)
+        entries.filter_map do |entry|
+          key = entry_value(entry, :key)
+          path = entry_value(entry, :path)
+          name = path && !path.to_s.empty? ? File.basename(path.to_s) : key.to_s.split(".").last
+          next if pattern.match?(name)
+
+          {
+            "code" => code,
+            "level" => "warning",
+            "subject" => key,
+            "message" => "#{key} does not match the required naming pattern #{pattern.inspect}",
+            "fix" => fix,
+          }
+        end
+      end
+
+      private
+
+      def entry_value(entry, key)
+        return entry.public_send(key) if !entry.is_a?(Hash) && entry.respond_to?(key)
+        return entry[key] if entry.is_a?(Hash) && entry.key?(key)
+        return entry[key.to_s] if entry.is_a?(Hash) && entry.key?(key.to_s)
+
+        nil
+      end
+
+      def deep_merge(left_hash, right_hash)
+        left_hash.merge(right_hash) do |_key, old_val, new_val|
+          if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            deep_merge(old_val, new_val)
+          else
+            new_val
+          end
+        end
+      end
+
+      def build_lanes(ctx)
+        data   = ctx.manifest.data
+        policy = ctx.manifest.policy
+        data.declared_lane_kinds.map do |name, kind|
+          writers = policy.writers_for(name).map(&:to_s)
+          { "name" => name.to_s, "kind" => kind.to_s,
+            "purpose" => data.lane_descs[name].to_s, "writers" => writers }
+        end
+      end
+
+      def build_roles(ctx)
+        ctx.manifest.data.role_caps.map do |role, caps|
+          { "name" => role.to_s, "capabilities" => caps.map(&:to_s) }
+        end
+      end
+    end
+  end
+end

data/lib/textus/workflow.rb

@@ -12,17 +12,14 @@ module Textus
 
     class NotFound < Textus::Error
       def initialize(key)
-        super(:workflow_not_found, "no workflow matches key '#{key}'; add a .textus/workflows/*.rb file with match: '#{key}'")
+        super(:workflow_not_found, "no workflow matches key '#{key}'; add a .textus/workflows/*.rb file with on: '#{key}'")
       end
     end
   end
 
   def self.workflow(name, &)
-    collector = Workflow::Collector.current
-    raise "Textus.workflow called outside Workflow::Loader.load_all context" unless collector
-
     defn = Workflow::DSL::Definition.new(name)
     defn.instance_eval(&)
-    collector.register(defn)
+    Workflow::DSL::Definition.register(defn)
   end
 end

data/lib/textus.rb

@@ -1,9 +1,21 @@
 require "zeitwerk"
 require_relative "textus/version"
 require_relative "textus/errors"
-require_relative "textus/surface/mcp"
+
+# Declare the MCP namespace before Zeitwerk encounters surface/mcp/errors.rb,
+# which is pre-required below because its filename (errors.rb) does not match
+# its constant name (ToolError) and cannot be managed by Zeitwerk.
+module Textus
+  module Surface
+    module MCP
+    end
+  end
+end
+
 require_relative "textus/surface/mcp/errors"
 
+require "sinatra/base"
+
 loader = Zeitwerk::Loader.for_gem
 loader.inflector.inflect(
   "cli" => "CLI",
@@ -14,23 +26,11 @@ loader.inflector.inflect(
   "dsl" => "DSL",
 )
 loader.ignore(File.expand_path("textus/errors.rb", __dir__))
-loader.ignore(File.expand_path("textus/surface/mcp.rb", __dir__))
 loader.ignore(File.expand_path("textus/surface/mcp/errors.rb", __dir__))
-loader.ignore(File.expand_path("textus/workflow/errors.rb", __dir__))
 loader.ignore(File.expand_path("textus/init/templates", __dir__))
-loader.ignore(File.expand_path("textus/produce/acquire", __dir__))
+loader.ignore(File.expand_path("textus/protocol/init/templates", __dir__))
+loader.ignore(File.expand_path("textus/protocol/verb_registry/verbs", __dir__))
 loader.setup
 loader.eager_load
 
-Textus::Boot::CLI_VERBS = Textus::Boot.build_cli_verbs.freeze
-
-module Textus
-  def self.workflow(name, &)
-    collector = Workflow::Collector.current
-    raise "Textus.workflow called outside Workflow::Loader.load_all context" unless collector
-
-    defn = Workflow::DSL::Definition.new(name)
-    defn.instance_eval(&)
-    collector.register(defn)
-  end
-end
+Textus::Protocol::Boot::CLI_VERBS = Textus::Protocol::Boot::Catalog.build.freeze