enola-guides 0.3.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8f7f20100ffdeea1ae928ad9e76186848aeba81caed9491993e09cfc5bc7461
-  data.tar.gz: dcbacd0bba3cf8ee9883b1590a8cd969d1c01150d4549789c1869920dad8de9e
+  metadata.gz: 3784520433166796cdd4b84e8991d25877fc6c1c97dcd5af9e04b5d8dcf12985
+  data.tar.gz: a6e317df671ddcbc2cc90f3077eff8db4ec03e6762cd5c5e3ea8e439d27d3555
 SHA512:
-  metadata.gz: f3de1b04dfb1ec8c76f2686d4730052a0f38175721ea288294a09e1f4c2be4fa154d9622748405204b086857bdc5de3969675b49f729b0a5f229f5b8dc5ebebb
-  data.tar.gz: 49e2f753fa478c657683dbe69b729774dc94129a8ba8bf3c6614469b7576e0752857daa266f993006098e8a3e36eeeada89377412548d122c83f9d4fa41d1a01
+  metadata.gz: 7b7987e38206a19d0bddbfa955b77158df65da89b794398ad510c1b63b482f4d28466cba970f1ccf58cf42592e533a2fffa072bd9a89533b60f83852c10b3188
+  data.tar.gz: 3a488496fb470ab2eb67183cc0e38bfa6f177892a74437cc808e345b85421ef0683bc6061231a9c6bfe38e3b362c9f597672cc274bbe415140767da699c1bccd

data/CHANGELOG.md

@@ -1,5 +1,115 @@
 # Changelog
 
+## 0.8.0 (2026-10-25)
+
+One command, `enola-guides`, in every ecosystem: RubyGems, npm, PyPI,
+crates.io, Go and Homebrew, and binaries for Linux, macOS and Windows on
+the GitHub release. `list`, `show` and `copy` read one catalogue,
+`bundle/bundle.json`, generated from the tree by `script/bundle`: 74 items
+across guides, examples, laws, skills, hooks, recipes and templates. The
+five implementations (Go, Rust, Node, Python, Ruby) are held to the same
+22 cases, byte for byte, by `script/test-clis`, and CI runs them against
+each package as installed from the artifact a release would publish, and
+installs the Homebrew formula from a local tap. `VERSION` is the one
+version; a tag `vX.Y.Z` publishes everywhere through trusted publishing
+(`RELEASING.md`). A `NOTICE` names enola. `CONTRIBUTING.md`, `SECURITY.md`,
+a code of conduct, issue and pull-request templates and Dependabot for the
+actions and the crate; `script/test` runs every check CI runs that needs
+no registry.
+
+## 0.7.0 (2026-10-25)
+
+Python, TypeScript, Go and Rust. Guides 15 to 18 and a worked example in
+each language: the same four-layer service with its source, binding the
+`layered` and `supply-chain` recipes and breaking its laws on purpose.
+`script/test-examples` snapshots every example with the pinned enola and
+fails when the laws reporting a breach are not exactly the ones its
+`EXPECTED` file lists. What the examples showed on v0.4.34, each said
+where it bites:
+
+- `layered`'s two domain rules read `depends_on`, which none of the four
+  extractors writes, so each example states the domain's law over
+  `imports`.
+- A TypeScript handler written inline puts its calls on the file, where
+  the edge rules do not walk; a named handler is walked.
+- An Express `router.post("/")` under a mount produces no route.
+- An Axum router nested inline keeps its bare paths.
+- A Cargo version with no operator counts as pinned.
+
+Guide 01 states its first law in YAML as well as Ruby, and the README
+no longer reads as Rubyists first.
+
+## 0.6.0 (2026-10-25)
+
+tabula and taha. Guide 13 is tabula for an enola user: a release that
+carries cardo inside the binary and finds it last, after `engine.binary`
+and any `enola` on PATH; the tour; laws said on an architecture page and
+compiled into plain enola YAML that upstream v0.4.34 lints clean; a PRD
+bullet graded with `grade: enola check clean`; its hooks beside enola's;
+and which hand-built piece of guides 09 to 12 each verb replaces. Guide
+14 is taha: installing from a clone (the npm name `taha` is another
+package's), a run under a mandate, adopting a repository enola already
+measures, and the `cardo` it calls by name. Guides 09 to 12 keep the
+hand-built path and say where tabula takes it over.
+
+## 0.5.0 (2026-10-25)
+
+What enola shipped between v0.4.4 and v0.4.34, each command and key run
+against v0.4.34 before it was written down:
+
+- Guide 05: enola-action@v2, with the install step that gives it the
+  Rubydex library it does not fetch itself, its outputs, and `-format`
+  `sarif`, `annotations` and `summary`; `-reviewers`. A CI job runs the
+  workflow the guide prints.
+- Guide 06: the opencode and Pi install targets, the Claude Code plugin
+  and what it leaves out, all twenty-two MCP tools, and the questions the
+  CLI answers without an agent (`impact`, `endpoint`, `plan`, `flows`,
+  `constraints ledger`, `dashboard`).
+- Guide 07: the rbs and zeitwerk providers, provider reuse, and pinning a
+  provider of your own.
+- Guide 08: `cluster init` and folders indexed as clusters, why the
+  output directory needs its own name (it is resolved inside each
+  member), `matched_routes`, `caller`, `unreached_by_clients`, `coverage
+  --unresolved`, declaring an in-house HTTP client, and sharing the
+  history.
+- Guide 04: laws over dependencies and the `supply-chain` recipe, the
+  ledger, `no_frame_in_members`, and how `since` falls back to git.
+  In v0.4.34 a Ruby `where:` drops a value that is not a string or a
+  symbol, so the guide quotes booleans and numbers.
+- Guide 02: the `packwerk` explainer and the `package_paths` it needs
+  when packs live outside `packages/`, and the `ruby-conventions` recipe.
+
+## 0.4.0 (2026-10-25)
+
+Checked against enola v0.4.34. enola skips a provider whose
+`expected_version` disagrees with what it answers, and the guides pinned
+Prism at `0.1.0` (the script answers `0.2.0` since v0.4.5) and Rubydex at
+`0.4.0` (the binary carries `0.4.1` since v0.4.33), so their Ruby
+configurations produced no provider facts. Every configuration now names
+the built-in `rubydex` and `prism` providers with no pin; neither needs
+Ruby. Also fixed, each wrong before this release too:
+
+- The configuration file is `mcp-arch.yaml`; enola never read
+  `enola.yaml`, so `examples/rails-shop` now ships `mcp-arch.yaml`.
+- `templates/enola-check.sh` defaults to v0.4.34 (it named `0.5.0`, which
+  does not exist), installs the binary under the name the release archive
+  gives it, configures the built-in providers in a tree with a `Gemfile`,
+  and grades with the configuration it generated with; grading the bare
+  path read no providers and reported every Ruby run as a partial verdict.
+- `templates/enola-findings.rb` renders a partial verdict and names each
+  producer it left ungraded.
+- `constraints init` writes `enola/constraints/recipes.yaml`.
+- A provider that ran on one side only gives a partial verdict, not a
+  decline; the session-start hook pins a baseline, and in Claude Code a
+  `PreToolUse` hook refuses the first two file searches.
+- `doctor` reports the hooks and the baseline, not the Rubydex library.
+- The recipes README lists `ruby-conventions` and `supply-chain` among
+  upstream's built-ins.
+
+A CI workflow lints every example against the pinned enola release, runs
+the check template end to end on a Rails fixture, and checks every
+relative link.
+
 ## 0.3.1 (2026-08-23)
 
 The recipes README says where the catalogue ships: built into munola,

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

@@ -0,0 +1,7 @@
+enola-guides
+Copyright (c) 2026 Muhamed Isabegovic
+
+Guides, worked examples, skills and templates for enola
+(https://github.com/enola-labs/enola), by Dejan Menges, licensed under the
+Apache License, Version 2.0. enola, tabula, taha and cardo are separate
+projects; no part of their code is included here.

data/README.md

@@ -1,20 +1,46 @@
 # enola-guides
 
-How to use what [enola](https://github.com/enola-labs/enola) ships since
-v0.4.4 ([enola-labs/enola#247](https://github.com/enola-labs/enola/pull/247)): a
-Ruby DSL for writing architecture constraints, Prism and Rubydex as
-providers that run together with enola's own extractors, recipes a team
-reviews, laws that read the whole graph, and an MCP your agent uses during
-a session. Guides, worked examples, skills and templates, packaged as a
-gem so a team can pin the guidance it adopted. Rubyists first; consumed by
-[enola-rb](https://github.com/misabegovic/enola-rb), the gem that runs
-enola. Expanding as the practice does.
+How to use [enola](https://github.com/enola-labs/enola), the tool that
+grades what a change did to a codebase's architecture, checked against
+v0.4.34: laws written as sentences in Ruby or YAML, recipes a team
+reviews, providers that run beside enola's own extractors, the check in
+CI, the hooks and MCP tools an agent uses during a session, and the
+knowledge base built on top of it with [tabula](guides/13-tabula.md) and
+[taha](guides/14-taha.md). Guides for Rails, Ember, Python, TypeScript,
+Go and Rust, worked examples that CI snapshots and grades on every change,
+skills and templates, packaged so a team can pin the guidance it adopted.
+
+## Install
+
+One command, `enola-guides`, with the same items and the same output from
+every package. Take it from the ecosystem you already use:
 
 ```bash
-gem install enola-guides
-gem contents enola-guides
+gem install enola-guides                                         # RubyGems
+npm install -g enola-guides                                      # npm
+pipx install enola-guides                                        # PyPI (or uv tool install)
+cargo install enola-guides                                       # crates.io
+go install github.com/misabegovic/enola-guides/cmd/enola-guides@latest
+brew install misabegovic/tap/enola-guides                        # Homebrew
 ```
 
+or a binary for Linux, macOS or Windows from the
+[releases](https://github.com/misabegovic/enola-guides/releases). Then:
+
+```bash
+enola-guides list                    # every item; list guides, list laws, list skills, ...
+enola-guides show guides/01-start-here
+enola-guides copy laws/foreign-keys  # writes enola/constraints/foreign-keys.yaml
+enola-guides copy skills/enola       # writes .claude/skills/enola/SKILL.md
+```
+
+`copy` writes an item's files under a directory each kind has a default
+for (`enola/constraints` for a law, `.claude/skills` for a skill,
+`enola/recipes` for a recipe) or the one you name, and never overwrites:
+it names the first file that exists and writes nothing. The gem also
+carries the tree itself, so `gem contents enola-guides` lists every file
+and a team can pin the guidance it adopted in its `Gemfile`.
+
 ## Start with an example
 
 [`examples/rails-shop`](examples/rails-shop): a Rails application declaring
@@ -24,7 +50,12 @@ with Prism and Rubydex configured as providers beside the extractors.
 [`examples/ember-app`](examples/ember-app): an Ember application bound to
 the conventions recipe in one block. [`examples/knowledge-base`](examples/knowledge-base/README.md):
 two pages anchored to code, a cluster config, receipts and a finding ledger,
-the smallest knowledge base the skills and hooks run against. [`examples/laws`](examples/laws/README.md):
+the smallest knowledge base the skills and hooks run against. [`examples/python-service`](examples/python-service),
+[`examples/typescript-service`](examples/typescript-service),
+[`examples/go-service`](examples/go-service) and
+[`examples/rust-service`](examples/rust-service): the same four-layer
+service in each language, with its source, breaking the laws it states on
+purpose so you can watch each one fire. [`examples/laws`](examples/laws/README.md):
 twenty-six laws, one directory each, from foreign keys on a tenant column
 to parts that may not cycle, each a complete declaration you copy and run.
 
@@ -55,6 +86,20 @@ to parts that may not cycle, each a complete declaration you copy and run.
     citation hygiene, the blast radius.
 12. [The wrapper](guides/12-the-wrapper.md): the thin command the skills
     call, the named skip, the receipts and the ledger.
+13. [tabula](guides/13-tabula.md): the knowledge base kept by a tool that
+    carries cardo, its laws compiled into `enola/constraints/`, PRDs
+    graded with `enola check`, and which hand-built piece each verb
+    replaces.
+14. [taha](guides/14-taha.md): agents run on a tabula project under a
+    mandate, gated by tabula's verdicts, asking before anything is
+    published.
+15. [A Python service](guides/15-python.md),
+16. [a TypeScript or JavaScript service](guides/16-typescript.md),
+17. [a Go service](guides/17-go.md), and
+18. [a Rust service](guides/18-rust.md): what enola measures in each
+    language, the `layered` recipe bound to a service, the law over
+    `imports` its domain rules need, dependencies, and where v0.4.34 reads
+    less than the code says.
 
 ## Skills