textus 0.52.0 → 0.54.0

data/lib/textus/maintenance/key_delete_prefix.rb

@@ -1,48 +0,0 @@
-module Textus
-  module Maintenance
-    # Bulk-delete every leaf key under `prefix`.
-    class KeyDeletePrefix
-      extend Textus::Contract::DSL
-
-      verb     :key_delete_prefix
-      summary  "Bulk-delete every leaf key under prefix."
-      surfaces :cli, :mcp
-      cli      "key delete-prefix"
-      arg :prefix,  String, required: true, positional: true, description: "every leaf key under this dotted prefix is deleted"
-      arg :dry_run, :boolean, default: false,
-                              description: "when true, returns the keys that would be deleted without deleting them; " \
-                                           "defaults to false, so omitting it deletes immediately"
-      view { |v, _i| v.to_h }
-
-      def initialize(container:, call:)
-        @container    = container
-        @call         = call
-      end
-
-      def call(prefix, dry_run: false)
-        raise UsageError.new("prefix required") if prefix.nil? || prefix.empty?
-
-        leaves = Read::List.new(container: @container)
-                           .call(prefix: prefix)
-                           .map { |r| r.is_a?(Hash) ? (r["key"] || r[:key]) : r }
-
-        warnings = leaves.empty? ? ["no keys under #{prefix}"] : []
-        steps = leaves.map { |k| { "op" => "delete", "key" => k } }
-
-        plan = Plan.new(steps: steps, warnings: warnings)
-        return plan if dry_run
-
-        steps.each do |s|
-          delete.call(s["key"])
-        end
-        plan
-      end
-
-      private
-
-      def delete
-        Write::KeyDelete.new(container: @container, call: @call)
-      end
-    end
-  end
-end

data/lib/textus/maintenance/key_mv_prefix.rb

@@ -1,68 +0,0 @@
-module Textus
-  module Maintenance
-    # Bulk-rename every leaf key under `from_prefix` to `to_prefix`.
-    # Calls Write::KeyMv directly for each entry — emits one audit row per file moved.
-    class KeyMvPrefix
-      extend Textus::Contract::DSL
-
-      verb     :key_mv_prefix
-      summary  "Bulk-rename every leaf key under from_prefix to to_prefix. Dry-run returns a Plan; apply with dry_run: false."
-      surfaces :cli, :mcp
-      cli      "key mv-prefix"
-      arg :from_prefix, String, required: true, positional: true, description: "dotted prefix whose leaf keys are renamed"
-      arg :to_prefix,   String, required: true, positional: true, description: "dotted prefix the keys are renamed to"
-      arg :dry_run,     :boolean, default: false,
-                                  description: "when true, returns the planned moves without applying them; " \
-                                               "defaults to false, so omitting it applies the rename immediately"
-      view { |v, _i| v.to_h }
-
-      def initialize(container:, call:)
-        @container    = container
-        @call         = call
-      end
-
-      def call(from_prefix, to_prefix, dry_run: false)
-        raise UsageError.new("from_prefix and to_prefix required") if from_prefix.nil? || to_prefix.nil?
-
-        leaves = list_leaves_under(from_prefix)
-
-        # When from_prefix is itself a leaf, `delete_prefix("#{from_prefix}.")`
-        # finds no trailing dot to strip, so the tail keeps the whole key and the
-        # move silently targets "to_prefix.<full-from_prefix>". Refuse it — a
-        # single-key rename is `mv`'s job, not the bulk prefix verb's.
-        if leaves.include?(from_prefix)
-          raise UsageError.new("from_prefix '#{from_prefix}' is itself a leaf — use `mv` to rename a single key")
-        end
-
-        warnings = []
-        warnings << "no keys under #{from_prefix}" if leaves.empty?
-
-        steps = leaves.map do |old_key|
-          tail = old_key.delete_prefix("#{from_prefix}.")
-          new_key = "#{to_prefix}.#{tail}"
-          { "op" => "mv", "from" => old_key, "to" => new_key }
-        end
-
-        plan = Plan.new(steps: steps, warnings: warnings)
-        return plan if dry_run
-
-        steps.each do |s|
-          mv.call(s["from"], s["to"], dry_run: false)
-        end
-        plan
-      end
-
-      private
-
-      def list_leaves_under(prefix)
-        Read::List.new(container: @container)
-                  .call(prefix: prefix)
-                  .map { |row| row.is_a?(Hash) ? (row["key"] || row[:key]) : row }
-      end
-
-      def mv
-        Write::KeyMv.new(container: @container, call: @call)
-      end
-    end
-  end
-end

data/lib/textus/maintenance/retention/apply.rb

@@ -1,52 +0,0 @@
-require "fileutils"
-
-module Textus
-  module Maintenance
-    module Retention
-      # The destructive half of convergence: apply retention rows (drop/archive).
-      # Lifted verbatim from the legacy reconcile apply/archive_leaf so drain/serve and
-      # the `sweep` job handler share one path. Runs as the caller's role — never
-      # self-elevates (ADR 0079/0093: destructiveness decides authority).
-      class Apply
-        def initialize(container:, call:)
-          @container = container
-          @call = call
-        end
-
-        def call(rows)
-          out = { dropped: [], archived: [], failed: [] }
-          delete = Write::KeyDelete.new(container: @container, call: @call)
-          rows.each do |row|
-            key = row["key"]
-            begin
-              case row["action"]
-              when "drop"
-                delete.call(key)
-                out[:dropped] << key
-              when "archive"
-                archive_leaf(row)
-                delete.call(key)
-                out[:archived] << key
-              end
-            rescue Textus::Error => e
-              out[:failed] << { "key" => key, "error" => e.message }
-            end
-          end
-          out
-        end
-
-        private
-
-        # Copy the leaf into <store>/archive/<relative-path> before deletion.
-        def archive_leaf(row)
-          src  = row["path"]
-          root = @container.root.to_s
-          rel  = src.delete_prefix("#{root}/")
-          dest = File.join(root, "archive", rel)
-          FileUtils.mkdir_p(File.dirname(dest))
-          FileUtils.cp(src, dest)
-        end
-      end
-    end
-  end
-end

data/lib/textus/maintenance/rule_lint.rb

@@ -1,66 +0,0 @@
-require "yaml"
-
-module Textus
-  module Maintenance
-    # Compare the live manifest's `rules:` block against a candidate
-    # YAML string. Returns a Plan describing rule additions/removals/
-    # changes. Does NOT write anything.
-    class RuleLint
-      extend Textus::Contract::DSL
-
-      verb     :rule_lint
-      summary  "Diff candidate manifest YAML's rules against the live manifest. No writes."
-      surfaces :cli, :mcp
-      cli      "rule lint"
-      arg :candidate_yaml, String, required: true, wire_name: :against, source: :file,
-                                   description: "path to candidate manifest YAML; its `rules:` block is diffed against the live manifest"
-      view { |v, _i| v.to_h }
-
-      def initialize(container:, call:)
-        @container = container
-        @call      = call
-        @root      = container.root
-      end
-
-      def call(candidate_yaml:)
-        live_rules      = current_rules
-        candidate_rules = parse_candidate(candidate_yaml)
-
-        live_by_match      = live_rules.to_h { |r| [r["match"], r] }
-        candidate_by_match = candidate_rules.to_h { |r| [r["match"], r] }
-
-        steps = (candidate_by_match.keys - live_by_match.keys).map do |m|
-          { "op" => "add_rule", "match" => m, "rule" => candidate_by_match[m] }
-        end
-        (live_by_match.keys - candidate_by_match.keys).each do |m|
-          steps << { "op" => "remove_rule", "match" => m }
-        end
-        (live_by_match.keys & candidate_by_match.keys).each do |m|
-          next if live_by_match[m] == candidate_by_match[m]
-
-          steps << { "op" => "change_rule", "match" => m,
-                     "from" => live_by_match[m], "to" => candidate_by_match[m] }
-        end
-
-        Plan.new(steps: steps, warnings: [])
-      end
-
-      private
-
-      def current_rules
-        raw = YAML.safe_load_file(File.join(@root, "manifest.yaml"),
-                                  permitted_classes: [Symbol], aliases: false)
-        Array(raw["rules"])
-      end
-
-      def parse_candidate(yaml_text)
-        raw = YAML.safe_load(yaml_text, permitted_classes: [Symbol], aliases: false)
-        raise UsageError.new("candidate is not a YAML mapping") unless raw.is_a?(Hash)
-
-        Array(raw["rules"])
-      rescue Psych::Exception => e
-        raise UsageError.new("candidate YAML parse error: #{e.message}")
-      end
-    end
-  end
-end

data/lib/textus/maintenance/serve.rb

@@ -1,30 +0,0 @@
-module Textus
-  module Maintenance
-    # The convergence daemon loop: seed scheduled work (TTL re-pull + sweep),
-    # reclaim crashed leases, drain the queue, sleep, repeat. `tick` is one
-    # iteration (unit-testable); `run` loops forever. Drains serially for the
-    # same reason as Drain — each produce job self-locks, so running them in turn
-    # keeps the build lock uncontended.
-    class Serve
-      def initialize(container:, call:)
-        @container = container
-        @call = call
-        @queue = Textus::Ports::Queue.new(root: container.root)
-      end
-
-      def tick
-        Textus::Jobs::Scheduler.new(container: @container, queue: @queue).run_once
-        @queue.reclaim(now: Textus::Ports::Clock.new.now)
-        Worker.for(container: @container, queue: @queue).drain
-      end
-
-      def run(poll: nil)
-        interval = poll || @container.manifest.data.worker_config[:poll]
-        loop do
-          tick
-          sleep(interval)
-        end
-      end
-    end
-  end
-end

data/lib/textus/maintenance/worker.rb

@@ -1,74 +0,0 @@
-module Textus
-  module Maintenance
-    # Drains the job queue: lease a job, look up its handler in the registry, run
-    # it (as the job's stamped authority — wired in a later phase), then ack on
-    # success or fail (requeue/dead-letter) on a raise. `drain` runs until the
-    # queue is empty and returns a summary. Delivery is at-least-once.
-    class Worker
-      Summary = Struct.new(:completed, :failed, keyword_init: true)
-
-      # The standard convergence worker: the closed handler allow-list plus the
-      # lease TTL from worker_config. Both `drain` and `serve` build it this way.
-      def self.for(container:, queue:)
-        new(
-          queue: queue, registry: Textus::Jobs::Handlers.registry,
-          container: container, lease_ttl: container.manifest.data.worker_config[:lease_ttl]
-        )
-      end
-
-      def initialize(queue:, registry:, container:, lease_ttl: 60)
-        @queue = queue
-        @registry = registry
-        @container = container
-        @lease_ttl = lease_ttl
-      end
-
-      def drain(worker_id: "drain-#{Process.pid}")
-        completed = 0
-        failed = 0
-        loop do
-          leased = @queue.lease(worker_id: worker_id, lease_ttl: @lease_ttl)
-          break unless leased
-
-          case run_one(leased)
-          when :completed     then completed += 1
-          when :dead_lettered then failed += 1
-            # :requeued -> a transient failure; it re-leases on a later iteration
-          end
-        end
-        Summary.new(completed: completed, failed: failed)
-      end
-
-      def drain_pool(pool: 4)
-        summaries = []
-        mutex = Mutex.new
-        threads = Array.new(pool) do |i|
-          Thread.new do
-            s = drain(worker_id: "pool-#{Process.pid}-#{i}")
-            mutex.synchronize { summaries << s }
-          end
-        end
-        threads.each(&:join)
-        Summary.new(
-          completed: summaries.sum(&:completed),
-          failed: summaries.sum(&:failed),
-        )
-      end
-
-      private
-
-      # Returns :completed on ack, or the queue's failure verdict (:requeued |
-      # :dead_lettered) on a raise. A requeued job re-leases on the next loop
-      # iteration, so a transient failure still drains; only a dead-letter is a
-      # terminal failure that counts toward the summary.
-      def run_one(leased)
-        entry = @registry.lookup(leased.job.type)
-        entry.handler.call(job: leased.job, container: @container)
-        @queue.ack(leased)
-        :completed
-      rescue StandardError => e
-        @queue.fail(leased, error: e.message)
-      end
-    end
-  end
-end

data/lib/textus/maintenance/zone_mv.rb

@@ -1,64 +0,0 @@
-require "yaml"
-
-module Textus
-  module Maintenance
-    # Rename a zone — rewrites the manifest's zones[] entry, rewrites
-    # the `zone:` field on every entry under the old zone, and moves
-    # every file from zones/<old>/ to zones/<new>/.
-    class ZoneMv
-      extend Textus::Contract::DSL
-
-      verb     :zone_mv
-      summary  "Rename a zone — manifest + files. Refuses if destination exists."
-      surfaces :cli, :mcp
-      cli      "zone mv"
-      arg :from,    String, required: true, positional: true, description: "current zone name"
-      arg :to,      String, required: true, positional: true, description: "new zone name; refused if a zone by this name already exists"
-      arg :dry_run, :boolean, default: false,
-                              description: "when true, returns the planned zone move without applying it; " \
-                                           "defaults to false, so omitting it applies the move immediately"
-      view { |v, _i| v.to_h }
-
-      def initialize(container:, call:)
-        @container = container
-        @call      = call
-        @manifest  = container.manifest
-        @root      = container.root
-      end
-
-      def call(from, to, dry_run: false)
-        raise UsageError.new("from and to required") if from.nil? || to.nil? || from.empty? || to.empty?
-        raise UsageError.new("zone '#{from}' not declared") unless @manifest.data.declared_zone_kinds.key?(from)
-
-        dest_dir = File.join(@root, "zones", to)
-        raise UsageError.new("destination 'zones/#{to}' already exists") if File.exist?(dest_dir)
-
-        affected_keys = @manifest.data.entries.select { |e| e.zone == from }.map(&:key)
-
-        steps  = [{ "op" => "rename_zone", "from" => from, "to" => to }]
-        steps += affected_keys.map { |k| { "op" => "mv", "from" => k, "to" => "#{to}#{k[from.length..]}" } }
-
-        plan = Plan.new(steps: steps, warnings: [])
-        return plan if dry_run
-
-        rewrite_manifest!(from, to)
-        FileUtils.mv(File.join(@root, "zones", from), dest_dir)
-        plan
-      end
-
-      private
-
-      def rewrite_manifest!(from, to)
-        path = File.join(@root, "manifest.yaml")
-        raw = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: false)
-        raw["zones"].each { |z| z["name"] = to if z["name"] == from }
-        raw["entries"].each do |e|
-          e["zone"] = to if e["zone"] == from
-          e["key"]  = e["key"].sub(/\A#{Regexp.escape(from)}(\.|\z)/, "#{to}\\1")
-          e["path"] = e["path"].sub(%r{\A#{Regexp.escape(from)}(/|\z)}, "#{to}\\1")
-        end
-        File.write(path, YAML.dump(raw))
-      end
-    end
-  end
-end

data/lib/textus/maintenance.rb

@@ -1,15 +0,0 @@
-module Textus
-  # Bulk and structural changes to a textus store. Each use case returns
-  # a Plan when called with dry_run: true, and applies the plan when
-  # called with dry_run: false.
-  module Maintenance
-    # A Plan is a JSON-shaped preview. Steps are op-tagged hashes the
-    # use case knows how to apply. Warnings are strings surfaced to
-    # the operator (skipped keys, ambiguities).
-    Plan = Data.define(:steps, :warnings) do
-      def to_h
-        { "steps" => steps, "warnings" => warnings }
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry/validators/events.rb

@@ -1,22 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      module Validators
-        module Events
-          def self.call(entry, policy: nil) # rubocop:disable Lint/UnusedMethodArgument
-            pubsub_events = Textus::Hooks::Catalog::PUBSUB.keys
-            events = entry.events
-            events.each_key do |evt|
-              next if pubsub_events.include?(evt.to_sym)
-
-              raise UsageError.new(
-                "entry '#{entry.key}': unknown event '#{evt}' in events: block. " \
-                "Known events: #{pubsub_events.join(", ")}.",
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/mcp/catalog.rb

@@ -1,70 +0,0 @@
-module Textus
-  module MCP
-    # Derives the entire MCP tool surface from the per-verb contracts
-    # (ADR 0039). `tool_schemas` feeds tools/list; `call` is the generic
-    # tools/call dispatch: map JSON args -> (positional, keyword) per the
-    # contract, invoke the verb through the role scope, then shape the
-    # return value with the contract's default view. No per-tool code.
-    module Catalog
-      module_function
-
-      # Contracts of every MCP-surfaced verb, in Dispatcher order.
-      def specs
-        Textus::Dispatcher::VERBS.values
-                                 .select { |k| mcp_surfaced?(k) }
-                                 .map(&:contract)
-      end
-
-      def tool_schemas
-        specs.map do |s|
-          { name: s.verb.to_s, description: s.summary, inputSchema: s.input_schema }
-        end.freeze
-      end
-
-      def names
-        specs.map { |s| s.verb.to_s }
-      end
-
-      # MCP-surfaced read verbs, by Dispatcher class namespace — the agent's
-      # real read/discovery surface. `boot.agent_quickstart.read_verbs` derives
-      # from this so it can never advertise a verb the agent cannot call, nor
-      # omit one it can (ADR 0056). Excludes Write/Maintenance.
-      def read_verbs
-        Textus::Dispatcher::VERBS
-          .select { |_verb, klass| mcp_surfaced?(klass) && klass.name.start_with?("Textus::Read::") }
-          .keys.map(&:to_s)
-      end
-
-      # MCP-surfaced write verbs, by Dispatcher class namespace — the mirror of
-      # read_verbs for the write side. `boot.agent_quickstart.write_verbs` derives
-      # from this so it advertises bare verb names the agent can call (no `--as`/
-      # `--stdin` CLI framing), finishing the de-CLI-ing of the agent surface
-      # (ADR 0056, ADR 0057).
-      def write_verbs
-        Textus::Dispatcher::VERBS
-          .select { |_verb, klass| mcp_surfaced?(klass) && klass.name.start_with?("Textus::Write::") }
-          .keys.map(&:to_s)
-      end
-
-      def mcp_surfaced?(klass)
-        klass.respond_to?(:contract?) && klass.contract? && klass.contract.mcp?
-      end
-
-      def call(name, session:, store:, args:)
-        klass = Textus::Dispatcher::VERBS[name.to_sym]
-        raise ToolError.new("unknown tool: #{name}") unless klass && mcp_surfaced?(klass)
-
-        spec = klass.contract
-        inputs = Textus::Contract::Binder.inputs_from_wire(spec, args)
-        result = store.as(session.role).dispatch_bound(spec.verb, inputs, session: session)
-        Textus::Contract::View.render(spec, :default, result, inputs)
-      rescue Textus::Contract::MissingArgs => e
-        raise ToolError.new("#{spec.verb}: missing #{e.missing.map { |a| a.wire.to_s }.join(", ")}")
-      rescue ContractDrift, CursorExpired
-        raise
-      rescue Textus::Error => e
-        raise ToolError.new("#{name}: #{e.message}")
-      end
-    end
-  end
-end

data/lib/textus/mcp/errors.rb

@@ -1,32 +0,0 @@
-module Textus
-  module MCP
-    # Manifest fingerprint changed mid-session. Client should re-boot.
-    class ContractDrift < Textus::Error
-      JSONRPC_CODE = -32_001
-
-      def initialize(message, details: {})
-        super("contract_drift", message, details: details)
-      end
-    end
-
-    # Audit cursor fell off the keep window. Client should re-boot and
-    # resume from the new latest_seq.
-    class CursorExpired < Textus::Error
-      JSONRPC_CODE = -32_002
-
-      def initialize(message, details: {})
-        super("cursor_expired", message, details: details)
-      end
-    end
-
-    # Tool execution failed (validation, authorization, IO). Wraps an
-    # underlying Textus::Error or generic StandardError.
-    class ToolError < Textus::Error
-      JSONRPC_CODE = -32_000
-
-      def initialize(message, details: {})
-        super("tool_error", message, details: details)
-      end
-    end
-  end
-end

data/lib/textus/mcp/server.rb

@@ -1,138 +0,0 @@
-require "json"
-
-module Textus
-  module MCP
-    # Stdio JSON-RPC 2.0 server speaking MCP draft 2024-11-05. One line per
-    # message (NDJSON). Holds a single Session for the lifetime of stdin.
-    class Server
-      PROTOCOL_VERSION = "2024-11-05"
-      SERVER_INFO = { "name" => "textus", "version" => Textus::VERSION }.freeze
-
-      def initialize(store:, stdin: $stdin, stdout: $stdout, role: Textus::Role::DEFAULT)
-        @store   = store
-        @stdin   = stdin
-        @stdout  = stdout
-        @role    = role
-        @session = nil
-      end
-
-      def run
-        @stdin.each_line do |line|
-          line = line.strip
-          next if line.empty?
-
-          handle_line(line)
-        end
-      end
-
-      private
-
-      def handle_line(line)
-        msg = JSON.parse(line)
-      rescue JSON::ParserError => e
-        emit_error(nil, -32_700, "parse error: #{e.message}")
-      else
-        dispatch(msg)
-      end
-
-      def dispatch(msg)
-        rid = msg["id"]
-        case msg["method"]
-        when "initialize"                then handle_initialize(rid, msg["params"] || {})
-        when "tools/list"                then handle_tools_list(rid)
-        when "tools/call"                then handle_tools_call(rid, msg["params"] || {})
-        when "ping"                      then emit_result(rid, {})
-        when "shutdown"                  then emit_result(rid, nil)
-        when "notifications/initialized" then nil
-        else emit_error(rid, -32_601, "method not found: #{msg["method"]}")
-        end
-      end
-
-      def handle_initialize(rid, _params)
-        # The acting role IS the resolved connection role (ADR 0040): the MCP
-        # transport defaults to `agent`, which can write the queue, so its
-        # propose_zone resolves directly. If a connection's role cannot propose,
-        # propose_zone is nil and the `propose` tool reports that honestly.
-        propose_zone = @store.manifest.policy.propose_zone_for(@role)
-
-        @session = Session.new(
-          role: @role,
-          cursor: @store.audit_log.latest_seq,
-          propose_zone: propose_zone,
-          contract_etag: contract_etag,
-        )
-
-        # ADR 0075: announce the connection to connect-time hooks with the
-        # resolved role. Distinct from :store_loaded (fired at Store.new under
-        # the default role, before any connection's role is known).
-        @store.events.publish(
-          :session_opened,
-          ctx: Hooks::Context.new(scope: @store.as(@role)),
-          role: @role,
-          cursor: @session.cursor,
-        )
-
-        emit_result(rid, {
-                      "protocolVersion" => PROTOCOL_VERSION,
-                      "serverInfo" => SERVER_INFO,
-                      "capabilities" => { "tools" => {} },
-                    })
-      end
-
-      def handle_tools_list(rid)
-        emit_result(rid, { "tools" => Catalog.tool_schemas })
-      end
-
-      def handle_tools_call(rid, params)
-        unless @session
-          emit_error(rid, -32_002, "session not initialized; call 'initialize' first")
-          return
-        end
-
-        name = params["name"]
-        args = params["arguments"] || {}
-
-        # ADR 0083: the contract-drift guard gates mutating verbs — every MCP
-        # verb that is NOT a pure read (Write:: + the destructive Maintenance::
-        # verbs drain/zone_mv/key_*_prefix). Reads and boot bypass it (a stale
-        # read returns on-disk truth; boot re-orients). Keying on read_verbs
-        # (not write_verbs) keeps the destructive Maintenance:: verbs gated.
-        @session.check_etag!(contract_etag) unless Catalog.read_verbs.include?(name)
-
-        result = Catalog.call(name, session: @session, store: @store, args: args)
-        @session = @session.advance_cursor(@store.audit_log.latest_seq) if name == "pulse"
-        @session = @session.with(contract_etag: contract_etag) if name == "boot"
-
-        emit_result(rid, {
-                      "content" => [{ "type" => "text", "text" => JSON.dump(result) }],
-                      "isError" => false,
-                    })
-      rescue ContractDrift => e
-        emit_error(rid, ContractDrift::JSONRPC_CODE, e.message)
-      rescue CursorExpired => e
-        emit_error(rid, CursorExpired::JSONRPC_CODE, e.message)
-      rescue ToolError => e
-        emit_error(rid, ToolError::JSONRPC_CODE, e.message)
-      rescue StandardError => e
-        emit_error(rid, -32_603, "internal: #{e.class}: #{e.message}")
-      end
-
-      def contract_etag
-        Textus::Etag.for_contract(@store.root)
-      end
-
-      def emit_result(rid, result)
-        write({ "jsonrpc" => "2.0", "id" => rid, "result" => result })
-      end
-
-      def emit_error(rid, code, message)
-        write({ "jsonrpc" => "2.0", "id" => rid, "error" => { "code" => code, "message" => message } })
-      end
-
-      def write(obj)
-        @stdout.puts(JSON.dump(obj))
-        @stdout.flush
-      end
-    end
-  end
-end