NAME

App::Ariza - bundler and distribution tool for Raku terminal apps

SYNOPSIS

$ ariza bundle --app=../App-Moneymoor --out-dir=dist
$ ariza smoke --archive=dist/moneymoor-0.2.0-macos-arm64.tar.gz
$ ariza installers --app=../App-Moneymoor    # install.sh + three friends
$ ariza scaffold-ci --app=../App-Moneymoor   # the workflows that build all three

$ ariza version                              # ariza's own version
$ ariza help                                 # usage

DESCRIPTION

ariza packages Raku TUI applications — Cantina, Kelpie, Mindmoor, Moneymoor — for people who do not have Raku and should not have to care that the thing is written in it.

The end state is a bundle: one archive per platform containing the application, a Rakudo runtime, every Raku dependency, and every native shared library the app touches (notcurses, SQLCipher, libvips), laid out so that unpacking it anywhere and running one launcher works, with no installer, no package manager, no PATH surgery, and nothing left behind when the directory is deleted. Platforms are named by App::Ariza::Platform's slugs, and what a given app needs in its bundle is declared by that app in an ariza.toml (App::Ariza::Config).

What a bundle is

ariza bundle produces one directory and one archive:

bin/moneymoor              the launcher, and the only thing a user runs
rakudo/                    the interpreter (plus SQLCipher, on macOS)
  share/perl6/vendor/      every Raku module, with warm bytecode
native/                    notcurses and friends
VERSION                    app version and component pins, one screen
ariza-manifest.json        the same, machine-readable, plus every sha256
THIRD-PARTY.md             every component, its licence, and where that
                           fact came from
LICENSES/                  the text of every licence the above cites

Nothing is installed, nothing is written outside the directory (bar a one-line first-run marker under XDG_STATE_HOME), and deleting the directory is the uninstall. ariza smoke then unpacks that archive somewhere with a space in its name, runs it with a replaced environment, and reports on each check — which is the difference between "the build finished" and "the bundle works".

The pieces

• App::Ariza::Platform — names the platform a bundle is for. The slugs are Notcurses-Native's, exactly, because a bundle carries that distribution's prebuilt libraries.

• App::Ariza::Versions — the single pin file every artefact is built against: the Rakudo runtime a bundle embeds, and the SQLCipher version it expects.

• App::Ariza::Config — the per-app ariza.toml manifest, which lives in the app's own repository so that ariza never grows a list of special cases about specific apps.

• App::Ariza::Resources — how all of the above find their data files, installed or from a checkout.

• App::Ariza::Tools — the shell-out layer. Every run, download, digest and extraction in ariza goes through it, so failures read the same way everywhere and no other module contains a bare run.

• App::Ariza::Rakudo — fetches, caches and unpacks the pinned runtime a bundle embeds.

• App::Ariza::Site — installs the app and its whole closure into the bundle's own repository, using the bundled zef, and warms the precompilation store so a user's first launch is not a minute long.

• App::Ariza::Native — stages SQLCipher, makes it self-contained, and audits every native binary in the bundle for anything that would load from outside it.

• App::Ariza::Launcher — writes the one script a user runs.

• App::Ariza::Runner — the compiled launcher a Windows bundle starts from: which artefact a platform gets, where it is published, and the digest it has to match before it goes anywhere near a bundle.

• App::Ariza::Licensing — reads a finished bundle and says what it redistributes: every native pack's own licensing kit, ariza's maintained record of the vendored runtime, every installed distribution's license, and the app's own declarations, merged into THIRD-PARTY.md and LICENSES/.

• App::Ariza::Installer — writes the four scripts that put a bundle on someone's machine, and take it off again.

• App::Ariza::CI — the GitHub Actions workflows that run all of the above once per platform, on machines that are actually those platforms, and publish the result.

• App::Ariza::Bundle — the orchestrator, and the author of VERSION and ariza-manifest.json.

• App::Ariza::Smoke — unpacks a finished archive somewhere new, with a replaced environment, and checks it.

COMMAND METHODS

Every ariza CLI verb is a class method here, so the whole tool is scriptable from Raku. The methods do the wiring and the reporting; the work lives in the modules.

cmd-bundle(:$app!, :$platform, :$out-dir, :$sqlcipher-archive --> Hash)

Build a bundle and report it: archive path, compressed and uncompressed size, SHA-256, launcher, and the ariza smoke line to check it with. Returns App::Ariza::Bundle's result hash.

:$platform defaults to this machine's slug. :$sqlcipher-archive stages SQLCipher from a local archive instead of from the build machine's package manager, which is what a cross-build (a Linux bundle needs a Linux library) or an air-gapped build needs.

cmd-installers(:$app!, :$out-dir, :$branch --> List)

Render the end-user install.sh, install.ps1, uninstall.sh and uninstall.ps1 from the app's ariza.toml, print what was written, and return the paths. :out-dir defaults to the app's own repository root — these are committed artefacts, because curl … | sh has to be able to fetch them from somewhere. :branch is the branch that one-liner names (main).

cmd-scaffold-ci(:$app!, :$out-dir, :$force --> List)

Render the app's .github/workflows/test.yml and release.yml from its ariza.toml, print what happened to each, and return one { path, output, action } per file.

release.yml is derived from bundle.platforms and is rewritten every time; test.yml is written only when it is absent, because a test workflow acquires things a generator cannot infer. :force overwrites both. :out-dir writes somewhere other than the app's own .github/workflows, which is otherwise created if it does not exist.

cmd-smoke(:$archive!, :$keep --> Hash)

Unpack an archive somewhere new and check it, printing one line per check. Returns App::Ariza::Smoke's result hash; the CLI exits non-zero when passed is false, so it drops straight into CI.

dist() / dist-version()

The $?DISTRIBUTION object for App-Ariza itself, and its version string ('dev' if the metadata has none).

SEE ALSO

App::Ariza::Bundle, App::Ariza::Smoke, App::Ariza::Rakudo, App::Ariza::Site, App::Ariza::Native, App::Ariza::Launcher, App::Ariza::Runner, App::Ariza::Installer, App::Ariza::CI, App::Ariza::Platform, App::Ariza::Versions, App::Ariza::Config, App::Ariza::Resources, App::Ariza::Tools

AUTHOR

Matt Doughty

COPYRIGHT AND LICENSE

Copyright 2026 Matt Doughty

This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.