munola 0.0.0 → 0.4.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b3a5c6e65edd8492967e458ddb0943a1557c96fe3600a268008f2f71972d5e6
-  data.tar.gz: b834e5597e9c9a9de7ac5049196ede6d53afa0df44e347b0eade627cfc67c7d9
+  metadata.gz: fc1f44ab0b5e72d5f18dda2afe879b156a0b9ac9a0ae337a1419b3641d2e91a1
+  data.tar.gz: d3f40bfc7e5c2225a268c025ef8a5ab4d141cc3109d1e0faa79c05d7204b210f
 SHA512:
-  metadata.gz: 18cfc7574cdd21c1efb323f8652e699fb0d232d9351b6bcdfa6996a2930a76e0de5eb485ef8cbe5ad56ebbe45b5b4b700fc9265f26ab1afb4062f33c9e4e9277
-  data.tar.gz: 76d7c976e14c3d51d6427bd633e220add54d6ac236eadb624ea24a489d1e47978fd5d7ca44c26236a62a2c5a63ceb1985383b69416020f99b2227069a779d74b
+  metadata.gz: 7401c008c0765293332500601bcb0243342f04e36f8332a4ca48a9f0de72525677b22aea0b1accb83989bcd8c072e70f114531c746057fd5e8a4e7288f139ef8
+  data.tar.gz: 5d91e09afc035996dfca5798b73f16f93cd4effad7a70b3da65dc919509892c5794b2dce05be6f9147e253bc02af125da98dd0ef45912ce507b5f2103f406d12

data/CHANGELOG.md

@@ -0,0 +1,47 @@
+## 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,103 @@
 # enola-rb
 
-Runs [enola](https://github.com/enola-labs/enola), the architecture-graph
-tool, from Ruby, with presets and defaults chosen for Rails stacks.
+Three 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.
+## `enola`
 
-Presets come from
-[enola-guides](https://github.com/misabegovic/enola-guides).
+The wrapper of the released enola. Its version is the upstream release it
+drives: `enola 0.4.4` runs enola-labs' v0.4.4.
 
-Placeholder release. No implementation yet.
+```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
+bin/rails generate munola:install --tenant-column company_id
+bundle exec munola init .
+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 first munola release is what makes the channel real; until it is cut,
+`MUNOLA_BINARY=/path/to/enola` names the binary to drive, and every command
+says so. `munola` depends on `enola` and `enola-rb` at its upstream version
+and on `enola-guides` 0.3.1 or later.

data/exe/munola

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

data/lib/generators/munola/install/install_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "munola"
+
+module Munola
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Writes enola/constraints/ and the munola recipe catalogue, binding what the tree shows a need for"
+      class_option :tenant_column, type: :string, default: nil, desc: "The column most tables carry; confirmed against db/schema.rb"
+
+      def install
+        Munola::Installer.new(destination_root, tenant_column: options[:tenant_column]).install.lines.each { |line| say line }
+      rescue Enola::Error => e
+        raise Thor::Error, "munola: #{e.message}"
+      end
+    end
+  end
+end

data/lib/munola/catalogue.rb

@@ -0,0 +1,46 @@
+# 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
+      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: 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}, built 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,107 @@
+# 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.
+    def install
+      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
+
+    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) || {}
+      entries = Array(doc["use_recipe"]) + @bound.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/railtie.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Munola
+  class Railtie < Rails::Railtie
+    generators { require_relative "../generators/munola/install/install_generator" }
+  end
+end

data/lib/munola/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Munola
+  UPSTREAM_VERSION = "0.4.4"
+  VERSION = "#{UPSTREAM_VERSION}.1"
+end

data/lib/munola.rb

@@ -1,5 +1,18 @@
 # frozen_string_literal: true
 
+require "enola"
+require "enola-rb"
+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"
+require_relative "munola/railtie" if defined?(Rails::Railtie)
+
+Enola.channel = Munola::CHANNEL
+Enola.resolver_factory = -> { Munola::Resolver.new(channel: Munola::CHANNEL) }
+
 module Munola
-  VERSION = "0.0.0"
 end

metadata

@@ -1,29 +1,87 @@
 --- !ruby/object:Gem::Specification
 name: munola
 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: enola
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.4
+- !ruby/object:Gem::Dependency
+  name: enola-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.4
+- !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, versioned as the upstream they are built
+  on plus a fourth segment, each release naming what differs. `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. 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/generators/munola/install/install_generator.rb
 - 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/railtie.rb
+- lib/munola/version.rb
 homepage: https://github.com/misabegovic/enola-rb
 licenses:
 - Apache-2.0
@@ -48,5 +106,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: []