enola 0.0.0 → 0.4.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fd2d396d3b108ec57cede0d8362e11fef4a6710352bc83b6336d205eace47aa
-  data.tar.gz: b3f11c1c771237daf33b2e45af86f14cdb98b4756a330e60dccfae2fc7106a39
+  metadata.gz: 84ee668ecfaed2e6d8ebc55fe5054e1635300502f762887f2d7b96660beb908f
+  data.tar.gz: 2905c89cad26afb7f6226515c7b3620ed6e089c16ff5886398f4043deda50360
 SHA512:
-  metadata.gz: 73dd9a25719c7206386bf842b6e871c1ea05793b045d7899af11abc85883001225e79f1f7b2d53414d9ec10676136d3c09e7ae42d55a811f0be4e457a36fdd66
-  data.tar.gz: b3787673babd9399a3c625ed723a1cdaf7ead0d1e819fe88faeed346bba8c87163e6201f1ce4ad3514baa0f6791f6bb55eb3be684be0cdf8781a8fc8340b7f60
+  metadata.gz: e8b8a19a54c9f13be8b2dd6a1d62b5cb999d14a7ff959f0771ca25cfc63b6fac3822bc31ccd676cc44c60e4106401c626f9fc1e7b2802a68d3f5f68a0c23c322
+  data.tar.gz: 42a9119e1b7d33d1a20b3e3d9f7a79f2c8199de3599365f6d13674db19a968aba0a749180014b061bb413940a17ae8212ebf63181ee40302acdcae20952c1bb5

data/CHANGELOG.md

@@ -0,0 +1,78 @@
+## munola 0.4.4.2 and munola-rb 0.4.4.2 (2026-08-23)
+
+munola follows the channel it drives. Its binary is now cut from the stable
+channel after it took eight changes measured against a Ruby architecture
+linter, so the gem's version moves with the release it fetches. The Rails
+layer is its own gem, `munola-rb`, the way `enola-rb` is for the upstream
+channel; `require "munola"` loads no Rails. A catalogue recipe the binary
+already binds is no longer bound a second time.
+
+## enola 0.4.4.1 and enola-rb 0.4.4.1 (2026-08-23)
+
+Wrapper fixes on the same upstream release. A test that set the channel put
+back upstream rather than what it found, so on some orderings a channel gem's
+own installation read as upstream. The Rails layer packaged its generator
+through a glob wide enough to take another channel's; it now packages its own.
+Both gems still drive upstream v0.4.4.
+
+## munola-rb 0.4.4.1 (2026-08-23)
+
+The Rails layer over munola, what enola-rb is to enola: `rails generate
+munola:install [--tenant-column COLUMN]` writes the starter laws, the
+bindings the binary's own init picks and the munola catalogue, and the
+enola:init, enola:snapshot and enola:check tasks drive munola's binary
+because munola installs its own resolver. The generator and the railtie
+move here out of the munola gem, so `require "munola"` loads no Rails and a
+project that only drives the binary carries no Rails machinery. The recipe
+catalogue, the detection and the tenant-column argument stay munola's.
+
+`Enola.resolver_factory` is readable as well as writable, so whoever
+replaces it can put back what was installed rather than what it assumed.
+
+## munola 0.4.4.1 (2026-08-23)
+
+The wrapper over the munola channel, first release with an implementation.
+`munola init` writes the starter laws and upstream's bindings the way
+`enola:install` does, then the recipe catalogue from enola-guides, binds the
+recipes the tree shows a need for, fills the tenant foreign-key template
+from the schema, writes `mcp-arch.yaml` with Prism and Rubydex on and fetches
+the Rubydex library; `munola --version` names the munola version, its
+upstream base and the binary that answered; `MUNOLA_BINARY` names a binary
+to drive until the first munola release is cut. The channel's tag shape is
+`munola-v<version>` on the fork's releases.
+
+## enola 0.4.4 (2026-08-23)
+
+The wrapper, first release with an implementation: a pure-Ruby `enola`
+executable that drives upstream's v0.4.4. The binary is fetched on first use
+from the release for the running platform, verified against the sha256 the
+release publishes, and kept under `~/.cache/enola/upstream/0.4.4/`; a binary on
+PATH is used only when it answers the pinned version; offline with an empty
+cache is a refusal that names the cache and the release. Every argument and
+exit code is forwarded; `--verbose` adds one stderr line naming channel,
+version and where the binary came from; `enola --wrapper-probe` prints the
+channel, pin, found version and which surfaces the binary answers.
+
+Both providers by default: the gem vendors upstream's Prism provider script
+at the pinned version and depends on the `prism` gem; `enola init` writes
+`mcp-arch.yaml` with Prism (run by this Ruby) and Rubydex on, then runs the
+binary's `constraints init`; the Rubydex engine library is fetched once per
+binary version after the binary itself, a failure printed once as a named
+skip. `Enola::Config.write_default` and `Enola::Providers` are the seams the
+Rails layer and munola call.
+
+## enola-rb 0.4.4 (2026-08-23)
+
+The Rails layer, first release with an implementation. `rails generate
+enola:install` writes `enola/constraints/` from the enola-guides starter laws,
+binds the recipes the binary's own `constraints init` picks, writes the rest
+as commented bindings and ignores `.enola/`; the `enola:init`,
+`enola:snapshot` and `enola:check` rake tasks drive the binary the `enola` gem
+fetches. A surface the pinned binary lacks is refused by name with the remedy;
+an absent binary still leaves the laws written. Depends on `enola` at the same
+version and on `enola-guides`. The generator writes the provider config first,
+so a fresh app's graph carries Prism and Rubydex facts from its first snapshot.
+
+## munola 0.0.0
+
+Placeholder. `munola` is the same wrapper over another channel. Follows.

data/README.md

@@ -1,13 +1,128 @@
 # enola-rb
 
-Runs [enola](https://github.com/enola-labs/enola), the architecture-graph
-tool, from Ruby, with presets and defaults chosen for Rails stacks.
+Four pure-Ruby gems, one repository, for running
+[enola](https://github.com/enola-labs/enola), the architecture-graph tool,
+from Ruby. None of them carries a binary or compiles anything.
 
-Two channels, picked in your Gemfile. `enola-rb` on its own drives whichever
-enola binary is on your path. Adding the `munola` gem switches it to the build
-this project ships, which carries capabilities not yet in an upstream release.
+Two channels, the same layering on both: `enola` wraps the released upstream
+binary and `enola-rb` adds the Rails layer on it; `munola` wraps the munola
+binary and `munola-rb` adds the Rails layer on that. The Rails code is written
+once, in `enola-rb`, and the munola gems add only what is munola's own.
 
-Presets come from
-[enola-guides](https://github.com/misabegovic/enola-guides).
+## `enola`
 
-Placeholder release. No implementation yet.
+The wrapper of the released enola. Its version is the upstream release it
+drives: `enola 0.4.4` runs enola-labs' v0.4.4.
+
+```ruby
+gem "enola"
+```
+
+```sh
+bundle exec enola --generate .
+bundle exec enola baseline pin .
+bundle exec enola check .
+```
+
+The first command that needs the binary downloads the release for your
+platform (linux, darwin, windows; amd64, arm64), verifies it against the
+sha256 file the same release publishes, and keeps it under
+`~/.cache/enola/upstream/0.4.4/` (`ENOLA_CACHE_DIR` moves the root). An
+`enola` already on your PATH is used only when it answers the pinned version;
+offline with an empty cache is a refusal that names the cache and the release
+rather than a fallback to whatever is installed. Nothing downloads at
+`bundle install`.
+
+Every argument and exit code is forwarded unchanged; the wrapper adds no flag
+of its own to enola's surface. `--verbose` on any command writes one line to
+stderr first, naming the channel, the version and where the binary came from.
+`enola --wrapper-probe` prints the channel, the pin, the version the binary
+answers and which surfaces it has (`constraints`, `providers`, `check`,
+`hook`), read by running them, never by comparing version strings.
+
+This gem is not an enola-labs release; it runs theirs.
+
+## `enola-rb`
+
+The Rails layer over `enola`. It depends on `enola` at the same version and on
+[enola-guides](https://github.com/misabegovic/enola-guides), and adds nothing
+to the binary's surface.
+
+```ruby
+gem "enola-rb"
+```
+
+```sh
+bin/rails generate enola:install
+bin/rake enola:snapshot
+bin/rake enola:check
+```
+
+The generator writes `enola/constraints/` from the guides' starter laws (four
+laws a Rails team keeps, each with its reason), asks the binary's own
+`constraints init` to bind the shipped recipes whose roles resolve in the app,
+writes every other shipped recipe as a commented binding to uncomment once the
+directories exist, and ignores `.enola/`. It reads what `init` wrote rather
+than its exit code, and when the binary cannot be fetched it still writes the
+laws and says so. `enola:snapshot` generates and pins the baseline;
+`enola:check` grades the working tree against it and fails on a new breach of
+a declared law. A surface the pinned binary lacks is refused by name with the
+remedy.
+
+## `munola`
+
+One person's taste on top of enola: the same wrapper over another channel,
+the builds cut from [a fork of enola](https://github.com/misabegovic/enola),
+versioned as the upstream they are built on plus a fourth segment
+(`0.4.4.1` drives a build on v0.4.4), each release naming what differs from
+that upstream. It is offered upstream where it fits and is not positioned
+against it. What it adds is the channel and the catalogue.
+
+```ruby
+gem "munola"
+```
+
+```sh
+bundle exec munola init . --tenant-column company_id
+bundle exec munola --version
+```
+
+`munola init` does what `enola:install` does, then what only munola carries:
+it writes the recipe catalogue the `enola-guides` gem ships (Ember
+conventions, data ownership, API boundaries, background work, a tenant
+foreign key) into `enola/recipes/`, binds the recipes the tree justifies
+(`ember-cli-build.js`, a schema with `app/models`, `config/routes.rb` with
+`app/policies`, `app/tasks`, a column most tables share confirmed against
+`db/schema.rb`) and writes every other one as a commented binding; it fills
+the tenant template from the schema's own table names, never from an
+inflection table; it writes `mcp-arch.yaml` with both Ruby providers on by
+default, Prism through the script the `enola` gem carries and Rubydex built
+into the binary, and fetches the Rubydex library, a failed fetch reported as a
+named skip. It never asks a question. `munola --version` names the munola
+version, the upstream it is built on and which binary answered.
+
+The binary comes from the fork's releases the way `enola`'s comes from
+upstream's, fetched on first use and verified against the sha256 the release
+publishes; `MUNOLA_BINARY=/path/to/enola` names one to drive instead, and
+every command says which answered. `munola` depends on `enola` at its upstream
+version and on `enola-guides` 0.3.1 or later; requiring it loads no Rails.
+
+## `munola-rb`
+
+The Rails layer over `munola`, what `enola-rb` is to `enola`. It depends on
+both at their own versions and adds one generator.
+
+```ruby
+gem "munola-rb"
+```
+
+```sh
+bin/rails generate munola:install --tenant-column company_id
+bin/rake enola:snapshot
+bin/rake enola:check
+```
+
+The generator runs the same install `munola init` does. The rake tasks are
+enola-rb's and need no munola copy: `munola` installs its own resolver when it
+loads, so `enola:snapshot` and `enola:check` drive the munola binary in an app
+that has this gem, and the upstream binary in one that does not.

data/exe/enola

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "enola"
+
+exit Enola::CLI.start(ARGV)

data/lib/enola/channel.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Enola
+  Channel = Struct.new(:name, :release_base, :version, :asset_prefix, :tag_prefix, keyword_init: true) do
+    def asset(platform)
+      "#{asset_prefix}-#{version}-#{platform}.tar.gz"
+    end
+
+    def checksum_asset(platform)
+      "#{asset_prefix}-#{version}-#{platform}.sha256"
+    end
+
+    def tag
+      "#{tag_prefix || 'v'}#{version}"
+    end
+
+    def url(file)
+      "#{release_base.chomp('/')}/#{tag}/#{file}"
+    end
+
+    def cache_dir(root)
+      File.join(root, name, version)
+    end
+
+    def to_s
+      "#{name} #{version}"
+    end
+  end
+
+  Channel::UPSTREAM = Channel.new(
+    name: "upstream",
+    release_base: "https://github.com/enola-labs/enola/releases/download",
+    version: UPSTREAM_VERSION,
+    asset_prefix: "enola"
+  ).freeze
+end

data/lib/enola/cli.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Enola
+  module CLI
+    def self.start(argv, stderr: $stderr, stdout: $stdout)
+      case argv.first
+      when "--wrapper-probe"
+        found = Enola.resolver.resolve
+        stdout.puts JSON.pretty_generate(Probe.new(found.path).report.merge(source: found.source))
+        0
+      when "--wrapper-fetch"
+        stdout.puts Fetcher.new.fetch
+        0
+      when "init"
+        root = argv[1] || "."
+        written = Config.write_default(root)
+        stdout.puts(written ? "wrote #{written}" : "#{Config.path(root)} already exists, left as is")
+        Runner.new(stderr: stderr).run(["constraints", "init", root])
+      else
+        Runner.new.exec(argv)
+      end
+    rescue Error => e
+      stderr.puts "enola: #{e.message}"
+      127
+    end
+  end
+end

data/lib/enola/config.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Enola
+  module Config
+    FILE = "mcp-arch.yaml"
+
+    IGNORE = %w[**/.git/** **/node_modules/** **/vendor/** **/tmp/** **/log/** **/coverage/** **/public/assets/**].freeze
+
+    def self.path(root)
+      File.join(File.expand_path(root), FILE)
+    end
+
+    def self.write_default(root, ruby: Providers.ruby)
+      target = path(root)
+      return nil if File.exist?(target)
+
+      File.write(target, render(ruby: ruby))
+      target
+    end
+
+    def self.render(ruby: Providers.ruby)
+      <<~YAML
+        # Written by the enola gem; edit freely. Both providers are on by default:
+        # Prism runs under the Ruby that runs the gem, Rubydex is built into the
+        # binary and fetched once. Remove one to leave it out of the graph.
+        repo: .
+        repos:
+          - .
+        ignore:
+        #{IGNORE.map { |glob| "  - \"#{glob}\"" }.join("\n")}
+        providers:
+          - name: prism
+            command: [#{ruby.inspect}, #{Providers.prism_script.inspect}]
+            expected_version: "#{Providers.prism_version || '0.1.0'}"
+          - name: rubydex
+            expected_version: "#{Providers::RUBYDEX_EXPECTED_VERSION}"
+      YAML
+    end
+  end
+end

data/lib/enola/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Enola
+  class Error < StandardError; end
+
+  class Unavailable < Error; end
+
+  class Unverified < Error; end
+
+  class UnsupportedPlatform < Error; end
+end

data/lib/enola/fetcher.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "net/http"
+require "open3"
+require "tmpdir"
+require "uri"
+
+module Enola
+  class Fetcher
+    REDIRECTS = 5
+
+    def initialize(channel: Enola.channel, cache_root: Enola.cache_root, platform: Platform.current)
+      @channel = channel
+      @cache_root = cache_root
+      @platform = platform
+    end
+
+    def binary_path
+      File.join(@channel.cache_dir(@cache_root), Platform.windows?(@platform) ? "enola.exe" : "enola")
+    end
+
+    def cached?
+      File.executable?(binary_path)
+    end
+
+    def fetch
+      return binary_path if cached?
+
+      Dir.mktmpdir("enola-fetch") do |work|
+        asset = @channel.asset(@platform)
+        tarball = File.join(work, asset)
+        write(@channel.url(asset), tarball)
+        verify(tarball, read(@channel.url(@channel.checksum_asset(@platform))), asset)
+        unpack(tarball, work)
+      end
+      binary_path
+    end
+
+    private
+
+    def verify(tarball, checksum_text, asset)
+      expected = checksum_text.split.first.to_s.downcase
+      actual = Digest::SHA256.file(tarball).hexdigest
+      return if !expected.empty? && expected == actual
+
+      raise Unverified, "#{asset} did not match the checksum #{@channel.name} published for #{@channel.version} " \
+                        "(expected #{expected.empty? ? 'nothing readable' : expected[0, 12]}, got #{actual[0, 12]}); nothing was installed"
+    end
+
+    def unpack(tarball, work)
+      unpacked = File.join(work, "unpacked")
+      FileUtils.mkdir_p(unpacked)
+      _, err, status = Open3.capture3("tar", "xzf", tarball, "-C", unpacked)
+      raise Unavailable, "could not unpack #{File.basename(tarball)}: #{err.strip}" unless status.success?
+
+      inner = Dir.children(unpacked).find { |name| name.start_with?("#{@channel.asset_prefix}-") && !name.end_with?(".tar.gz") }
+      raise Unavailable, "#{File.basename(tarball)} holds no #{@channel.asset_prefix} binary" unless inner
+
+      dir = @channel.cache_dir(@cache_root)
+      begin
+        FileUtils.mkdir_p(dir)
+      rescue SystemCallError => e
+        raise Unavailable, "cannot write the cache at #{dir} (#{e.message}); set ENOLA_CACHE_DIR to a writable directory"
+      end
+      FileUtils.mv(File.join(unpacked, inner), binary_path, force: true)
+      FileUtils.chmod(0o755, binary_path)
+      %w[LICENSE NOTICE].each do |extra|
+        source = File.join(unpacked, extra)
+        FileUtils.mv(source, File.join(dir, extra), force: true) if File.exist?(source)
+      end
+    end
+
+    def read(url)
+      body = +""
+      stream(url) { |chunk| body << chunk }
+      body
+    end
+
+    def write(url, path)
+      File.open(path, "wb") { |file| stream(url) { |chunk| file.write(chunk) } }
+    end
+
+    def stream(url, hops = 0, &block)
+      uri = URI(url)
+      return File.open(uri.path, "rb") { |file| file.each(nil, 1 << 16, &block) } if uri.scheme == "file"
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 15, read_timeout: 60) do |http|
+        http.request(Net::HTTP::Get.new(uri)) do |response|
+          case response
+          when Net::HTTPRedirection
+            raise Unavailable, "too many redirects fetching #{url}" if hops >= REDIRECTS
+
+            return stream(response["location"], hops + 1, &block)
+          when Net::HTTPSuccess
+            response.read_body(&block)
+          else
+            raise Unavailable, "#{url} answered #{response.code}"
+          end
+        end
+      end
+    rescue SocketError, SystemCallError, Net::OpenTimeout, Net::ReadTimeout, IOError => e
+      raise Unavailable, offline_message(e)
+    end
+
+    def offline_message(error)
+      "enola #{@channel} is not in the cache at #{@channel.cache_dir(@cache_root)} and could not be fetched " \
+        "from #{@channel.release_base} (#{error.class}: #{error.message}); connect once, or place the verified binary there"
+    end
+  end
+end

data/lib/enola/platform.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Enola
+  module Platform
+    OS = { "linux" => "linux", "darwin" => "darwin", "mingw" => "windows", "mswin" => "windows" }.freeze
+    ARCH = { "x86_64" => "amd64", "amd64" => "amd64", "aarch64" => "arm64", "arm64" => "arm64" }.freeze
+
+    def self.current(config = RbConfig::CONFIG)
+      os = OS.find { |key, _| config["host_os"].include?(key) }&.last
+      arch = ARCH[config["host_cpu"]]
+      raise UnsupportedPlatform, "no enola release for #{config['host_os']} on #{config['host_cpu']}" unless os && arch
+
+      "#{os}-#{arch}"
+    end
+
+    def self.windows?(platform)
+      platform.start_with?("windows")
+    end
+  end
+end

data/lib/enola/probe.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Enola
+  class Probe
+    SURFACES = %w[constraints providers check plan hook].freeze
+
+    def initialize(binary)
+      @binary = binary
+    end
+
+    def version
+      out, status = Open3.capture2e(@binary, "--version")
+      return nil unless status.success?
+
+      out[/\d+\.\d+\.\d+(?:[.-][\w.]+)?/]
+    rescue SystemCallError
+      nil
+    end
+
+    # A surface the binary has prints its usage (exit code 2 is its convention
+    # for --help); one it lacks is refused by the top-level dispatch by name.
+    def capabilities
+      SURFACES.to_h do |surface|
+        out, = Open3.capture2e(@binary, surface, "--help")
+        [surface.to_sym, !out.include?("unknown command \"#{surface}\"")]
+      rescue SystemCallError
+        [surface.to_sym, false]
+      end
+    end
+
+    def report(channel: Enola.channel)
+      { channel: channel.name, pinned: channel.version, binary: @binary, version: version, capabilities: capabilities }
+    end
+  end
+end

data/lib/enola/providers/prism/enola_prism_provider.rb

@@ -0,0 +1,188 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# Vendored from enola-labs/enola examples/providers/ruby/prism/enola_prism_provider.rb at v0.4.4 (1e35dfd88e7b293bb2bffec6949989bd6105b796), Apache-2.0.
+
+# enola Prism reference provider.
+#
+# Parses every **/*.rb under the path given as ARGV[0] with Prism (the Ruby
+# parser that ships in the standard library from Ruby 3.3) and emits JSONL
+# call facts on stdout in enola's fact schema — one fact per method call,
+# typed by what the receiver resolves to LEXICALLY. No runtime, no gems, no
+# guessing:
+#
+#   receiver is a constant                  -> callee "Const#method",     resolution_level "constant-receiver"
+#   self or no receiver, inside a def
+#   nested in a nameable class/module       -> callee "Enclosing#method", resolution_level "lexical-self"
+#   anything else                           -> callee "method",           resolution_level "name-only"
+#
+# Fact naming is designed to ADD typed call edges without colliding with the
+# identities enola's own Ruby extractor emits — the extractor already owns the
+# symbol facts, and the seam skips any provider fact sharing a name+kind
+# identity with an extractor fact. Every fact here is therefore kind
+# "dependency" with the distinctive name "prism-call: <caller> -> <callee>",
+# carrying one calls relation targeting the callee. The seam stamps
+# provider/provider_version onto accepted facts; this script declares only
+# resolution_level, which the seam requires on every provider fact.
+#
+# Determinism: files are enumerated in sorted order, output lines are sorted
+# before printing, and nothing time- or environment-dependent is emitted.
+# vendor/, node_modules/ and tmp/ subtrees are skipped at any depth; a file
+# Prism cannot parse cleanly is skipped whole — fail closed, never guess.
+# --version prints a fixed semver on stdout and exits, which is how the seam
+# learns what build it is talking to.
+
+require "json"
+require "prism"
+
+PROVIDER_VERSION = "0.1.0"
+
+if ARGV.include?("--version")
+  puts PROVIDER_VERSION
+  exit 0
+end
+
+root = ARGV[0]
+abort "usage: enola_prism_provider.rb <repo-path>" unless root && File.directory?(root)
+
+SKIP_SEGMENTS = %w[vendor node_modules tmp].freeze
+
+class CallCollector < Prism::Visitor
+  attr_reader :facts
+
+  def initialize(file)
+    @file = file
+    @scopes = []
+    @methods = []
+    @facts = []
+    @chained = []
+    super()
+  end
+
+  def visit_class_node(node)
+    with_scope(constant_name(node.constant_path)) { super }
+  end
+
+  def visit_module_node(node)
+    with_scope(constant_name(node.constant_path)) { super }
+  end
+
+  # An eigenclass body (class << self) pushes an unnameable scope: calls inside
+  # it degrade to name-only rather than being attributed to a name this script
+  # cannot lexically prove.
+  def visit_singleton_class_node(node)
+    with_scope(nil) { super }
+  end
+
+  def visit_def_node(node)
+    @methods.push(node.name.to_s)
+    super
+    @methods.pop
+  end
+
+  def visit_call_node(node)
+    record(node)
+    receiver = node.receiver
+    chained = receiver.is_a?(Prism::CallNode) && receiver.name.to_s == "new" ? node.name.to_s : nil
+    @chained.push(chained)
+    super
+    @chained.pop
+  end
+
+  private
+
+  def with_scope(name)
+    @scopes.push(name)
+    yield
+    @scopes.pop
+  end
+
+  def enclosing
+    return nil if @scopes.empty? || @scopes.any?(&:nil?)
+
+    @scopes.join("::")
+  end
+
+  def caller_name
+    enc = enclosing
+    return @file unless enc
+    return enc if @methods.empty?
+
+    "#{enc}##{@methods.last}"
+  end
+
+  def constant_name(node)
+    case node
+    when Prism::ConstantReadNode
+      node.name.to_s
+    when Prism::ConstantPathNode
+      begin
+        node.full_name
+      rescue StandardError
+        nil
+      end
+    end
+  end
+
+  def record(node)
+    method = node.name.to_s
+    receiver = node.receiver
+    return record_instantiation(node, receiver) if method == "new" && receiver && constant_name(receiver)
+
+    callee, level =
+      if receiver && (const = constant_name(receiver))
+        ["#{const}##{method}", "constant-receiver"]
+      elsif (receiver.nil? || receiver.is_a?(Prism::SelfNode)) && !@methods.empty? && (enc = enclosing)
+        ["#{enc}##{method}", "lexical-self"]
+      else
+        [method, "name-only"]
+      end
+    @facts << {
+      "kind" => "dependency",
+      "name" => "prism-call: #{caller_name} -> #{callee}",
+      "file" => @file,
+      "line" => node.location.start_line,
+      "props" => { "resolution_level" => level },
+      "relations" => [{ "kind" => "calls", "target" => callee }]
+    }
+  end
+
+  # A `new` on a literal constant is the one call whose result has a knowable
+  # type, so it is recorded as an instantiation rather than a call. When the
+  # instantiation is itself the receiver of a further call the ceremony
+  # `Foo.new(...).bar` is named on the fact, which is what a rule about
+  # one-shot objects reads.
+  def record_instantiation(node, receiver)
+    const = constant_name(receiver)
+    props = { "resolution_level" => "constant-receiver" }
+    props["one_shot_call"] = @chained.last unless @chained.empty? || @chained.last.nil?
+    @facts << {
+      "kind" => "dependency",
+      "name" => "prism-new: #{caller_name} -> #{const}",
+      "file" => @file,
+      "line" => node.location.start_line,
+      "props" => props,
+      "relations" => [{ "kind" => "instantiates", "target" => const }]
+    }
+  end
+end
+
+lines = []
+files = Dir.glob(File.join("**", "*.rb"), base: root).reject do |rel|
+  rel.split("/").any? { |segment| SKIP_SEGMENTS.include?(segment) }
+end.sort
+
+files.each do |rel|
+  source = begin
+    File.read(File.join(root, rel))
+  rescue StandardError
+    next
+  end
+  result = Prism.parse(source)
+  next unless result.success?
+
+  collector = CallCollector.new(rel)
+  result.value.accept(collector)
+  collector.facts.each { |fact| lines << JSON.generate(fact) }
+end
+
+puts lines.sort

data/lib/enola/providers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "rbconfig"
+
+module Enola
+  # Prism and Rubydex are on by default. Prism runs as the vendored upstream
+  # script under the Ruby running this gem; Rubydex is built into the binary
+  # and needs its engine library fetched once per binary version.
+  module Providers
+    RUBYDEX_EXPECTED_VERSION = "0.4.0"
+
+    def self.prism_script
+      File.expand_path("providers/prism/enola_prism_provider.rb", __dir__)
+    end
+
+    def self.ruby
+      RbConfig.ruby
+    end
+
+    def self.prism_version
+      out, status = Open3.capture2(ruby, prism_script, "--version")
+      status.success? ? out.strip : nil
+    end
+
+    def self.rubydex_expected_version(binary = nil)
+      return RUBYDEX_EXPECTED_VERSION unless binary
+
+      out, status = Open3.capture2(binary, "providers", "list")
+      return RUBYDEX_EXPECTED_VERSION unless status.success?
+
+      out[/rubydex\s+(\d+\.\d+\.\d+)/, 1] || RUBYDEX_EXPECTED_VERSION
+    end
+
+    # Runs `providers fetch rubydex` once per binary version; the outcome is
+    # remembered beside the binary so a session never asks twice, and a
+    # failure is a named skip the graph will also report, never silence.
+    def self.ensure_rubydex(binary, channel: Enola.channel, cache_root: Enola.cache_root, stderr: $stderr)
+      marker = File.join(channel.cache_dir(cache_root), "providers-rubydex")
+      return File.read(marker).strip if File.exist?(marker)
+
+      out, status = Open3.capture2e(binary, "providers", "fetch", "rubydex")
+      outcome = status.success? ? "fetched" : "skipped: #{out.lines.last&.strip || 'providers fetch rubydex failed'}"
+      stderr.puts "enola: rubydex #{outcome}; Rubydex facts will be a named skip in the receipt until it succeeds" unless status.success?
+      FileUtils.mkdir_p(File.dirname(marker))
+      File.write(marker, "#{outcome}\n")
+      outcome
+    rescue SystemCallError => e
+      "skipped: #{e.message}"
+    end
+  end
+end

data/lib/enola/resolver.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Enola
+  class Resolver
+    Found = Struct.new(:path, :source)
+
+    def initialize(channel: Enola.channel, cache_root: Enola.cache_root, platform: Platform.current, path: ENV.fetch("PATH", ""))
+      @channel = channel
+      @fetcher = Fetcher.new(channel: channel, cache_root: cache_root, platform: platform)
+      @path = path
+    end
+
+    def resolve
+      return Found.new(@fetcher.binary_path, "cache") if @fetcher.cached?
+
+      on_path, found_version = matching_path_binary
+      return Found.new(on_path, "path") if on_path
+
+      begin
+        Found.new(@fetcher.fetch, "fetched")
+      rescue Unavailable => e
+        raise Unavailable, found_version ? "#{e.message}; the enola on PATH is #{found_version}, the Gemfile pins #{@channel.version}" : e.message
+      end
+    end
+
+    EXECUTABLE = File.expand_path("../../exe/enola", __dir__)
+
+    private
+
+    def matching_path_binary
+      candidate = @path.split(File::PATH_SEPARATOR).map { |dir| File.join(dir, "enola") }
+                       .find { |bin| File.executable?(bin) && !wrapper?(bin) }
+      return [nil, nil] unless candidate
+
+      version = Probe.new(candidate).version
+      version == @channel.version ? [candidate, version] : [nil, version]
+    end
+
+    # Bundler puts this gem's own exe on PATH, and a rubygems binstub for the
+    # gem looks like a binary too; probing either would run the wrapper inside
+    # itself without end.
+    def wrapper?(bin)
+      return true if File.realpath(bin) == File.realpath(EXECUTABLE)
+
+      head = File.binread(bin, 512)
+      head.include?("Gem.activate_bin_path") || head.include?('require "enola"')
+    rescue SystemCallError
+      true
+    end
+  end
+end

data/lib/enola/runner.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Enola
+  class Runner
+    def initialize(resolver: Enola.resolver, channel: Enola.channel, stderr: $stderr)
+      @resolver = resolver
+      @channel = channel
+      @stderr = stderr
+    end
+
+    def command(argv)
+      found = @resolver.resolve
+      Providers.ensure_rubydex(found.path, channel: @channel, stderr: @stderr)
+      @stderr.puts "enola: #{@channel} via #{found.source} (#{found.path})" if argv.include?("--verbose")
+      [found.path, *argv]
+    end
+
+    def run(argv)
+      system(*command(argv))
+      $?.exitstatus || 1
+    end
+
+    def exec(argv)
+      Kernel.exec(*command(argv))
+    end
+  end
+end

data/lib/enola/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Enola
+  # The release this wrapper drives. VERSION carries a patch segment for
+  # wrapper-only fixes, so what to fetch is stated separately.
+  UPSTREAM_VERSION = "0.4.4"
+  VERSION = "#{UPSTREAM_VERSION}.1"
+end

data/lib/enola.rb

@@ -1,5 +1,37 @@
 # frozen_string_literal: true
 
-module EnolaPlaceholder
-  VERSION = "0.0.0"
+require_relative "enola/version"
+require_relative "enola/error"
+require_relative "enola/channel"
+require_relative "enola/platform"
+require_relative "enola/fetcher"
+require_relative "enola/probe"
+require_relative "enola/providers"
+require_relative "enola/config"
+require_relative "enola/resolver"
+require_relative "enola/runner"
+require_relative "enola/cli"
+
+module Enola
+  class << self
+    attr_writer :channel
+
+    # Another channel's gem installs its own resolver here, so every rake
+    # task and wrapped command built on Runner drives that channel's binary.
+    # Readable as well as writable: whoever replaces it can put back what was
+    # installed rather than what it assumed.
+    attr_accessor :resolver_factory
+
+    def resolver
+      (@resolver_factory || -> { Resolver.new(channel: channel) }).call
+    end
+
+    def channel
+      @channel ||= Channel::UPSTREAM
+    end
+
+    def cache_root
+      ENV.fetch("ENOLA_CACHE_DIR") { File.join(Dir.home, ".cache", "enola") }
+    end
+  end
 end

metadata

@@ -1,35 +1,66 @@
 --- !ruby/object:Gem::Specification
 name: enola
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.4.4.1
 platform: ruby
 authors:
 - Muhamed Isabegovic
 autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2026-08-21 00:00:00.000000000 Z
-dependencies: []
+date: 2026-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: |
-  This gem is a placeholder, not an implementation. enola is an
-  architecture-graph tool written in Go by enola-labs, which has no Ruby
-  package. This name is held so that it stays available to that project, and
-  will be transferred to its maintainers on request. For Ruby usage today,
-  see the enola-rb gem.
+  A pure-Ruby wrapper around enola, the architecture-graph tool by enola-labs.
+  The gem's version is the upstream release it drives. The binary is not in
+  the gem: the first command that needs it downloads the release for your
+  platform, verifies it against the checksum the release publishes, and keeps
+  it in a per-user cache. Every command and exit code is forwarded unchanged.
+  This gem is not an enola-labs release.
 email:
 - m.isabegovic@hotmail.com
-executables: []
+executables:
+- enola
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
+- exe/enola
 - lib/enola.rb
-homepage: https://github.com/enola-labs/enola
+- lib/enola/channel.rb
+- lib/enola/cli.rb
+- lib/enola/config.rb
+- lib/enola/error.rb
+- lib/enola/fetcher.rb
+- lib/enola/platform.rb
+- lib/enola/probe.rb
+- lib/enola/providers.rb
+- lib/enola/providers/prism/enola_prism_provider.rb
+- lib/enola/resolver.rb
+- lib/enola/runner.rb
+- lib/enola/version.rb
+homepage: https://github.com/misabegovic/enola-rb
 licenses:
 - Apache-2.0
 metadata:
   source_code_uri: https://github.com/misabegovic/enola-rb
+  changelog_uri: https://github.com/misabegovic/enola-rb/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -48,5 +79,6 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Name placeholder held for the enola project; not an official release.
+summary: 'Runs the released enola from Ruby: fetched on first use, verified, pinned
+  to this gem''s version.'
 test_files: []