textus 0.55.1 → 0.56.0

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,10 +1,21 @@
 require "zeitwerk"
-require "dry-monads"
 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",
@@ -15,86 +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__))
-# Scaffold sources copied verbatim into user stores by `textus init`. They are
-# templates for user-owned step classes, not gem constants — Zeitwerk must not
-# manage or eager-load them.
 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
 
-# Verb symbol → Action class mapping. Replaces Textus::Dispatcher::VERBS.
-Textus::Action::VERBS = {
-  put: Textus::Action::Put,
-  propose: Textus::Action::Propose,
-  key_delete: Textus::Action::KeyDelete,
-  key_mv: Textus::Action::KeyMv,
-  accept: Textus::Action::Accept,
-  reject: Textus::Action::Reject,
-  enqueue: Textus::Action::Enqueue,
-  get: Textus::Action::Get,
-  ingest: Textus::Action::Ingest,
-  list: Textus::Action::List,
-  where: Textus::Action::Where,
-  uid: Textus::Action::Uid,
-  blame: Textus::Action::Blame,
-  audit: Textus::Action::Audit,
-  # materialize, refresh, sweep are Worker-only — not in VERBS
-  deps: Textus::Action::Deps,
-  rdeps: Textus::Action::Rdeps,
-  pulse: Textus::Action::Pulse,
-  rule_explain: Textus::Action::RuleExplain,
-  rule_list: Textus::Action::RuleList,
-  published: Textus::Action::Published,
-  schema_show: Textus::Action::SchemaEnvelope,
-  doctor: Textus::Action::Doctor,
-  boot: Textus::Action::Boot,
-  jobs: Textus::Action::Jobs,
-  data_mv: Textus::Action::DataMv,
-  key_mv_prefix: Textus::Action::KeyMvPrefix,
-  key_delete_prefix: Textus::Action::KeyDeletePrefix,
-  drain: Textus::Action::Drain,
-  rule_lint: Textus::Action::RuleLint,
-}.freeze
-
-# Derive CLI_VERBS after VERBS is available.
-Textus::Boot::CLI_VERBS = Textus::Boot.build_cli_verbs.freeze
-
-# Dynamic verb methods on Store (deferred after VERBS is defined).
-Textus::Action::VERBS.each_key do |verb|
-  Textus::Store.define_method(verb) do |*args, role: Textus::Value::Role::DEFAULT, **kwargs|
-    as(role).public_send(verb, *args, **kwargs)
-  end
-
-  Textus::Surface::RoleScope.define_method(verb) do |*args, **kwargs|
-    klass     = Textus::Action::VERBS[verb]
-    inputs    = if klass.respond_to?(:contract?) && klass.contract?
-                  Textus::Gate::Binder.inputs_from_ordered(klass.contract, args, kwargs)
-                else
-                  kwargs.transform_keys(&:to_sym)
-                end
-
-    role_value = if klass.respond_to?(:contract?) && klass.contract? &&
-                    klass.contract.args.any? { |a| a.name == :role }
-                   inputs[:role]
-                 else
-                   @role
-                 end
-
-    @container.gate.dispatch(spec: klass.contract, inputs: inputs, role: role_value, correlation_id: @correlation_id)
-  end
-end
-
-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