munola 0.0.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b3a5c6e65edd8492967e458ddb0943a1557c96fe3600a268008f2f71972d5e6
-  data.tar.gz: b834e5597e9c9a9de7ac5049196ede6d53afa0df44e347b0eade627cfc67c7d9
+  metadata.gz: 3fef04df27a6176d9c98ef6a96588ab444f63e92a6ef3c3c3fd73268af931de3
+  data.tar.gz: 8190ecb25656352775ea9ead33c18e04c7faddaac23d67644045398fea80ce26
 SHA512:
-  metadata.gz: 18cfc7574cdd21c1efb323f8652e699fb0d232d9351b6bcdfa6996a2930a76e0de5eb485ef8cbe5ad56ebbe45b5b4b700fc9265f26ab1afb4062f33c9e4e9277
-  data.tar.gz: 76d7c976e14c3d51d6427bd633e220add54d6ac236eadb624ea24a489d1e47978fd5d7ca44c26236a62a2c5a63ceb1985383b69416020f99b2227069a779d74b
+  metadata.gz: 7524cf02ef40ba7136a5ff531ffda09c2e1056b9a53b73710728be0ad64a7158d3aeccf94492a7401619776d2a44a07e22bcff7511ac775083112de200df4820
+  data.tar.gz: fcf9fc3d4ac887817ad8dab39f5c071d4569a282a12fa2720bd5f935da62a4793e6a833c45032cead51f653603baf675f78f2f064351a8bae23516f912a9e883

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/LICENSE

@@ -187,7 +187,7 @@ APPENDIX: How to apply the Apache License to your work.
   same "printed page" as the copyright notice for easier
   identification within third-party archives.
 
-Copyright (c) 2026 Dejan Menges
+Copyright (c) 2026 Muhamed Isabegovic
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/README.md

@@ -1,13 +1,130 @@
 # 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. The gem versions itself; the release it
+drives is `Enola::UPSTREAM_VERSION`, v0.4.4 as of `enola 0.5.0`, and every
+gemspec summary names it.
+
+```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 minor 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),
+each release naming what differs from that upstream. The gem versions itself;
+the channel release it fetches is `Munola::CHANNEL_VERSION`, which carries the
+upstream it is built on plus a segment of its own (`0.4.4.2` on v0.4.4). 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 channel release and 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 the same
+minor 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 the same minor 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/munola

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

data/lib/munola/catalogue.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Munola
+  # The recipes munola ships built in, read from the enola-guides gem so the
+  # content has one version line; the template carries a value the installer
+  # fills in from what the app shows.
+  module Catalogue
+    RECIPES = %w[ember-conventions data-ownership api-boundaries background-work tenant-foreign-key].freeze
+    TEMPLATES = %w[tenant-foreign-key].freeze
+    PLACEHOLDERS = { column: "TENANT_COLUMN", table: "TENANT_TABLE" }.freeze
+
+    def self.source_dir
+      require "enola-rb"
+      File.join(EnolaRb::Guides.root, "recipes")
+    end
+
+    def self.source(name)
+      path = File.join(source_dir, "#{name}.yaml")
+      raise Enola::Unavailable, "the installed enola-guides gem has no recipe #{name}; it needs 0.3.1 or later" unless File.exist?(path)
+
+      path
+    end
+
+    # Writes every catalogue recipe the project does not already have into
+    # enola/recipes/, the template with its values filled or, without them,
+    # left as it is so the placeholders show what to decide.
+    def self.write(root, tenant: nil)
+      dir = File.join(root, "enola", "recipes")
+      FileUtils.mkdir_p(dir)
+      RECIPES.each_with_object([]) do |name, written|
+        target = File.join(dir, "#{name}.yaml")
+        next if File.exist?(target)
+
+        body = File.read(source(name))
+        body = fill(body, tenant) if TEMPLATES.include?(name) && tenant
+        File.write(target, body)
+        written << target
+      end
+    end
+
+    def self.fill(body, tenant)
+      body.gsub(PLACEHOLDERS[:column], tenant.fetch(:column)).gsub(PLACEHOLDERS[:table], tenant.fetch(:table))
+    end
+  end
+end

data/lib/munola/channel.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Munola
+  CHANNEL = Enola::Channel.new(
+    name: "munola",
+    release_base: "https://github.com/misabegovic/enola/releases/download",
+    version: CHANNEL_VERSION,
+    asset_prefix: "enola",
+    tag_prefix: "munola-v"
+  ).freeze
+
+  # The binary this channel drives is fetched from the fork's releases; until
+  # the first one is cut, MUNOLA_BINARY names a binary to drive instead, and
+  # every command says which one answered.
+  class Resolver < Enola::Resolver
+    def initialize(override: ENV.fetch("MUNOLA_BINARY", nil), **options)
+      super(**options)
+      @override = override
+    end
+
+    def resolve
+      return super unless @override
+
+      raise Enola::Unavailable, "MUNOLA_BINARY names #{@override}, which is not executable" unless File.executable?(@override)
+
+      Found.new(@override, "MUNOLA_BINARY (#{Enola::Probe.new(@override).version || 'no version answered'})")
+    end
+  end
+
+  def self.resolve
+    Resolver.new(channel: CHANNEL).resolve
+  end
+
+  def self.channel_line(found = resolve)
+    "munola #{VERSION}, channel #{CHANNEL_VERSION} on enola #{UPSTREAM_VERSION}; binary via #{found.source} (#{found.path})"
+  end
+end

data/lib/munola/cli.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Munola
+  module CLI
+    def self.start(argv, stdout: $stdout, stderr: $stderr)
+      case argv.first
+      when "--version"
+        found = Munola.resolve
+        out, = Open3.capture2e(found.path, "--version")
+        stdout.puts Munola.channel_line(found)
+        stdout.puts out.strip
+        0
+      when "init"
+        init(argv.drop(1), stdout: stdout, stderr: stderr)
+      else
+        Enola::Runner.new(channel: CHANNEL, stderr: stderr).exec(argv)
+      end
+    rescue Enola::Error => e
+      stderr.puts "munola: #{e.message}"
+      127
+    end
+
+    def self.init(args, stdout:, stderr:)
+      options = { tenant_column: nil }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: munola init [ROOT] [--tenant-column COLUMN]"
+        opts.on("--tenant-column COLUMN", "The column most tables carry; confirmed against db/schema.rb") { |v| options[:tenant_column] = v }
+      end
+      rest = parser.parse(args)
+      root = rest.first || Dir.pwd
+      Installer.new(root, tenant_column: options[:tenant_column], stderr: stderr).install.lines.each { |line| stdout.puts line }
+      0
+    end
+  end
+end

data/lib/munola/detector.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Munola
+  # Reads the tree for what the binary's own init cannot see: which catalogue
+  # recipes have the directories their roles need, and which column most
+  # tables share. It reads files; it never asks.
+  class Detector
+    Tenant = Struct.new(:column, :table, :share, keyword_init: true)
+
+    def initialize(root)
+      @root = File.expand_path(root)
+    end
+
+    def bindings
+      found = []
+      found << "ember-conventions" if file?("ember-cli-build.js")
+      found << "data-ownership" if schema? && dir?("app/models")
+      found << "api-boundaries" if file?("config/routes.rb") && dir?("app/policies")
+      found << "background-work" if dir?("app/tasks")
+      found
+    end
+
+    def schema?
+      file?("db/schema.rb") || file?("db/structure.sql")
+    end
+
+    # The tenant column is the one present on most tables; a column the
+    # caller names is confirmed against the schema rather than trusted.
+    def tenant(column: nil)
+      tables = schema_tables
+      return nil if tables.empty?
+
+      counts = Hash.new(0)
+      tables.each_value { |columns| columns.uniq.each { |name| counts[name] += 1 } }
+      candidate = column || counts.select { |name, _| name.end_with?("_id") }.max_by { |name, count| [count, -name.length] }&.first
+      return nil unless candidate
+
+      share = counts.fetch(candidate, 0).fdiv(tables.size)
+      return nil if share < 0.5 && column.nil?
+
+      table = tenant_table(candidate, tables.keys)
+      Tenant.new(column: candidate, table: table, share: share)
+    end
+
+    private
+
+    def file?(rel)
+      File.file?(File.join(@root, rel))
+    end
+
+    def dir?(rel)
+      File.directory?(File.join(@root, rel))
+    end
+
+    def schema_tables
+      path = File.join(@root, "db", "schema.rb")
+      return {} unless File.file?(path)
+
+      tables = {}
+      current = nil
+      File.foreach(path) do |line|
+        if (m = line.match(/create_table\s+"([^"]+)"/))
+          current = m[1]
+          tables[current] = []
+        elsif current && (m = line.match(/^\s*t\.\w+\s+"([^"]+)"/))
+          tables[current] << m[1]
+        elsif line.strip == "end"
+          current = nil
+        end
+      end
+      tables
+    end
+
+    # company_id names companies, category_id names categories, person_id
+    # names people only if the schema has that table: the table is looked up
+    # among the schema's own names, never guessed from an inflection table.
+    def tenant_table(column, names)
+      stem = column.delete_suffix("_id")
+      candidates = [stem, "#{stem}s", "#{stem}es", stem.sub(/y\z/, "ies")]
+      names.find { |name| candidates.include?(name) }
+    end
+  end
+end

data/lib/munola/installer.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "yaml"
+
+module Munola
+  class Installer
+    Report = Struct.new(:written, :bound, :commented, :notes, keyword_init: true) do
+      def lines
+        out = written.map { |path| "wrote #{path}" }
+        out << "bound #{bound.join(', ')}" unless bound.empty?
+        out << "left commented, bind when the directories exist: #{commented.join(', ')}" unless commented.empty?
+        out + notes
+      end
+    end
+
+    def initialize(root, tenant_column: nil, binary: nil, stderr: $stderr)
+      @root = File.expand_path(root)
+      @tenant_column = tenant_column
+      @binary = binary
+      @stderr = stderr
+      @report = Report.new(written: [], bound: [], commented: [], notes: [])
+    end
+
+    # The Rails layer first (starter laws, the binary's own init, upstream's
+    # recipes commented), then what only munola carries: the catalogue, the
+    # bindings the tree justifies, the providers both on by default.
+    # enola-rb carries the installer this reuses; it is required here rather
+    # than at load time so `require "munola"` stays a wrapper and pulls in no
+    # Rails machinery for a project that only drives the binary.
+    def install
+      require "enola-rb"
+      rails = EnolaRb::Installer.new(@root, binary: resolved_binary, stderr: @stderr).install
+      @report.written.concat(rails.written)
+      @report.notes.concat(rails.notes)
+
+      detector = Detector.new(@root)
+      tenant = detector.tenant(column: @tenant_column)
+      values = tenant&.table ? { column: tenant.column, table: tenant.table } : nil
+      @report.written.concat(Catalogue.write(@root, tenant: values).map { |p| relative(p) })
+      bind(detector.bindings + (tenant&.table ? ["tenant-foreign-key"] : []))
+      note_tenant(tenant)
+      providers
+      @report.bound = (rails.bound + @bound).uniq
+      @report.commented = rails.unbound + @commented
+      @report
+    end
+
+    private
+
+    def resolved_binary
+      @binary ||= Munola.resolve.path
+    rescue Enola::Error
+      nil
+    end
+
+    def bindings_path
+      File.join(@root, "enola", "constraints", "recipes.yaml")
+    end
+
+    # A munola binary carries the catalogue itself, so its own `constraints
+    # init` may already have bound a recipe this would bind again, and two
+    # instances of one recipe expand to colliding rule ids. What the file
+    # already names is left alone and counted as bound.
+    def bind(names)
+      @bound = names & Catalogue::RECIPES
+      @commented = Catalogue::RECIPES - @bound
+      existing = File.exist?(bindings_path) ? File.read(bindings_path) : "use_recipe: []\n"
+      return if existing.include?("# munola catalogue")
+
+      doc = YAML.safe_load(existing) || {}
+      declared = Array(doc["use_recipe"]).map { |entry| entry["recipe"] }.compact
+      entries = Array(doc["use_recipe"]) + (@bound - declared).map { |name| { "recipe" => name, "as" => name, "mode" => "advisory" } }
+      body = YAML.dump({ "use_recipe" => entries }).sub(/\A---\n/, "")
+      tail = existing[/\n# Shipped recipes not bound.*\z/m].to_s
+      commented = @commented.map { |name| "#  - recipe: #{name}\n#    as: #{name}\n#    mode: advisory\n" }.join
+      File.write(bindings_path, "#{body}#{tail}\n# munola catalogue recipes not bound because the tree shows no need for them yet.\n" \
+                                "# Uncomment one to switch it on, then run `enola constraints lint`.\n#{commented}")
+      @report.written << relative(bindings_path) unless @report.written.include?(relative(bindings_path))
+    end
+
+    def note_tenant(tenant)
+      if tenant&.table
+        note("tenant column #{tenant.column} on #{(tenant.share * 100).round}% of tables, referencing #{tenant.table}; tenant-foreign-key written with it")
+      elsif tenant && tenant.share.zero?
+        note("#{tenant.column} appears on no table in db/schema.rb; tenant-foreign-key keeps its placeholders")
+      elsif tenant
+        note("tenant column #{tenant.column} found but no table named for it in the schema; tenant-foreign-key keeps its TENANT_TABLE placeholder")
+      elsif @tenant_column
+        note("#{@tenant_column} appears on no table in db/schema.rb; tenant-foreign-key keeps its placeholders")
+      else
+        note("no column sits on most tables; tenant-foreign-key keeps its placeholders, pass --tenant-column to name one")
+      end
+    end
+
+    def providers
+      path = ProvidersConfig.write(@root)
+      if path
+        @report.written << relative(path)
+        note("prism provider: the enola gem carries no provider script yet; mcp-arch.yaml names the slot") unless ProvidersConfig.prism_script
+      end
+      binary = resolved_binary
+      note(binary ? ProvidersConfig.fetch_rubydex(binary) : "rubydex library not fetched: no binary resolved; run `enola providers fetch rubydex` once it is")
+    end
+
+    def relative(path)
+      path.delete_prefix("#{@root}/")
+    end
+
+    def note(text)
+      @report.notes << text
+      @stderr.puts "munola: #{text}"
+    end
+  end
+end

data/lib/munola/providers_config.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "open3"
+require "rbconfig"
+
+module Munola
+  # Every munola project runs both Ruby providers by default: Prism through the
+  # script the enola gem carries, Rubydex built into the binary. The config is
+  # written once, never rewritten; the Rubydex library is fetched after the
+  # binary, and a fetch that fails is a named skip, never a silent absence.
+  module ProvidersConfig
+    RUBYDEX_VERSION = "0.4.0"
+
+    def self.write(root, ruby: RbConfig.ruby)
+      path = File.join(root, "mcp-arch.yaml")
+      return nil if File.exist?(path)
+
+      File.write(path, render(ruby))
+      path
+    end
+
+    def self.render(ruby)
+      lines = ["repo: .", "repos:", "  - .", "providers:"]
+      script = prism_script
+      if script
+        lines += ["  - name: prism", "    command: [#{ruby.inspect}, #{script.inspect}]", "    expected_version: \"0.1.0\""]
+      else
+        lines << "  # prism: the enola gem on this machine carries no provider script; add one here to run it"
+      end
+      lines += ["  - name: rubydex", "    expected_version: \"#{RUBYDEX_VERSION}\""]
+      "#{lines.join("\n")}\n"
+    end
+
+    def self.prism_script
+      return nil unless defined?(Enola::Providers) && Enola::Providers.respond_to?(:prism_script)
+
+      script = Enola::Providers.prism_script
+      script if script && File.exist?(script)
+    end
+
+    def self.fetch_rubydex(binary)
+      out, status = Open3.capture2e(binary, "providers", "fetch", "rubydex")
+      return "rubydex #{RUBYDEX_VERSION} library in place" if status.success?
+
+      "rubydex library not fetched (#{out.lines.last.to_s.strip}); the provider reads as a named skip until `enola providers fetch rubydex` succeeds"
+    rescue SystemCallError => e
+      "rubydex library not fetched (#{e.message}); the provider reads as a named skip until `enola providers fetch rubydex` succeeds"
+    end
+  end
+end

data/lib/munola/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Munola
+  # UPSTREAM_VERSION names the enola release this channel is built on,
+  # CHANNEL_VERSION the fork release the gem fetches.
+  UPSTREAM_VERSION = "0.4.4"
+  CHANNEL_VERSION = "0.4.4.2"
+  VERSION = "0.5.0"
+end

data/lib/munola.rb

@@ -1,5 +1,16 @@
 # frozen_string_literal: true
 
+require "enola"
+require_relative "munola/version"
+require_relative "munola/channel"
+require_relative "munola/catalogue"
+require_relative "munola/detector"
+require_relative "munola/providers_config"
+require_relative "munola/installer"
+require_relative "munola/cli"
+
+Enola.channel = Munola::CHANNEL
+Enola.resolver_factory = -> { Munola::Resolver.new(channel: Munola::CHANNEL) }
+
 module Munola
-  VERSION = "0.0.0"
 end

metadata

@@ -1,29 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: munola
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.5.0
 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: enola
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: enola-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: enola-guides
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.1
 description: |
-  Carries a build of enola, the architecture-graph tool, for projects that
-  want capabilities not yet in an upstream release. Installing it alongside
-  enola-rb switches that gem from the stock binary to this one. Placeholder
-  release; no binary yet.
+  The same pure-Ruby wrapper as the enola gem over another channel: the
+  builds cut from a fork of enola, each release naming what differs. This
+  gem drives channel release 0.4.4.2, built on enola
+  0.4.4. `munola init` writes the recipe catalogue the
+  enola-guides gem carries (Ember, data ownership, API boundaries,
+  background work, a tenant foreign key) into the project and binds the
+  recipes its tree justifies, and turns both Ruby providers on by default. The Rails generator lives in munola-rb. Offered
+  upstream where it fits; no binary here, nothing compiled.
 email:
 - m.isabegovic@hotmail.com
-executables: []
+executables:
+- munola
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
+- exe/munola
 - lib/munola.rb
+- lib/munola/catalogue.rb
+- lib/munola/channel.rb
+- lib/munola/cli.rb
+- lib/munola/detector.rb
+- lib/munola/installer.rb
+- lib/munola/providers_config.rb
+- lib/munola/version.rb
 homepage: https://github.com/misabegovic/enola-rb
 licenses:
 - Apache-2.0
@@ -48,5 +104,6 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Ships the enola build that enola-rb runs when upstream lacks a capability.
+summary: 'One person''s taste on top of enola: a channel of its own and a recipe catalogue
+  bound by what the tree shows.'
 test_files: []