singularity-cli

v0.3.1

Universal project command runner. One set of commands for every project type.

$curl -fsSL https://getsingularity.lol/cli | sh

Zero-config detection

Reads your project files. Detects Rust, Node, Python, Go, Java, .NET, Ruby, and more. No setup, no config.

Monorepo aware

Discovers all sub-projects in a workspace and runs commands in parallel - or serially with --serial.

Transparent

Every command shows the underlying invocation it runs. --dry-run or --explain to inspect before committing.

Introduction

singularity-cli (command: sgl) is a universal project command runner written in Rust. It detects your project's ecosystem from its manifest files and maps one consistent verb - sgl dev, sgl test, sgl build - to the right underlying command.

No configuration required. Switch between Rust, Node, Python, and Go projects and always type the same thing. In a monorepo it finds every sub-project and runs them in parallel.

Installation

Pick the method that matches your platform.

macOS / Linux

Windows

Cross-platform

curl -fsSL https://getsingularity.lol/cli | sh

macOS . Linux . WSL - downloads a prebuilt binary, verifies SHA256, installs to ~/.local/bin. Add ~/.local/bin to your $PATH if needed.

Commands & Flags

All commands share a common set of global flags and forward extra arguments to the underlying tool where applicable.

Commands

Command	Description	Example
`sgl setup`	Install dependencies for the detected project ecosystem.	`$ sgl setup`
`sgl dev`	Start dev server, watcher, or local daemon.	`$ sgl dev`
`sgl test [args]...`	Run tests. Extra arguments are automatically forwarded to the underlying test runner.Pass extra arguments without worrying about syntax conversion.	`$ sgl test -- --nocapture`
`sgl build`	Build the project using the native compiler or bundler.	`$ sgl build`
`sgl lint`	Run linter and formatting checks.	`$ sgl lint`
`sgl fmt`	Automatically format source files across the project.	`$ sgl fmt`
`sgl run <script> [args]...`	Run a project script or task. Forwards extra arguments (inserts npm -- separator when needed).	`$ sgl run migrate --dry-run`
`sgl doctor`	Check for installed development tools, versions, and system environment health.	`$ sgl doctor`
`sgl info [--json]`	Inspect detected projects, resolved package managers, and configured command mappings.	`$ sgl info`
`sgl init`	Generate an initial singularity.toml based on detected project ecosystems.	`$ sgl init`
`sgl completions <shell>`	Generate shell autocompletions for bash, zsh, fish, or powershell.	`$ sgl completions zsh > ~/.zsh/completion/_sgl`

Global Flags

Flag	Type	Description
`--dry-run`	bool	Print the commands that would run without executing them.
`-v, --verbose`	bool	Show verbose output and debug logs.
`-q, --quiet`	bool	Suppress non-error output.
`--no-color`	bool	Disable ANSI color formatting.
`--cwd <path>`	path	Execute command as if in the specified directory.
`--project <name>`	string	Limit monorepo execution to a single project name.
`--changed`	bool	Only run in projects with uncommitted or branch-changed files.
`--serial`	bool	Run monorepo projects sequentially instead of in parallel.
`--fail-fast`	bool	Abort execution immediately on the first project failure.
`--json`	bool	Output result as structured JSON (supported for info, doctor, --explain).
`--explain <verb>`	verb	Print the resolved underlying commands for a specific verb without running them.

Monorepos & Output

In a monorepo, sgl discovers all sub-projects and runs the requested command in parallel across all of them. Use --project to target one, --serial to run them in order, or --changed to limit to files with uncommitted changes.

monorepo usagebash

# Run tests across every sub-project in parallel
$ sgl test

# Only the "api" sub-project
$ sgl test --project api

# Serial execution, stop on first failure
$ sgl build --serial --fail-fast

# Only projects with uncommitted changes
$ sgl lint --changed

Supported Ecosystems

Detected automatically from manifest files - no config required.

Ecosystem	Detection	Package managers
Node.js	package.json	npm, pnpm, yarn, bun (resolved from lockfile)
Rust	Cargo.toml	cargo
Python	pyproject.toml, requirements.txt, Pipfile	uv, poetry, pipenv, pip
Go	go.mod	go
Java / Kotlin	pom.xml, build.gradle[.kts]	mvn, gradle / gradlew
.NET	.sln, .csproj	dotnet
Ruby	Gemfile	bundler
Docker	docker-compose.yml, compose.yaml	docker
Task / Make	Makefile, justfile, Justfile, Taskfile.yml	make, just, task

singularity.toml

Drop a singularity.toml at the project root to override auto-detected commands, add custom scripts, or set environment variables. Generate a starting file with sgl init.

singularity.tomltoml

[project]
name = "api"

[commands]
test = "pytest -x"
dev = ["docker compose up -d db", "uvicorn app:app --reload"]
deploy = "./scripts/deploy.sh"

[env]
DATABASE_URL = "postgres://localhost/dev"

Comparison

Unlike Makefile wrappers or per-language scripts, sgl requires no configuration to get started - detection is its primary mechanism. You can override it when you need to.

	sgl	Makefile	mise / just
Zero-config setup	✓	✗	✗
Cross-ecosystem	✓	✗	✓
Monorepo parallel	✓	✗	partial
Built-in override	✓	N/A	✓
Written in	Rust	N/A	Rust

Links & Resources

GitHub↗crates.io↗

Uninstall

If you installed via the curl script:

macOS / Linuxbash

rm ~/.local/bin/sgl

If you installed via cargo:

cargobash

cargo uninstall singularitycli

GitHub·crates.io

Other projects:/runspace