slipwai 1.0.0.dev10__py3-none-any.whl

slipwai/__init__.py

@@ -0,0 +1,6 @@
+"""Slipwai, the factory: one command that scaffolds a new product monorepo.
+
+`cli` is the entry point, `scaffold` assembles a project, and `project/` holds one module per part of
+the repository being generated. Nothing here reads the working directory: every path comes from
+`assets`, so the same answers produce the same project from anywhere.
+"""

slipwai/__main__.py

@@ -0,0 +1,6 @@
+"""`python -m slipwai` — and the entry point the frozen executable is built from."""
+
+from slipwai.cli import main
+
+if __name__ == "__main__":
+    main()

slipwai/_bundle/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+
+No public releases yet. Release notes are recorded here newest first.

slipwai/_bundle/VERSION

@@ -0,0 +1 @@
+1.0.0.dev10

slipwai/_bundle/assets/README.md

@@ -0,0 +1,40 @@
+# The canonical toolkit
+
+Everything a generated project receives lives here. No starter copy is committed anywhere, so a change in
+this tree reaches every combination the moment it is generated.
+
+| Directory | Holds |
+|---|---|
+| `toolkit/skills/` | The shared delivery and event skills, canonical in their event-modelling form |
+| `toolkit/docs/` | Shared methodology documentation (event modeling to code, first slice) |
+| `toolkit/scripts/` | The dependency-free gate scripts a generated repository ships |
+| `profiles/standard/` | The rewritten overlays, and the preset, that derive the standard profile |
+| `profiles/event-modelling/` | Additions specific to the event profile |
+| `languages/<language>/app/` | Each backend's walking skeleton, laid out at the paths it lands on under the service's directory — `apps/service/` by default |
+| `languages/java/build/` | The Maven wrapper and analyser configuration both Java backends share |
+| `languages/<language>/event-port/` | The event-store port with no adapter behind it, for a backend whose event-store axis offers nothing yet. Every backend offers the axis today, so this is not emitted for any of them; it is kept for the next language on the day it lands before its stores do |
+| `languages/<language>/locks/`, `go/modules/` | Committed dependency locks, one per dependency set the axes can produce |
+| `languages/<language>/examples/` | The snippet a `{{example: skill/id}}` marker resolves to, per language; a project written in several languages gets one labelled block per language at each marker |
+| `frontends/<frontend>/` | Frontend packs — currently `react-vite`: the `app/` skeleton, `features/<feature>/` copied into every browser app when a service has that feature (the customer login), and `locks/` per dependency set |
+| `backing-services/` | Axis implementations: event-store, HTTP, staff-identity and customer-identity adapters per backend, the shared `sql/` event-log schema, the Keycloak realms under `keycloak/realms/`, the Compose file, and the pruner shared with generated projects |
+
+The toolkit is canonical in its event-modelling form, which is why `profiles/standard/` is the
+only profile directory with rewritten overlays.
+
+## Editing it
+
+Edit the material in place, then run `make verify` from the factory root. There is no import or
+synchronization step and no remote source repository: the factory is self-contained. Spec Kit itself is
+not vendored — each generated project's `./init` installs it.
+
+**A generated file's body belongs in this tree, never as a string in the generator.** The `app/` trees
+here and under `frontends/` are read as trees, so adding a file to a starter is an edit in this directory
+and nothing else. Code decides content only where the *selection* does — a marked region, a per-feature
+dependency list, a name derived from the project — and `tests/test_language_skeletons.py` fails a language
+module that stops reading its tree.
+
+Routing and the generated adaptations live in `src/slipwai/`: one module per part of the
+repository being generated, so the file to open is named after the file you are changing.
+
+See [docs/maintaining.md](../docs/maintaining.md) for the verification and browsing workflow, and
+[docs/axes.md](../docs/axes.md) for what each axis answer is expected to deliver.

slipwai/_bundle/assets/adoption/docs/change-strategy.md

@@ -0,0 +1,137 @@
+# How this repository changes
+
+> **Experimental.** This page arrived with brownfield adoption and will change as real programmes teach it
+> what it gets wrong. What surprised you belongs on the public issue tracker.
+
+The delivery method is installed. `make verify` is green, the survey says what is here, and `/characterise`
+can pin any behaviour before it changes. Nothing on this page had to be decided for that to happen, and that
+was the point: the method makes every later step safe for an agent to attempt, and only now is the question
+*which* step. This page is the Choose and Slice stages — three strategies, the order to change in, what
+to do about data and infrastructure, and the one rule that holds all of it together.
+
+## Three strategies, not two
+
+| Strategy | What it is | When it is right | What it needs |
+|---|---|---|---|
+| **Strangler fig** | New capability grows beside the old system and takes its traffic one capability at a time, until the old system serves nothing and is removed | The system is large, alive and cannot stop; there is a seam requests enter through; the business trigger (`project.json`'s `why`) is a capability that has to change, not a platform that has to go | A routing seam, a data strategy that is not dual-write, and the retirement ledger |
+| **Modular monolith in place** | The code is restructured behind its characterisation tests — contexts found, seams made, layers separated — without a second deployable or a routing seam | The system is one deployable that mostly works, the trigger is "cannot change it safely" rather than "cannot run it", and the team is small | `/characterise` before every move, `refactoring` and `improve-codebase-architecture`, and patience; the import gate's rule can be adopted context by context (`"layout": "hexagonal"`) |
+| **Rewrite** | A new system replaces the old one, and the old one is switched off | The system is small enough to hold in one head; there is no seam to strangle through; the platform is dead and cannot be upgraded in place | Characterisation of everything the rewrite claims to preserve, a cut-over plan with a rollback, and the honesty that most rewrites are cancelled halfway |
+
+Rewrite is the exception, chosen when the other two cannot work, not the default because it is cleaner.
+A programme is allowed to change its mind: a strangler that finds one context is the whole system may
+become a rewrite of that context, and a rewrite that turns out to have a seam after all may become a
+strangler. What is not allowed is to do neither and call the refactoring a strategy.
+
+## Be honest about the event model
+
+The generated method carries Event Modeling and event sourcing as one bundle, and the factory's own position
+is that "start standard and adopt events where a subdomain earns it" is an option that mostly does not
+exist: state cannot be turned back into history it never recorded. Brownfield does not change that. What
+event modelling means here is **new slices at the edge**: a capability that moves to a new home is modelled
+as events from the day it moves, with its history starting at a **genesis event** that records the state
+the legacy system handed over, or with a change-data-capture stream translating the legacy tables into
+events the new home reads. The legacy system itself is an **external system** in the model — an actor and
+a swimlane, its events marked `external: true`, never a set of events invented by renaming its tables.
+`/survey` says the same in the event-modelling profile; do not promise more than this.
+
+## Separate the layers, and do one at a time
+
+Most programmes mix six changes into one and then cannot say which one broke it. The order below is
+from the cheapest and most mechanical to the one only a person can decide, and each is a stopping point that
+leaves the system better than before.
+
+Under the ladder is its floor: **a build that declares its dependencies and fetches them** — Maven or Gradle
+through the wrapper for Java, the package manager for everything else. An Ant build with its jars committed is
+below it, and no rung above can be taken from there: nothing dates a jar by its name for long, nothing audits
+it, and no CI runner has the tool without being told. So where the survey finds one, the programme opens with
+the move — a `pom.xml` that declares each committed jar by its coordinates, sources under `src/main/java`, the
+same artifact out of `./mvnw -q package`, then `/survey` reads the tree as Maven — and it is the one step no
+strategy paces differently: *leave it* still takes it, because it is the least the method holds any repository
+to. The rungs:
+
+1. **Language version** — the runtime the code is compiled or interpreted against. Java 8 → 21, Python 2 →
+   3, .NET Framework → .NET. Largely mechanical: **OpenRewrite** recipes for Java (`UpgradeToJava21` and the
+   framework migrations beside it), `pyupgrade` and `futurize` for Python, the .NET **Upgrade Assistant**
+   for C#. Point the agent at the recipe, not at the files: a recipe applied is a diff to review; an agent
+   hand-rewriting a thousand files is a thousand chances to be wrong.
+2. **Framework** — Spring 4 → Boot, Struts → anything, AngularJS → Angular through `ngUpgrade`'s hybrid
+   mode, Express 3 → 4. OpenRewrite has recipes for the Java rungs (`SpringBootUpgrade`); the others are
+   guided and pinned by `/characterise` at the HTTP boundary.
+3. **Packaging** — WAR on an application server → an executable jar, a `.NET Framework` site → a self-hosted
+   process, a set of scripts → a package. The survey records `packaging: war` where it sees one; this rung
+   is where it stops mattering.
+4. **Runtime** — VM → container, or the container base image the packaging now allows. The first `Dockerfile`
+   is written here, and `make verify` grows a step that builds it.
+5. **Host** — where it runs: on-premises → a cloud, or one cloud → another. `docs/deployment.md` records the
+   infrastructure's home and the rule (import or reference, never manage a resource in two places); the
+   factory's `aws` target is one possible destination for a *generated* service, and never a claim about the
+   legacy system's host.
+6. **Architecture** — the strangler, the modular monolith, the contexts. Last, because every rung above it is
+   cheaper with a green gate and characterisation tests, and none of them needs an architectural decision.
+
+A programme whose `why` is "end-of-life runtime" stops after rung 1 or 2 and has succeeded. One whose `why`
+is "cannot ship" usually finds its problem at rung 6 and needs the five below it first. The survey reads
+which of these is actually out of support — the runtime the tree pins, the framework and test framework the
+manifest declares, the images a `Dockerfile` starts from — and dates each against the factory's support table
+(`__DELIVERY__/survey/structure.md`, *What it runs on*); a product past its end of life goes at the head of the
+recommendation's `before` list whatever `why` says, with the way up named for it, and is the map's Platform
+row climbing `inventoried` → `supported` → `audited`. `/survey` re-dates on the day it runs, so a runtime that
+leaves support while the programme goes on shows up without anyone looking.
+
+## Data
+
+- **Schema ownership is the usual blocker.** `project.json`'s `database.schema` records where the schema is
+  versioned: `here`, `elsewhere` (a repository that is now the contract), `unmanaged` (a DBA, a console) or
+  `none`. Nothing is moved until somebody can answer who else reads these tables; the answer is written in
+  `docs/deployment.md` beside the infrastructure.
+- **Migration tooling, where there is none.** Flyway or Liquibase for the JVM, Alembic or Django's for
+  Python, Prisma or knex for Node, EF migrations for .NET, `golang-migrate` for Go — recommended, not
+  scaffolded: the tool belongs to the ecosystem the schema lives in, and a baseline migration that matches
+  the database as it is (`baseline-on-migrate` in Flyway's words) is the first migration, never a rewrite of
+  the schema from memory.
+- **Dual-write is a trap.** Two systems each writing the same fact drift the first time one of them fails.
+  Move data with **change data capture** from the legacy store, or an **outbox** written in the legacy
+  system's own transaction, and let the new home read that. One writer per fact, always.
+- **Rehearse the migration.** Every cut-over is run against a copy first, with a **reconciliation report**
+  — counts, sums, samples — between the old and new stores, and a **rollback plan** that has been executed
+  at least once in rehearsal. A migration that has not been rolled back in rehearsal has no rollback plan.
+- **Dual-run, then cut over.** The new home serves reads in shadow, its answers reconciled against the old
+  system's, before it serves anything to an actor; then the flag flips one capability at a time.
+- **Some things do not move.** Data residency, audit retention, regulatory constraints on where a record may
+  live — find them in the survey stage and write them down, because a strategy that ignores one is cancelled
+  the day somebody notices.
+
+## Infrastructure
+
+Three cases, and one rule. **ClickOps**, nothing describes the infrastructure: describe it before anything
+imports it, because describing is safe and importing what is not described is how two things end up
+managing one resource. **A platform team's IaC in another repository**: that repository is the contract, and
+what this one hands over — a tag, an image, a ticket — is written in `docs/deployment.md`. **IaC in this
+repository**: the factory adds nothing to it and manages none of it. The rule in all three: **import or
+reference** — `tofu import`, data sources — and never manage a resource in two places. `docs/deployment.md`
+records which case this is and where the description lives.
+
+## Every step shippable, every step reversible
+
+Most programmes are cancelled halfway. Slice the programme so that stopping at any point leaves the
+system better than it was: a runtime upgrade shipped is a win whether or not the strangler ever starts; a
+capability moved and routed is a win whether or not the next one moves. A step that only pays off once the
+whole programme finishes is a step to split. And every step is reversible while it is fresh: the flag flips
+back, the router points back, the migration rolls back — which is why the flag, the router and the rollback
+are decided in the slice's plan and not after the code exists.
+
+## The agent's context
+
+A legacy codebase is larger than any context window, and an agent that reads files one at a time in it will
+be confidently wrong. Before the first slice: the survey (`survey/survey.md`), the code index
+(`./init --extension codegraph`), and a module map — which directories are which contexts, in the agent's
+guidance. `/characterise` before each change, `/strangle` for each capability that moves, and the ledgers
+they keep are what let a later session pick up where this one stopped.
+
+## The retirement ledger
+
+`__DELIVERY__/retirement.md` is the record of the strangler: one row per capability, from where, to where,
+routed by what, pinned by which tests, and its status — *routed*, *moved*, *retired* or *removed*. `/strangle`
+writes the rows; the programme is finished when every row is *removed* and nothing else is left. A ledger
+that stops being written is the first sign that a programme has quietly become a second system beside
+the first, which is the one outcome worse than either.

slipwai/_bundle/assets/adoption/scripts/check-convergence.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""Hold the convergence map to the tree: fail a row that claims a rung the repository contradicts, and a page
+that no longer matches the record.
+
+    python3 scripts/check-convergence.py
+
+`project.json`'s `convergence` rows say where an adopted repository stands on each ladder (brownfield adoption;
+experimental). Most rungs only a person can establish, and those stand as written. What the tree can contradict
+it does: a constitution that is still the template cannot be `ratified`; a test suite the ratchet quarantines
+cannot be `tests-pass`; a repository whose release path is `manual` is not on `pipeline`; an application whose
+role is not established is not `named`. An `unrecorded` row passes with a line saying so — it is a question, not
+a gap. A page rendered from other rows than the record now holds is stale, and fails: `/survey` regenerates it.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import sys
+from pathlib import Path
+
+
+def project_root(script: Path) -> Path:
+    for candidate in script.parents:
+        if (candidate / "project.json").is_file():
+            return candidate
+    return script.parents[1]
+
+
+SCRIPT = Path(__file__).resolve()
+ROOT = project_root(SCRIPT)
+DELIVERY = SCRIPT.parents[1]
+PAGE = DELIVERY / "docs/convergence.md"
+BASELINE = DELIVERY / "baseline.json"
+CONSTITUTION = ROOT / ".specify/memory/constitution.md"
+PLACEHOLDER = re.compile(r"\[[A-Z][A-Z0-9_]{2,}[^\]]*\]")
+# A whole line, as `slipwai.strategy` reads it; a sentence mentioning the `Strategy:` line is not the line.
+ADR_STRATEGY = re.compile(r"^\W*strategy\W*:\W*([a-z-]+)\W*$", re.IGNORECASE | re.MULTILINE)
+STRATEGIES = ("leave-it", "in-place", "modular-monolith", "strangler-fig", "rewrite")
+# What a strategy was called before the axis was `strategy`: an ADR accepted under the older spelling still
+# decides, and the record is written under the current name by the next `/survey`.
+OLD_STRATEGIES = {"modernise-in-place": "in-place"}
+ADR_ACCEPTED = re.compile(r"^## Status\s*\n+\s*Accepted\b", re.MULTILINE)
+LEDGER = DELIVERY / "retirement.md"
+MARKER = re.compile(r"<!-- convergence: ([0-9a-f]+) -->")
+RUNGS = {
+    "path-to-production": ("unknown", "manual", "scripted", "pipeline", "one-path", "pipeline-decides"),
+    "integration": ("unknown", "branches", "trunk", "continuous"),
+    "safety-net": ("none", "tests-exist", "tests-pass", "fast", "pinned", "mutation-measured"),
+    "structure": ("as-found", "named", "laid-out", "hexagonal", "typed"),
+    "platform": ("unknown", "inventoried", "supported", "audited"),
+    "constitution": ("template", "ratified", "in-full"),
+    "data": ("open", "recorded", "settled"),
+    "infrastructure": ("open", "recorded", "settled"),
+    "strategy": ("open", "why-recorded", "recommended", "decided", "done"),
+}
+
+
+def caps(document: dict) -> dict[str, tuple[str, str]]:
+    """The highest rung the tree allows each axis, with the fact that caps it — only where the tree can say."""
+    found: dict[str, tuple[str, str]] = {}
+    release = (document.get("release") or {}).get("path", "unknown")
+    if release in ("unknown", "manual", "scripted"):
+        found["path-to-production"] = (release, f"release.path is `{release}`")
+    wrapped = [r for r in (document.get("deployables") or {}).values() if r.get("generated") is False]
+    if wrapped:
+        if any(r.get("kind") == "application" for r in wrapped):
+            found["structure"] = ("as-found", "an application's role is not established (`kind: application`)")
+        elif not all(r.get("path", "").startswith("apps/") for r in wrapped):
+            found["structure"] = ("named", "not every application lives under apps/")
+        elif not all(r.get("layout") == "hexagonal" for r in wrapped):
+            found["structure"] = ("laid-out", "not every application declares the hexagonal layout")
+        elif not all((r.get("commands") or {}).get("typecheck") for r in wrapped):
+            found["structure"] = ("hexagonal", "not every application records a typecheck command")
+        if not any((r.get("commands") or {}).get("test") for r in wrapped):
+            found["safety-net"] = ("none", "no application records a test command")
+        # What the applications run on, as `/survey` dated it: a product past its end of life, or one the table does
+        # not know, caps the row; a missing audit command caps it below `audited`. A person who knows better — a
+        # vendor's paid support — records the row with `confirmed` provenance and the terms as evidence, and this
+        # still says what the tree and the table say.
+        products = [p for p in ((document.get("platform") or {}).get("products") or []) if isinstance(p, dict)]
+        if not products:
+            found["platform"] = ("unknown", "no runtime pin, framework version or image was dated by the survey")
+        else:
+            behind = [f"{p.get('title')} {p.get('version')}" for p in products
+                      if p.get("status") in ("end-of-life", "unknown")]
+            # An Ant build declares nothing a tool can audit: its jars are committed. The floor under the ladder is
+            # a build that does (`docs/change-strategy.md`), and the programme's first step is to move there.
+            ant = [r.get("name") for r in wrapped if (r.get("toolchain") or {}).get("ecosystem") == "ant"]
+            if behind and (document.get("platform") or {}).get("provenance") != "confirmed":
+                found["platform"] = ("inventoried",
+                                     f"{', '.join(behind)} is out of support or not in the support table")
+            elif ant:
+                found["platform"] = ("inventoried", f"{', '.join(map(str, ant))} builds with Ant, whose committed jars "
+                                                    "nothing can audit — Maven or Gradle first")
+            elif not all((r.get("commands") or {}).get("audit") for r in wrapped):
+                found["platform"] = ("supported", "not every application records an audit command")
+    if BASELINE.is_file():
+        try:
+            baseline = json.loads(BASELINE.read_text())
+        except ValueError:
+            baseline = {}
+        red = []
+        for name, targets in baseline.items():
+            test = targets.get("test") or {}
+            if test.get("exit"):
+                # The runner's own failure names are findings (`test: <name>`), so the count is of failing tests
+                # where the output named them, and of nothing where it did not.
+                failing = sum(1 for finding in test.get("findings") or [] if str(finding).startswith("test: "))
+                red.append(f"{name} ({failing} failing)" if failing else name)
+        if red and "safety-net" not in found:
+            found["safety-net"] = ("tests-exist", f"the ratchet quarantines the test suite of {', '.join(red)}")
+    if not CONSTITUTION.is_file() or PLACEHOLDER.search(CONSTITUTION.read_text(errors="replace")):
+        found["constitution"] = ("template", "the constitution is missing or still carries the template's placeholders")
+    if not document.get("why"):
+        found["strategy"] = ("open", "no `why` is recorded")
+    else:
+        decided = decided_strategy()
+        if decided is None:
+            found["strategy"] = ("recommended", "no accepted ADR under docs/adr/ carries a `Strategy:` line")
+        elif decided != "leave-it" and not ledger_finished():
+            found["strategy"] = ("decided", f"the ADR decides `{decided}` and the retirement ledger does not "
+                                                 "read *removed* throughout")
+    return found
+
+
+def decided_strategy() -> str | None:
+    """The strategy the highest-numbered accepted ADR names, or None."""
+    decided = None
+    for path in sorted((DELIVERY / "docs/adr").glob("*.md")):
+        text = path.read_text(errors="replace")
+        spelled = [match.group(1).lower() for match in ADR_STRATEGY.finditer(text)]
+        named = [OLD_STRATEGIES.get(name, name) for name in spelled]
+        strategy = next((name for name in named if name in STRATEGIES), None)
+        if strategy and ADR_ACCEPTED.search(text):
+            decided = strategy
+    return decided
+
+
+def ledger_finished() -> bool:
+    last: dict[str, str] = {}
+    for line in (LEDGER.read_text(errors="replace") if LEDGER.is_file() else "").splitlines():
+        cells = [cell.strip() for cell in line.strip().strip("|").split("|")]
+        if len(cells) == 7 and cells[0] not in ("Date", "---") and not cells[0].startswith("-"):
+            last[cells[1]] = cells[6].strip("*").lower()
+    return bool(last) and all(status == "removed" for status in last.values())
+
+
+def main() -> int:
+    document = json.loads((ROOT / "project.json").read_text())
+    rows = document.get("convergence")
+    if not isinstance(rows, list) or not rows:
+        print("check-convergence: no map recorded — adopted before the map existed; `slipwai adopt --refresh` writes "
+              "it")
+        return 0
+    if not PAGE.is_file():
+        print(f"check-convergence: {PAGE.relative_to(ROOT)} is missing; /survey (slipwai adopt --refresh) writes it",
+              file=sys.stderr)
+        return 1
+    marker = MARKER.search(PAGE.read_text())
+    expected = hashlib.sha256(json.dumps(rows, sort_keys=True).encode()).hexdigest()[:16]
+    if marker is None or marker.group(1) != expected:
+        print(
+            f"check-convergence: {PAGE.relative_to(ROOT)} is stale — project.json's convergence rows changed and the "
+            "page was not regenerated; run /survey (slipwai adopt --refresh) and commit both.", file=sys.stderr,
+        )
+        return 1
+    capped = caps(document)
+    failures = 0
+    for row in rows:
+        axis, rung = row.get("axis"), row.get("rung")
+        if axis not in RUNGS or rung not in RUNGS[axis]:
+            print(f"check-convergence: {axis}: `{rung}` is not a rung this factory knows", file=sys.stderr)
+            failures += 1
+            continue
+        if row.get("provenance") == "unrecorded":
+            print(f"  {axis}: `{rung}` — unrecorded: nothing has established it; /drive asks before the first slice")
+            continue
+        cap = capped.get(axis)
+        if cap and RUNGS[axis].index(rung) > RUNGS[axis].index(cap[0]):
+            print(
+                f"check-convergence: {axis} is recorded at `{rung}` ({row.get('provenance')}), but {cap[1]} — the tree "
+                f"allows `{cap[0]}` at most. Establish the rung, or record where it stands.", file=sys.stderr,
+            )
+            failures += 1
+            continue
+        mark = "at target" if rung == row.get("target") else f"below `{row.get('target')}`"
+        print(f"  {axis}: `{rung}` — {mark}" + (f"; planned as {row['planned']}" if row.get("planned") else ""))
+    # Said, not failed: a strangler fig decided with nowhere for a capability to move to. The first strangler
+    # adoption archived five product slices, all built in the WAR it had decided to strangle, with an empty ledger.
+    deployables = document.get("deployables") or {}
+    if decided_strategy() == "strangler-fig" and not ledger_finished() and deployables and all(
+        not (record or {}).get("generated") for record in deployables.values()
+    ):
+        archived = len([path for path in (ROOT / "specs").glob("*/slices/*") if path.is_dir()])
+        print(
+            f"  strategy: `strangler-fig` is decided, {archived} slice(s) are archived, the retirement ledger "
+            "reads *removed* for nothing, and every deployable is one that was here — nothing has moved to a new "
+            "home. A product slice under a strangler lands in a new home (`add-service`, then `/strangle`); the "
+            "Plan stage of /drive has the rule."
+        )
+    at = sum(1 for r in rows if r.get("rung") == r.get("target"))
+    print(f"check-convergence: {at} of {len(rows)} axes at target; the map is {PAGE.relative_to(ROOT)}")
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())