Download the PHP package welldigit/kalimera without Composer

On this page you can find all versions of the php package welldigit/kalimera. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.

FAQ

After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

Example:
If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Example code of welldigit/kalimera

Informations about the package kalimera

Kalimera ☀️

Interactive installer that scaffolds a fresh Laravel application — one guided CLI flow from laravel new to a fully configured, quality-checked, Sail-running app with all the tools you need.

Instead of a boilerplate — a frozen copy of someone else's choices that goes stale — kalimera automates the initialization step itself: a fresh, current Laravel application prepared exactly the way you want it, the same way every time. Your package set is defined once in kalimera.config.json (the built-in catalog is the Spatie collection — replace it with your own), Pint + PHPStan + Rector and Sail are wired from the first commit, every choice is made at once upfront, and the whole run is unattended — driven by you or by your coding agent through the agent skill. A ready-to-build project in minutes, no manual setup each time.

Requirements

Tool Version Why it is on the host
PHP 8.4.1+ runs kalimera itself, laravel new and the first artisan calls
Composer 2.2+ installs kalimera and downloads the new app's packages
Laravel installer current laravel new
Docker running daemon, reachable without sudo Sail builds and runs the app
git any laravel new --git and the final commit

The host's PHP and Composer create the application and download its packages; everything that runs PHP afterwards runs inside Sail, on the PHP version you chose. Node.js is not needed on the host — npm install runs in the container. Before anything is installed, kalimera checks for every tool above and stops with a clear message if one is missing.

The host PHP needs the extensions Laravel itself needs to boot a fresh skeleton: curl, mbstring, openssl, pdo_sqlite, tokenizer, xml/dom and zip (or the unzip binary). The setups below include them.

macOS

Docker Desktop (or OrbStack) provides the daemon; PHP, Composer and the Laravel installer come from php.new, the one-liner the Laravel docs recommend, or from Homebrew.

Make sure ~/.composer/vendor/bin is on your PATH (php.new does this for you).

Ubuntu (22.04 / 24.04)

Ubuntu's own archive ships PHP 8.1 (22.04) or 8.3 (24.04), both too old to run kalimera, so PHP 8.4 comes from the ondrej/php PPA — or use curl -fsSL https://php.new/install/linux/8.4 | bash instead of the first two blocks.

Log out and back in (or run newgrp docker) after usermod — until then docker info fails with "permission denied" and kalimera reports that the Docker daemon did not answer. Never run kalimera with sudo to get around it: the app's files would end up owned by root.

Check the whole setup in one go:

Installation

Global (recommended)

Install once, use kalimera from anywhere — same mechanism as the laravel installer.

Make sure composer's global bin directory (~/.composer/vendor/bin or ~/.config/composer/vendor/bin) is in your PATH — if the laravel command works, it already is.

Working from a local checkout

Developing kalimera itself? Point global composer at your working copy with a path repository instead of Packagist (the symlink means every local change is instantly live):

(:@dev is needed because a path repository has no tagged releases — the package only exists as dev-main, and composer's default stability is stable.) A path repository is canonical, so it silently shadows the Packagist version even after you're done — switch back with:

Local (no global install)

Then call the binary by its full path from wherever the new app should live:

The app is created in the current working directory — don't run kalimera from inside this repo unless you want the app scaffolded into it.

Usage

Options:

Flag Effect
--dry-run Print every command without executing anything
--defaults Skip all prompts and accept the preselected answers
--continue Resume into an existing app directory after a failed run — the answers saved in its .kalimera.json are reused, no prompts, and the steps that file records as done are skipped so the run picks up where it stopped. The file is written after laravel new, gitignored, and removed when the scaffold completes. Editing the answers before resuming only affects steps that have not been checkpointed — a step already listed in completedSteps is skipped whatever its answers now say, so delete it from the list as well to have the edit take effect
--config=path Load the preselected answers and the additional-packages catalog from a JSON config — see Configuration. kalimera.config.json in the current directory is picked up automatically
--log[=path] Write an append-only transcript of steps, commands and outcomes to a log file (defaults to kalimera.log inside the new application, gitignored there)
--verbose, -v Stream the raw output of every command instead of condensing it to a progress line. Off by default: the Sail image build alone is tens of thousands of apt lines, which buries the installer's own steps. A failed command always replays its last 40 lines regardless, and --log captures everything either way

What it does

  1. Prompts for everything upfront: app name, starter kit (React / Vue / Livewire / Svelte / none, with optional manual Inertia), ecosystem packages (Horizon, Fortify, Laravel AI, Scout, Nightwatch), Sail services, PHP version constraint (default ^8.5), quality tools, additional packages, Postmark, GitHub repos for Boost skills, and any extra packages — then shows a summary and one final confirm. Before anything runs it checks that php, composer, laravel, docker and git are there, that PHP is 8.3+ and Composer 2.2+, and that Docker answers.

Then, on the host — no container exists yet:

  1. laravel new with Pest and git, no interaction.
  2. Installs Sail with the chosen services and pins its runtime to the chosen PHP version (sail:install --php=<minor>; it only writes compose.yaml and .env — the image is built later, once).
  3. Restricts require.php to the chosen constraint and pins composer's config.platform.php to the container's PHP — the exact version from your local Sail image when there is one — so the host's composer picks packages for the container whatever PHP the host runs. The pin stays in the app, so a later host-side composer update keeps resolving for the container.
  4. Publishes the Pint / PHPStan (Larastan + IDE Helper) / Rector configs (pint.json, phpstan.neon.dist, rector.php) and composer scripts: pint:dry, pint:fix, phpstan, phpstan-clear, ide-helper, rector:dry, rector:fix and the aggregate quality. Generated ide-helper files are gitignored.
  5. Prepares Laravel Vet (chosen at the quality-tools prompt, on by default): allows its composer plugin and adds a vet script plus @vet in quality.
  6. Optionally adds Postmark (symfony/postmark-mailer, the transport behind config/mail.php's postmark entry) with postmark:push / postmark:pull composer scripts and a POSTMARK_API_KEY env placeholder, and the Core structure: src/{Domain,Shared,Support,Feature,Infrastructure} with .gitkeep files, mapped to a PSR-4 namespace of your choice (Core by default).
  7. Downloads every package with the host's composer in one go — a runtime batch, a --dev batch, then each optional package (Nightwatch, extras) on its own, which warns instead of failing. Nothing executes yet (--no-scripts --no-plugins), and only network failures are retried.
  8. Installs the AI-agent guard: publishes app/Providers/AgentGuardServiceProvider.php and registers it last in bootstrap/providers.php, so destructive database commands (db:wipe, migrate:fresh/refresh/reset/rollback) are prohibited whenever an AI agent is driving the app — exactly as they already are in production. Detection comes from laravel/pao's AgentDetector, which ships with new Laravel apps by default and recognizes Claude Code, Cursor, Codex, Copilot, Gemini and others. Registration order matters and the provider must boot after AppServiceProvider; see TROUBLESHOOTING.md.

Then in the container, where the chosen PHP runs:

  1. Picks free host ports right before binding them (APP_PORT, FORWARD_DB_PORT, …) so parallel projects never clash, and boots the containers (sail up -d --wait).
  2. Records Vet's trust file (vet --init writes vet.json from every package just downloaded), then composer install — which checks the PHP extensions the host skipped, runs the composer plugins and package:discover — and publishes laravel-assets. From here on each composer install, update and require shows the code it is about to write into vendor/ and fails on a version nobody has read — review it with sail composer vet in a terminal. Commit vet.json. No minimum-release-age is set: the floor rejects releases younger than it even when trusted, so a fresh application would arrive failing its own audit — TROUBLESHOOTING.md has the recipe for turning it on.
  3. Sets up the ecosystem packages: horizon:install, fortify:install (skipped when the starter kit already ships it), Laravel AI's config and conversations migration, and Scout's config with SCOUT_DRIVER=database — full-text search on PostgreSQL or MySQL with no extra service (collection without either).
  4. Publishes the configs/migrations of the chosen additional packages. The built-in catalog is the Spatie collection (laravel-data, laravel-view-models, laravel-query-builder, laravel-backup, laravel-permission, laravel-activitylog, laravel-translatable) — replace it with your own via Configuration.
  5. Optionally installs Laravel Boost (on by default): you pick the AI agents (Claude Code, Cursor, Codex, Copilot, …) upfront — kalimera preconfigures boost.json and runs boost:install --guidelines --skills --mcp --no-interaction, fully unattended. (Select no agents to answer Boost's own prompts instead.) Then pulls your skills from GitHub via boost:add-skill <owner/repo> --all — one run per repository, so you can list several space- or comma-separated at the prompt. Finishes with boost:update --no-discover --no-interaction so the guidelines and skills are the latest guidance rather than whatever the installed release bundled (a warning, never a failure).
  6. Finalizes: migrates, npm install, generates the IDE helper files, formats the fresh skeleton with Rector + Pint, repairs the published stubs PHPStan would reject (no baseline, so composer quality starts green on its own merits), and commits.

Configuration

Kalimera works with zero configuration — the built-in setup is the curated Well Digit stack. To adapt it to your own, drop a kalimera.config.json next to where you run kalimera (or point at one with --config=path). Everything in it is optional; whatever you omit keeps the built-in behavior.

The built-in setup itself lives in schema/kalimera.config.schema.json: each property's enum lists the available options — what is there — and the default values of preselected and additionalPackages are the built-in choices — what is chosen. Kalimera reads it on start, so editing that file changes what the installer offers out of the box (your fork, your stack), while a kalimera.config.json overrides it per project. Referencing it via $schema gives your editor completion for every option. Validation happens in kalimera itself: every loaded file is checked on start and unknown keys or invalid values are refused with a precise error, so a typo fails before anything is installed, not halfway through.

Agent skill

The repo ships a ready-made agent skill at skills/kalimera/ that teaches AI coding agents to drive kalimera end-to-end. The agent becomes the prompt layer: it re-asks kalimera's full prompt set in its own interface (starter kit, Sail services, ecosystem and Spatie packages, PHP constraint, quality tools, Core structure, Boost agents, …), encodes the answers into a config JSON, and runs the installer unattended with --defaults — kalimera's own prompts would die in the agent's non-TTY shell. It then verifies the result and resumes failed runs. The skill is plain Markdown in the open Agent Skills format, so any skills-aware tool can consume it.

Layout

Quality & tests

The package dogfoods the same tooling it installs into new applications:

Individual scripts: pint:dry / pint:fix, rector:dry / rector:fix, phpstan, phpstan-clear, test and test:coverage.

The suite is split into three Pest test suites:

Steps talk to the outside world only through the ProcessRunner, PortChecker and ExecutableFinder seams, so the whole installer runs in-process against fakes (tests/Fakes/) — no Docker, network or laravel binary needed to test it.

Continuous integration

.github/workflows/ci.yml runs on every push and pull request:

Job What it covers
Quality matrix The full suite on PHP 8.4 and 8.5 across Ubuntu and macOS. Pint, PHPStan and Rector are platform-independent, so they run on Ubuntu only; macOS runs the tests because it is the platform kalimera is actually used on, and the one whose quirks the process handling works around — a relative program path that proc_open() reports as not found while still running it, which would make every sail command run twice
Lowest dependencies The suite against the lowest versions every composer.json constraint allows. Resolution always picks the newest, so without this the declared floors are never executed — this job is what caught mockery ^1.6 emitting PHP 8.4 deprecations at its lower bound
Coverage composer test:coverage, informational rather than a gate — the number exists so gaps are visible when deciding what to test next, not so a PR can be blocked on a decimal point

Because every test fakes the process runner, the suite proves kalimera emits the right commands but never that they succeed. Before a release, scaffold a real application with kalimera new <app> --defaults --log against real Docker and check the containers are up — every bug found in real use so far (every sail command running twice, an inherited volume, a frozen progress line) survived the faked-runner suite and only showed up in a real run.

All versions of kalimera with dependencies

PHP Build Version
Package Version
Requires php Version ^8.4.1
laravel/prompts Version ^0.3
symfony/process Version ^7.0 || ^8.0
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package welldigit/kalimera contains the following files

Loading the files please wait ...