# this file contains all the shorthand names for tools in mise
# the format is as follows:
# [tool-name] = [long-names...]
# multiple are allowed for each tool because some backends may be disabled, like on windows we don't use asdf, for example
# or a backend may be disabled via MISE_DISABLE_BACKENDS=ubi

[tools.1password]
aliases = ["1password-cli", "op"]
backends = ["vfox:mise-plugins/vfox-1password", "aqua:1password/cli"]
description = "Password manager developed by AgileBits Inc"
test = ["op --version", "{{version}}"]

[tools.aapt2]
backends = ["vfox:mise-plugins/vfox-aapt2"]
description = "Android Asset Packaging Tool (aapt)"
test = [
  "aapt2 version 2>&1",
  "Android Asset Packaging Tool (aapt)",
] # version doesn't match

[tools.act]
backends = ["aqua:nektos/act", "ubi:nektos/act", "asdf:gr1m0h/asdf-act"]
description = "Run your GitHub Actions locally"
test = ["act --version", "act version {{version}}"]

[tools.action-validator]
backends = [
  "aqua:mpalmer/action-validator",
  "ubi:mpalmer/action-validator",
  "asdf:mpalmer/action-validator",
  "cargo:action-validator",
]
description = "Tool to validate GitHub Action and Workflow YAML files"
os = ["linux", "macos"]
test = ["action-validator --version", "action-validator {{version}}"]

[tools.actionlint]
backends = [
  "aqua:rhysd/actionlint",
  "ubi:rhysd/actionlint",
  "asdf:crazy-matt/asdf-actionlint",
  "go:github.com/rhysd/actionlint/cmd/actionlint",
]
description = ":octocat: Static checker for GitHub Actions workflow files"
test = ["actionlint --version", "{{version}}"]

[tools.adr-tools]
backends = [
  "aqua:npryce/adr-tools",
  "asdf:https://gitlab.com/td7x/asdf/adr-tools",
]
description = "Command-line tools for working with Architecture Decision Records"
test = ["adr help", "adr help"]

[tools.ag]
backends = ["vfox:mise-plugins/vfox-ag", "asdf:mise-plugins/mise-ag"]
description = "The Silver Searcher: A code searching tool similar to ack, with a focus on speed"
# test = ["ag --version", "ag version {{version}}"] # requires libpcre

[tools.age]
backends = ["aqua:FiloSottile/age", "asdf:threkk/asdf-age"]
description = "A simple, modern and secure encryption tool (and Go library) with small explicit keys, no config options, and UNIX-style composability"
test = ["age --version", "v{{version}}"]

[tools.age-plugin-yubikey]
backends = [
  "github:str4d/age-plugin-yubikey",
  "asdf:joke/asdf-age-plugin-yubikey",
  "cargo:age-plugin-yubikey",
]
description = "age-plugin-yubikey is a plugin for age clients like age and rage, which enables files to be encrypted to age identities stored on YubiKeys"
test = ["which age-plugin-yubikey", ""] # libpcsclite.so.1 is missing in CI

[tools.agebox]
backends = ["aqua:slok/agebox", "ubi:slok/agebox", "asdf:slok/asdf-agebox"]
description = "Age based repository file encryption gitops tool"
test = ["agebox --version 2>&1", "v{{version}}"]

[tools.aichat]
backends = ["aqua:sigoden/aichat"]
description = "Use GPT-4(V), Gemini, LocalAI, Ollama and other LLMs in the terminal"
test = ["aichat --version", "{{version}}"]

[tools.air]
backends = ["aqua:air-verse/air", "asdf:pdemagny/asdf-air"]
description = "Live reload for Go apps"
test = ["air -v", "{{version}}"]

[tools.aks-engine]
backends = ["aqua:Azure/aks-engine", "asdf:robsonpeixoto/asdf-aks-engine"]
description = "AKS Engine deploys and manages Kubernetes clusters in Azure"
test = ["aks-engine version", "Version: v{{version}}"]

[tools.allure]
backends = ["github:allure-framework/allure2", "asdf:mise-plugins/mise-allure"]
description = "Allure Report is a popular open source tool for visualizing the results of a test run"
test = ["allure --version", "{{version}}"]

[tools.allurectl]
backends = ["github:allure-framework/allurectl"]
description = "allurectl is the command line wrapper of Allure TestOps' API allowing you to upload the test results in real time from a build job, and managing entities on Allure TestOps side (test cases, launches, projects)"
test = ["allurectl --version", "allurectl version {{version}}"]

[tools.alp]
backends = ["aqua:tkuchiki/alp", "asdf:asdf-community/asdf-alp"]
description = "Access Log Profiler"
test = ["alp --version", "{{version}}"]

[tools.amass]
backends = ["github:owasp-amass/amass", "asdf:dhoeric/asdf-amass"]
description = "In-depth attack surface mapping and asset discovery"
test = ["amass -version 2>&1", "v"] # version is wrong from the CLI

[tools.amazon-ecr-credential-helper]
backends = [
  "aqua:awslabs/amazon-ecr-credential-helper",
  "asdf:dex4er/asdf-amazon-ecr-credential-helper",
]
description = "Automatically gets credentials for Amazon ECR on docker push/docker pull"
test = [
  "docker-credential-ecr-login version",
  "docker-credential-ecr-login (github.com/awslabs/amazon-ecr-credential-helper/ecr-login) {{version}}",
]

[tools.amazon-ecs-cli]
aliases = ["ecs-cli"]
backends = ["aqua:aws/amazon-ecs-cli"]
description = "The Amazon ECS CLI enables users to run their applications on ECS/Fargate using the Docker Compose file format, quickly provision resources, push/pull images in ECR, and monitor running applications on ECS/Fargate."
test = ["ecs-cli --version", "ecs-cli version {{version}}"]

[tools.amp]
backends = ["npm:@sourcegraph/amp"]
description = "An agentic coding tool built by Sourcegraph"
test = ["amp --version", "{{version}}"]

[tools.android-sdk]
backends = ["vfox:mise-plugins/vfox-android-sdk"]
depends = ["java"]
description = "Android Command-line tools"
test = ["sdkmanager --version", ".0"]

[tools.ansible]
backends = ["pipx:ansible[uvx=false,pipx_args=--include-deps]"]
description = "ansible python package contains the core runtime and CLI tools, such as ansible and ansible-playbook and extra modules, plugins, and roles"
test = ["ansible --version", "ansible"]

[tools.ansible-core]
aliases = ["ansible-base"]
backends = ["pipx:ansible-core"]
description = "ansible-core python package contains the core runtime and CLI tools, such as ansible and ansible-playbook"
test = ["ansible --version", "ansible [core {{version}}]"]

[tools.ant]
backends = ["vfox:mise-plugins/vfox-ant"]
description = "Apache Ant is a Java library and command-line tool whose mission is to drive processes described in build files as targets and extension points dependent upon each other"
test = ["ant -version", "Apache Ant(TM) version {{version}}"]

[tools.apko]
backends = [
  "aqua:chainguard-dev/apko",
  "ubi:chainguard-dev/apko",
  "asdf:omissis/asdf-apko",
]
description = "Build OCI images from APK packages directly without Dockerfile"
test = ["apko version", "GitVersion:    v{{version}}"]

[tools.apollo-ios]
aliases = ["apollo-ios-cli"]
backends = ["github:apollographql/apollo-ios"]
description = "Apollo iOS Code Generation"
os = ["macos"]

[tools.apollo-router]
backends = ["github:apollographql/router", "asdf:safx/asdf-apollo-router"]
description = "A configurable, high-performance routing runtime for Apollo Federation"
test = ["router --version", "{{version}}"]

[tools.apollo-rover]
backends = ["github:apollographql/rover"]
description = "The CLI for Apollo GraphOS"
test = ["rover --version", "Rover {{version}}"]

[tools.aqua]
backends = ["github:aquaproj/aqua"]
description = "Declarative CLI Version manager written in Go. Support Lazy Install, Registry, and continuous update with Renovate. CLI version is switched seamlessly"
test = ["aqua version", "{{version}}"]

[tools.arduino]
aliases = ["arduino-cli"]
backends = ["aqua:arduino/arduino-cli", "asdf:egnor/asdf-arduino-cli"]
description = "Arduino command line tool"
test = ["arduino-cli version", "arduino-cli  Version: {{version}}"]

[tools.argc]
backends = ["github:sigoden/argc"]
description = "A Bash CLI framework, also a Bash command runner"
test = ["argc --argc-version", "argc {{version}}"]

[tools.argo]
backends = ["aqua:argoproj/argo-workflows", "asdf:sudermanjr/asdf-argo"]
description = "Argo Workflows CLI. Workflow engine for Kubernetes"
test = ["argo version", "argo: v{{version}}"]

[tools.argo-rollouts]
backends = ["aqua:argoproj/argo-rollouts", "asdf:abatilo/asdf-argo-rollouts"]
description = "Progressive Delivery for Kubernetes"
test = ["kubectl-argo-rollouts version", "kubectl-argo-rollouts: v{{version}}"]

[tools.argocd]
backends = [
  "aqua:argoproj/argo-cd",
  "ubi:argoproj/argo-cd[exe=argocd]",
  "asdf:beardix/asdf-argocd",
]
description = "Declarative continuous deployment for Kubernetes"
test = ["argocd version --client", "argocd: v{{version}}"]

[tools.asciidoctorj]
backends = [
  "vfox:mise-plugins/vfox-asciidoctorj",
  "asdf:mise-plugins/mise-asciidoctorj",
]
description = "AsciidoctorJ is the official library for running Asciidoctor on the JVM. Using AsciidoctorJ, you can convert AsciiDoc content or analyze the structure of a parsed AsciiDoc document from Java and other JVM languages"
test = ["asciidoctorj --version", "AsciidoctorJ {{version}}"]

[tools.assh]
backends = ["github:moul/assh", "asdf:mise-plugins/mise-assh"]
description = "make your ssh client smarter"
test = ["assh --version", "assh version "] # 2.16.0 reports version n/a

[tools.ast-grep]
backends = [
  "aqua:ast-grep/ast-grep",
  "cargo:ast-grep",
  "npm:@ast-grep/cli",
  "pipx:ast-grep-cli",
]
description = "A CLI tool for code structural search, lint and rewriting. Written in Rust"
test = ["sg --version", "ast-grep {{version}}"]

[tools.astro]
backends = ["github:astronomer/astro-cli[exe=astro]"]
description = "CLI that makes it easy to create, test and deploy Airflow DAGs to Astronomer"
test = ["astro version", "Astro CLI Version: {{version}}"]

[tools.atlas]
backends = ["aqua:ariga/atlas", "asdf:komi1230/asdf-atlas"]
description = "A modern tool for managing database schemas"
test = ["atlas version", "atlas version v{{version}}"]

[tools.atmos]
backends = ["aqua:cloudposse/atmos", "asdf:cloudposse/asdf-atmos"]
description = "Workflow automation tool for DevOps. Keep configuration DRY with hierarchical imports of configurations, inheritance, and WAY more. Native support for Terraform and Helmfile"
idiomatic_files = [".atmos-version"]
test = ["atmos version", "Atmos {{version}}"]

[tools.atuin]
backends = ["aqua:atuinsh/atuin", "ubi:atuinsh/atuin", "cargo:atuin"]
description = "✨ Magical shell history"
test = ["atuin --version", "atuin {{version}}"]

[tools.auto-doc]
backends = ["github:tj-actions/auto-doc", "asdf:mise-plugins/mise-auto-doc"]
description = "Github action that turns your reusable workflows and custom actions into easy to read markdown tables"
test = ["auto-doc --help", "auto-doc [flags]"]

[tools.aws-amplify]
aliases = ["amplify"]
backends = [
  "ubi:aws-amplify/amplify-cli[exe=amplify-pkg,rename_exe=amplify]",
  "asdf:LozanoMatheus/asdf-aws-amplify-cli",
]
description = "The AWS Amplify CLI is a toolchain for simplifying serverless web and mobile development"
test = ["amplify --version", "{{version}}"]

[tools.aws-cli]
aliases = ["aws", "awscli"]
backends = [
  { full = "aqua:aws/aws-cli", options = { symlink_bins = "true" } },
  "asdf:MetricMike/asdf-awscli",
]
description = "The AWS Command Line Interface (AWS CLI v2) is a unified tool that provides a consistent interface for interacting with all parts of Amazon Web Services"
os = ["linux", "macos"]
test = ["aws --version", "aws-cli/{{version}}"]

[tools.aws-copilot]
backends = ["aqua:aws/copilot-cli", "asdf:NeoHsu/asdf-copilot"]
description = "The AWS Copilot CLI is a tool for developers to build, release and operate production ready containerized applications on AWS App Runner, Amazon ECS, and AWS Fargate"
test = ["copilot --version", "copilot version: v{{version}}"]

[tools.aws-iam-authenticator]
backends = [
  "aqua:kubernetes-sigs/aws-iam-authenticator",
  "asdf:zekker6/asdf-aws-iam-authenticator",
]
description = "A tool to use AWS IAM credentials to authenticate to a Kubernetes cluster"
test = ["aws-iam-authenticator version", '"Version":"{{version}}"']

[tools.aws-nuke]
backends = ["aqua:ekristen/aws-nuke", "asdf:bersalazar/asdf-aws-nuke"]
description = "Remove all the resources from an AWS account"
test = ["aws-nuke --version", "aws-nuke version v{{version}}"]

[tools.aws-sam]
aliases = ["aws-sam-cli"]
backends = [
  { full = "aqua:aws/aws-sam-cli", platforms = [
    "linux",
    "macos",
  ], options = { symlink_bins = "true" } },
  "pipx:aws-sam-cli",
  "asdf:mise-plugins/mise-pyapp",
]
description = "CLI tool to build, test, debug, and deploy Serverless applications using AWS SAM"
test = ["sam --version", "SAM CLI, version {{version}}"]

[tools.aws-sso]
backends = ["aqua:synfinatic/aws-sso-cli", "asdf:adamcrews/asdf-aws-sso-cli"]
description = "A powerful tool for using AWS Identity Center for the CLI and web console"
test = ["aws-sso version", "AWS SSO CLI Version {{version}}"]

[tools.aws-vault]
backends = ["aqua:99designs/aws-vault", "asdf:karancode/asdf-aws-vault"]
description = "A vault for securely storing and accessing AWS credentials in development environments"
test = ["aws-vault --version 2>&1", "v{{version}}"]

[tools.awscli-local]
backends = ["pipx:awscli-local"]
description = "This package provides the awslocal command, which is a thin wrapper around the aws command line interface for use with LocalStack"
test = ["awslocal --version", "aws-cli/"]

[tools.awsebcli]
backends = ["pipx:awsebcli", "asdf:mise-plugins/mise-pyapp"]
description = "The AWS Elastic Beanstalk Command Line Interface (EB CLI) is a tool that helps you deploy and manage your Elastic Beanstalk applications and environments. It also provides integration with Git"
test = ["eb --version", "EB CLI {{version}}"]

[tools.awsls]
backends = ["github:jckuester/awsls", "asdf:chessmango/asdf-awsls"]
description = "A list command for AWS resources"
test = ["awsls --version", "version: {{version}}"]

[tools.awsrm]
backends = ["github:jckuester/awsrm", "asdf:chessmango/asdf-awsrm"]
description = "A remove command for AWS resources"
test = ["awsrm --version", "version: {{version}}"]

[tools.awsweeper]
backends = ["github:jckuester/awsweeper", "asdf:chessmango/asdf-awsweeper"]
description = "A tool for cleaning your AWS account"
test = ["awsweeper --version", "version: {{version}}"]

[tools.azure]
aliases = ["azure-cli"]
backends = ["asdf:mise-plugins/mise-azure-cli"]
description = "azure-cli (az)"
test = ["az --version", "azure-cli                         {{version}}"]

[tools.azure-functions-core-tools]
backends = [
  "vfox:mise-plugins/vfox-azure-functions-core-tools",
  "asdf:mise-plugins/mise-azure-functions-core-tools",
]
description = "Command line tools for Azure Functions"

[tools.azure-kubelogin]
backends = ["aqua:Azure/kubelogin", "asdf:sechmann/asdf-kubelogin"]
description = "A Kubernetes credential (exec) plugin implementing azure authentication"
test = ["kubelogin --version", "git hash: v{{version}}"]

[tools.babashka]
backends = ["github:babashka/babashka[exe=bb]", "asdf:pitch-io/asdf-babashka"]
description = "Native, fast starting Clojure interpreter for scripting"
test = ["bb --version", "babashka v{{version}}"]

[tools.balena]
aliases = ["balena-cli"]
backends = ["github:balena-io/balena-cli", "asdf:jaredallard/asdf-balena-cli"]
description = "The balena CLI is a Command Line Interface for balenaCloud or openBalena"
test = ["balena --version", "{{version}}"]

[tools.bashbot]
backends = ["aqua:mathew-fleisch/bashbot", "asdf:mathew-fleisch/asdf-bashbot"]
description = "A slack-bot written in golang for infrastructure/devops teams"
test = ["bashbot version", "v{{version}}"]

[tools.bashly]
backends = ["gem:bashly", "asdf:mise-plugins/mise-bashly"]
depends = ["ruby"]
description = "Bashly is a command line application (written in Ruby) that lets you generate feature-rich bash command line tools"
# test = ["bashly --version", "{{version}}"]  # not working in CI

[tools.bat]
backends = [
  "aqua:sharkdp/bat",
  "ubi:sharkdp/bat",
  "cargo:bat",
  "asdf:https://gitlab.com/wt0f/asdf-bat",
]
description = "A cat(1) clone with wings"
test = ["bat --version", "bat {{version}}"]

[tools.bat-extras]
backends = ["aqua:eth-p/bat-extras", "asdf:mise-plugins/mise-bat-extras"]
description = "Bash scripts that integrate bat with various command line tools"
test = ["batman --version", "batman {{version}}"]

[tools.bats]
backends = ["aqua:bats-core/bats-core", "asdf:timgluz/asdf-bats"]
description = "Bash Automated Testing System"
os = ["linux", "macos"]
test = ["bats -v", "Bats"]

[tools.bazel]
backends = [
  "aqua:bazelbuild/bazel",
  "ubi:bazelbuild/bazel",
  "asdf:rajatvig/asdf-bazel",
]
description = "a fast, scalable, multi-language and extensible build system"
test = ["bazel --version", "bazel {{version}}"]

[tools.bazel-watcher]
backends = ["aqua:bazelbuild/bazel-watcher"]
description = "Tools for building Bazel targets when source files change"
test = ["ibazel version 2>&1", "iBazel - Version v{{version}}"]

[tools.bazelisk]
backends = [
  "aqua:bazelbuild/bazelisk",
  "npm:@bazel/bazelisk",
  "asdf:josephtate/asdf-bazelisk",
]
description = "A user-friendly launcher for Bazel"
test = [
  "bazelisk --version",
  "bazel",
] # shows bazel version, not bazelisk version

[tools.bbr-s3-config-validator]
backends = ["asdf:mise-plugins/tanzu-plug-in-for-asdf"]
description = "The BOSH Backup and Restore (BBR) S3 bucket configuration validator is a tool to validate and troubleshoot your Cloud Foundry and BBR external blobstore configuration"
os = ["linux"]
test = ["bbr-s3-config-validator --help", ""] # no version output

[tools.bfs]
backends = ["vfox:mise-plugins/vfox-bfs", "asdf:mise-plugins/mise-bfs"]
description = "Breadth-first search for your files"
test = ["bfs --version", "bfs {{version}}"]

[tools.binnacle]
backends = ["aqua:Traackr/binnacle", "asdf:Traackr/asdf-binnacle"]
description = "An opinionated tool to interact with Kubernetes' Helm"
test = ["binnacle --version", "binnacle version {{version}}"]

[tools.biome]
backends = ["aqua:biomejs/biome", "ubi:biomejs/biome", "npm:@biomejs/biome"]
description = "A toolchain for web projects, aimed to provide functionalities to maintain them. Biome offers formatter and linter, usable via CLI and LSP"
test = ["biome --version", "Version: {{version}}"]

[tools.bitwarden]
backends = ["aqua:bitwarden/clients", "asdf:vixus0/asdf-bitwarden"]
description = "Bitwarden CLI"
test = ["bw --version", "{{version}}"]

[tools.bitwarden-secrets-manager]
backends = [
  "github:bitwarden/sdk[version_prefix=bws-v]",
  "asdf:asdf-community/asdf-bitwarden-secrets-manager",
]
description = "CLI for interacting with the Bitwarden Secrets Manager"
test = ["bws --version", "bws {{version}}"]

[tools.blender]
backends = ["aqua:blender/blender"]
description = "Blender is a free and open-source 3D computer graphics software"
test = ["blender --version", "Blender {{version}}"]

[tools.black]
backends = ["aqua:psf/black"]
description = "The uncompromising Python code formatter"
test = ["black --version", "black, {{version}}"]

[tools.bob]
backends = [
  "aqua:MordechaiHadad/bob",
  'ubi:MordechaiHadad/bob[matching_regex=bob-(linux|macos|windows)-(arm|x86_64)\.zip$]',
  "cargo:bob-nvim",
]
description = "A version manager for neovim"
test = ["bob --version", "bob-nvim {{version}}"]

[tools.boilerplate]
backends = ["aqua:gruntwork-io/boilerplate"]
description = 'A tool for generating files and folders ("boilerplate") from a set of templates'
test = ["boilerplate --version", "boilerplate version v{{version}}"]

[tools.bombardier]
backends = ["aqua:codesenberg/bombardier", "asdf:NeoHsu/asdf-bombardier"]
description = "Fast cross-platform HTTP benchmarking tool written in Go"
test = ["bombardier --version 2>&1", "bombardier version"] # shows "unspecified"

[tools.borg]
backends = ["aqua:borgbackup/borg", "asdf:lwiechec/asdf-borg"]
description = "Deduplicating archiver with compression and authenticated encryption"
test = ["borg --version", "borg {{version}}"]

[tools.bosh]
backends = [
  "aqua:cloudfoundry/bosh-cli",
  "asdf:mise-plugins/tanzu-plug-in-for-asdf",
]
description = "The bosh CLI is the command line tool used for interacting with all things BOSH, from deployment operations to software release management"
test = ["bosh --version", "version {{version}}"]

[tools.bosh-backup-and-restore]
aliases = ["bbr"]
backends = [
  "ubi:cloudfoundry-incubator/bosh-backup-and-restore[matching=bbr-1]",
  "asdf:mise-plugins/tanzu-plug-in-for-asdf",
]
description = "BOSH Backup and Restore is a CLI utility for orchestrating the backup and restore of BOSH deployments and BOSH directors"
os = ["linux", "macos"]
test = ["bosh-backup-and-restore version", "bbr version {{version}}"]

[tools.bottom]
backends = [
  "aqua:ClementTsang/bottom",
  "asdf:carbonteq/asdf-btm",
  "cargo:bottom",
]
description = "Yet another cross-platform graphical process/system monitor"
test = ["btm --version", "bottom {{version}}"]

[tools.boundary]
backends = ["aqua:hashicorp/boundary", "asdf:mise-plugins/mise-hashicorp"]
description = "Boundary enables identity-based access management for dynamic infrastructure"
test = ["boundary version", "Version Number:      {{version}}"]

[tools.bpkg]
backends = ["vfox:mise-plugins/vfox-bpkg", "asdf:mise-plugins/mise-bpkg"]
description = "Lightweight bash package manager"
test = ["bpkg --version", "{{version}}"]

[tools.brig]
backends = ["aqua:brigadecore/brigade", "asdf:Ibotta/asdf-brig"]
description = "Brigade CLI. Event-driven scripting for Kubernetes"
test = ["brig version", "Brigade client: version v{{version}}"]

[tools.btop]
backends = ["aqua:aristocratos/btop", "ubi:aristocratos/btop"]
description = "A monitor of resources"
test = [
  '''btop --version | sed -e 's/\x1b\[[0-9;]*m//g'''',
  "btop version: {{version}}",
]

[tools.btrace]
backends = ["github:btraceio/btrace", "asdf:mise-plugins/mise-btrace"]
description = "BTrace - a safe, dynamic tracing tool for the Java platform"
test = ["btrace --version", "BTrace v.{{version}}"]

[tools.buck2]
backends = ["github:facebook/buck2[bin=buck2]"]
description = "A fast, hermetic, multi-language build system"
test = ["buck2 --version", "buck2"]

[tools.buf]
backends = ["aqua:bufbuild/buf", "ubi:bufbuild/buf", "asdf:truepay/asdf-buf"]
description = "The best way of working with Protocol Buffers"
test = ["buf --version", "{{version}}"]

[tools.buildifier]
backends = ["aqua:bazelbuild/buildtools/buildifier"]
description = "buildifier: For formatting BUILD, BUILD.bazel and BUCK files in a standard way"
test = ["buildifier --version", "buildifier version: {{version}}"]

[tools.buildpack]
aliases = ["pack", "buildpacks"]
backends = ["aqua:buildpacks/pack", "asdf:johnlayton/asdf-buildpack"]
description = "CLI for building apps using Cloud Native Buildpacks"
test = ["pack --version", "{{version}}"]

[tools.bun]
backends = ["core:bun"]
description = "Bun is a fast JavaScript all-in-one toolkit"
test = ["bun --version", "{{version}}"]

[tools.cabal]
backends = ["aqua:haskell/cabal/cabal-install"]
description = "Cabal(haskell): Common Architecture for Building Applications and Libraries"
test = ["cabal --version", "cabal-install version {{version}}"]

[tools.caddy]
backends = ["aqua:caddyserver/caddy", "asdf:salasrod/asdf-caddy"]
description = "Fast, multi-platform web server with automatic HTTPS"
test = ["caddy --version", "v{{version}}"]

[tools.calendarsync]
backends = [
  "aqua:inovex/CalendarSync",
  "ubi:inovex/CalendarSync",
  "asdf:FeryET/asdf-calendarsync",
]
description = "Stateless CLI tool to sync calendars across different calendaring systems"
test = ["CalendarSync --version", "Version: {{version}}"]

[tools.calicoctl]
backends = [
  "aqua:projectcalico/calico/calicoctl",
  "asdf:TheCubicleJockey/asdf-calicoctl",
]
description = "Cloud native networking and network security"
test = ["calicoctl version", "Client Version:    v{{version}}"]

[tools.carapace]
backends = ["aqua:carapace-sh/carapace-bin"]
description = "A multi-shell completion binary"
test = ["carapace --version 2>&1", "carapace-bin {{version}}"]

[tools.cargo-binstall]
backends = [
  "aqua:cargo-bins/cargo-binstall",
  'ubi:cargo-bins/cargo-binstall[tag_regex=^\\d\\.]',
  "cargo:cargo-binstall",
]
description = "Binary installation for rust projects"
test = ["cargo binstall -V", "{{version}}"]

[tools.cargo-insta]
backends = ["aqua:mitsuhiko/insta", "ubi:mitsuhiko/insta", "cargo:insta"]
description = "A snapshot testing library for rust"
test = ["cargo insta --version", "cargo-insta {{version}}"]

[tools.cargo-make]
backends = [
  "aqua:sagiegurari/cargo-make",
  "ubi:sagiegurari/cargo-make",
  "asdf:mise-plugins/asdf-cargo-make",
  "cargo:cargo-make",
]
description = "Rust task runner and build tool"
test = ["makers --version", "cargo-make {{version}}"]

[tools.carp]
backends = ["github:carp-lang/Carp[exe=carp]", "asdf:susurri/asdf-carp"]
description = "Carp Language"
test = ["which carp", ""] # hangs in non-interactive shells

[tools.carthage]
backends = [
  "vfox:mise-plugins/vfox-carthage",
  "asdf:mise-plugins/mise-carthage",
]
description = "A simple, decentralized dependency manager for Cocoa"
os = ["macos"]

[tools.ccache]
backends = ["github:ccache/ccache", "asdf:asdf-community/asdf-ccache"]
description = "ccache – a fast compiler cache"
test = ["ccache --version", "ccache version {{version}}"]

[tools.certstrap]
backends = ["github:square/certstrap", "asdf:carnei-ro/asdf-certstrap"]
description = "Tools to bootstrap CAs, certificate requests, and signed certificates"
test = ["certstrap --version", "certstrap version {{version}}"]

[tools.cf]
backends = ["github:cloudfoundry/cli", "asdf:mise-plugins/mise-cf"]
description = "The official command line client for Cloud Foundry"
test = ["cf version", "cf version {{version}}"]

[tools.cfn-lint]
backends = ["pipx:cfn-lint"]
description = "Checks CloudFormation templates for practices and behaviour that could potentially be improved"
# test = ["cfn-lint --version", "cfn-lint {{version}}"] # disabled: failing in CI

[tools.cfssl]
backends = ["aqua:cloudflare/cfssl/cfssl", "asdf:mathew-fleisch/asdf-cfssl"]
description = "CFSSL: Cloudflare's PKI and TLS toolkit"

[tools.cfssljson]
backends = ["aqua:cloudflare/cfssl/cfssljson"]
description = "cfssljson: Takes the JSON output from Cloudflare's cfssl and multirootca programs and writes certificates, keys, CSRs, and bundles to disk."
test = ["cfssljson -version", "Version: {{version}}"]

[tools.chamber]
backends = [
  "aqua:segmentio/chamber",
  "ubi:segmentio/chamber",
  "asdf:mintel/asdf-chamber",
]
description = "CLI for managing secrets"
test = ["chamber version", "chamber v{{version}}"]

[tools.changie]
backends = [
  "aqua:miniscruff/changie",
  "ubi:miniscruff/changie",
  "asdf:pdemagny/asdf-changie",
]
description = "Automated changelog tool for preparing releases with lots of customization options"
test = ["changie --version", "changie version v{{version}}"]

[tools.cheat]
backends = ["aqua:cheat/cheat", "asdf:jmoratilla/asdf-cheat-plugin"]
description = "cheat allows you to create and view interactive cheatsheets on the command-line. It was designed to help remind *nix system administrators of options for commands that they use frequently, but not frequently enough to remember"

[tools.checkmake]
backends = ["aqua:mrtazz/checkmake"]
description = "experimental linter/analyzer for Makefiles"
test = ["checkmake --version", "checkmake {{version}}"]

[tools.checkov]
backends = [
  "aqua:bridgecrewio/checkov",
  "ubi:bridgecrewio/checkov",
  "asdf:bosmak/asdf-checkov",
]
description = "Prevent cloud misconfigurations and find vulnerabilities during build-time in infrastructure as code, container images and open source packages with Checkov by Bridgecrew"
test = ["checkov -v", "{{version}}"]

[tools.chezmoi]
backends = [
  "aqua:twpayne/chezmoi",
  "ubi:twpayne/chezmoi",
  "asdf:joke/asdf-chezmoi",
]
description = "Manage your dotfiles across multiple diverse machines, securely"
test = ["chezmoi --version", "chezmoi version v{{version}}"]

[tools.chezscheme]
backends = [
  "vfox:mise-plugins/vfox-chezscheme",
  "asdf:mise-plugins/mise-chezscheme",
]
description = "Chez Scheme is both a programming language and an implementation of that language, with supporting tools and documentation"

[tools.chicken]
backends = ["vfox:mise-plugins/vfox-chicken"]
description = "CHICKEN is a compiler for the Scheme programming language"
os = ["linux", "macos", "freebsd", "openbsd"]
test = ["csi -version", "Version"]

[tools.chisel]
backends = [
  "aqua:jpillora/chisel",
  "ubi:jpillora/chisel",
  "go:github.com/jpillora/chisel",
  "asdf:lwiechec/asdf-chisel",
]
description = "A fast TCP/UDP tunnel over HTTP"
test = ["chisel --version", "{{version}}"]

[tools.choose]
backends = [
  "aqua:theryangeary/choose",
  "ubi:theryangeary/choose",
  "cargo:choose",
  "asdf:carbonteq/asdf-choose",
]
description = "A human-friendly and fast alternative to cut (and sometimes awk)"
test = ["choose --version", "{{version}}"]

[tools.chromedriver]
backends = [
  "vfox:mise-plugins/vfox-chromedriver",
  "asdf:mise-plugins/mise-chromedriver",
]
description = "ChromeDriver is a standalone server that implements the W3C WebDriver and WebDriver BiDi standards"
test = ["chromedriver --version", "ChromeDriver {{version}}"]

[tools.cidr-merger]
backends = ["github:zhanhb/cidr-merger", "asdf:ORCID/asdf-cidr-merger"]
description = "A simple command line tool to merge ip/ip cidr/ip range, supports IPv4/IPv6"
test = ["cidr-merger --version 2>&1", "cidr merger {{version}}"]

[tools.cidrchk]
backends = ["github:mhausenblas/cidrchk", "asdf:ORCID/asdf-cidrchk"]
description = "CLI tool for CIDR range operations (check, generate)"
test = ["cidrchk --version", "{{version}},"]

[tools.cilium-cli]
backends = [
  "aqua:cilium/cilium-cli",
  "ubi:cilium/cilium-cli[exe=cilium]",
  "asdf:carnei-ro/asdf-cilium-cli",
]
description = "CLI to install, manage & troubleshoot Kubernetes clusters running Cilium"
test = ["cilium version", "cilium-cli: v{{version}}"]

[tools.cilium-hubble]
backends = ["github:cilium/hubble", "asdf:NitriKx/asdf-cilium-hubble"]
description = "Hubble - Network, Service & Security Observability for Kubernetes using eBPF"
test = ["hubble --version", "{{version}}"]

[tools.circleci]
aliases = ["circleci-cli"]
backends = [
  "aqua:CircleCI-Public/circleci-cli",
  "ubi:CircleCI-Public/circleci-cli[exe=circleci]",
  "asdf:ucpr/asdf-circleci-cli",
]
description = "Use CircleCI from the command line"
test = ["circleci version", "{{version}}"]

[tools.clang]
backends = ["asdf:mise-plugins/mise-llvm", "vfox:mise-plugins/vfox-clang"]
description = "Clang is an 'LLVM native' C/C++/Objective-C compiler, which aims to deliver amazingly fast compiles, extremely useful error and warning messages and to provide a platform for building great source level tools"

[tools.clang-format]
backends = ["asdf:mise-plugins/mise-llvm"]
description = "format C/C++/Java/JavaScript/JSON/Objective-C/Protobuf/C# code"

[tools.clangd]
backends = ["asdf:mise-plugins/mise-llvm"]
description = "clangd understands your C++ code and adds smart features to your editor: code completion, compile errors, go-to-definition and more"

[tools.clarinet]
backends = ["github:hirosystems/clarinet", "asdf:alexgo-io/asdf-clarinet"]
description = "Write, test and deploy high-quality smart contracts to the Stacks blockchain and Bitcoin"
os = ["linux", "macos"]
test = ["clarinet --version", "clarinet {{version}}"]

[tools.claude]
aliases = ["claude-code"]
description = "Claude Code is an agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explaining complex code, and handling git workflows -- all through natural language commands"
os = ["linux", "macos"]
test = ["claude --version", "{{version}} (Claude Code)"]

[[tools.claude.backends]]
full = "http:claude"

[tools.claude.backends.options]
bin = "claude"
version_list_url = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/stable"

[tools.claude.backends.options.platforms.macos-arm64]
url = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/{version}/darwin-arm64/claude"

[tools.claude.backends.options.platforms.macos-x64]
url = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/{version}/darwin-x64/claude"

[tools.claude.backends.options.platforms.linux-arm64]
url = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/{version}/linux-arm64/claude"

[tools.claude.backends.options.platforms.linux-x64]
url = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases/{version}/linux-x64/claude"

[[tools.claude.backends]]
full = "npm:@anthropic-ai/claude-code"

[tools.claude-squad]
backends = ["aqua:smtg-ai/claude-squad", "ubi:smtg-ai/claude-squad"]
description = "Manage multiple AI agents like Claude Code, Aider, Codex, and Amp. 10x your productivity"
test = ["claude-squad version", """
claude-squad version {{version}}
https://github.com/smtg-ai/claude-squad/releases/tag/v{{version}}"""]

[tools.cli53]
backends = ["aqua:barnybug/cli53"]
description = "Command line tool for Amazon Route 53"
test = ["cli53 --version", "cli53 version {{version}}"]

[tools.clickhouse]
backends = [
  "vfox:mise-plugins/vfox-clickhouse",
  "asdf:mise-plugins/mise-clickhouse",
]
description = "ClickHouse® is a high-performance, column-oriented SQL database management system (DBMS) for online analytical processing (OLAP)"
test = [
  "clickhouse --version",
  "ClickHouse local version {{version | trim_end_matches(pat='-lts') | trim_end_matches(pat='-stable')}}",
]

[tools.clj-kondo]
backends = ["github:clj-kondo/clj-kondo", "asdf:rynkowsg/asdf-clj-kondo"]
description = "Static analyzer and linter for Clojure code that sparks joy"
test = ["clj-kondo --version", "{{version}}"]

[tools.cljstyle]
backends = ["github:greglook/cljstyle", "asdf:abogoyavlensky/asdf-cljstyle"]
description = "A tool for formatting Clojure code"
os = ["linux", "macos"]
test = ["cljstyle version", "mvxcvi/cljstyle {{version}}"]

[tools.clojure]
backends = ["asdf:mise-plugins/mise-clojure"]
description = "The Clojure Programming Language"

[tools.cloud-sql-proxy]
backends = [
  "aqua:GoogleCloudPlatform/cloud-sql-proxy",
  "asdf:pbr0ck3r/asdf-cloud-sql-proxy",
]
description = "A utility for connecting securely to your Cloud SQL instances"

[tools.cloudflared]
backends = ["aqua:cloudflare/cloudflared", "asdf:threkk/asdf-cloudflared"]
description = "cloudflared connects your machine or user identity to Cloudflare's global network"
test = ["cloudflared -v", "cloudflared version {{version}}"]

[tools.clusterawsadm]
backends = [
  "ubi:kubernetes-sigs/cluster-api-provider-aws",
  "asdf:kahun/asdf-clusterawsadm",
]
description = "clusterawsadm provides helpers for bootstrapping Kubernetes Cluster API Provider AWS"
test = ["cluster-api-provider-aws version", "clusterawsadm version:"]

[tools.clusterctl]
backends = [
  "aqua:kubernetes-sigs/cluster-api",
  "asdf:pfnet-research/asdf-clusterctl",
]
description = "Home for Cluster API, a subproject of sig-cluster-lifecycle"
test = ["clusterctl version", "{{version}}"]

[tools.cmake]
backends = [
  "aqua:Kitware/CMake",
  "asdf:mise-plugins/mise-cmake",
  "vfox:mise-plugins/vfox-cmake",
]
description = "CMake is a tool to manage building of source code. Originally, CMake was designed as a generator for various dialects of Makefile, today CMake generates modern buildsystems such as Ninja as well as project files for IDEs such as Visual Studio and Xcode"
test = ["cmake --version", """
cmake version {{version}}

CMake suite maintained and supported by Kitware (kitware.com/cmake)."""]

[tools.cmctl]
backends = ["aqua:cert-manager/cmctl", "asdf:asdf-community/asdf-cmctl"]
description = "the command line utility that makes cert-manager'ing easier"

[tools.cmdx]
backends = ["aqua:suzuki-shunsuke/cmdx", "ubi:suzuki-shunsuke/cmdx"]
description = "Task runner. It provides useful help messages and supports interactive prompts and validation of arguments"
test = ["cmdx version", "cmdx version {{version}}"]

[tools.cockroach]
backends = ["aqua:cockroachdb/cockroach", "asdf:salasrod/asdf-cockroach"]
description = "A distributed SQL database designed for speed, scale, and survival"
test = ["cockroach version", "v{{version}}"]

[tools.cocoapods]
backends = ["asdf:mise-plugins/mise-cocoapods"]
description = "CocoaPods is a dependency manager for Swift and Objective-C Cocoa projects"

[tools.cocogitto]
backends = ["aqua:cocogitto/cocogitto"]
description = "The Conventional Commits toolbox"
test = ["cog --version", "cog {{version}}"]

[tools.code]
backends = [
  "aqua:just-every/code",
  "ubi:just-every/code",
  "npm:@just-every/code",
]
description = "Fast, effective, mind-blowing, coding CLI. Browser integration, multi-agents, theming, and reasoning control. Orchestrate agents from OpenAI, Claude, Gemini or any provider."
test = ["code --version", "code {{version}}"]

[tools.codebuff]
backends = ["npm:codebuff"]
description = "Codebuff is a CLI tool that writes code for you"

[tools.codefresh]
backends = [
  "github:codefresh-io/cli[exe=codefresh]",
  "asdf:gurukulkarni/asdf-codefresh",
]
description = "The Codefresh CLI provides a full and flexible interface to interact with Codefresh"

[tools.codeql]
backends = ["asdf:mise-plugins/mise-codeql"]
description = "CodeQL CLI"

[tools.coder]
backends = ["aqua:coder/coder", "asdf:mise-plugins/asdf-coder"]
description = "Provision remote development environments via Terraform"

[tools.codex]
backends = ["aqua:openai/codex", "npm:@openai/codex"]
description = "Lightweight coding agent that runs in your terminal"
test = ["codex --version", "codex-cli {{version}}"]

[tools.colima]
backends = [
  "aqua:abiosoft/colima",
  "ubi:abiosoft/colima",
  "asdf:CrouchingMuppet/asdf-colima",
]
description = "Container runtimes on macOS (and Linux) with minimal setup"
test = ["colima --version", "colima version v{{version}}"]

[tools.committed]
backends = ["aqua:crate-ci/committed"]
description = "Nitpicking commit history since beabf39"

[tools.conan]
backends = ["pipx:conan", "asdf:mise-plugins/mise-pyapp"]
description = "Decentralized, open-source (MIT), C/C++ package manager"
test = ["conan --version", "Conan version {{version}}"]

[tools.concourse]
backends = [
  "aqua:concourse/concourse/concourse",
  "asdf:mattysweeps/asdf-concourse",
]
description = "Concourse is a container-based automation system written in Go"

[tools.conduit]
backends = ["github:ConduitIO/conduit", "asdf:gmcabrita/asdf-conduit"]
description = "Conduit streams data between data stores. Kafka Connect replacement. No JVM required"
test = ["conduit --version", "v{{version}}"]

[tools.conform]
backends = ["aqua:siderolabs/conform", "asdf:skyzyx/asdf-conform"]
description = "Policy enforcement for your pipelines"
os = ["linux", "macos"]
test = ["conform version", "conform version v{{version}}"]

[tools.conftest]
backends = ["aqua:open-policy-agent/conftest", "asdf:looztra/asdf-conftest"]
description = "Write tests against structured configuration data using the Open Policy Agent Rego query language"

[tools.consul]
backends = ["aqua:hashicorp/consul", "asdf:mise-plugins/mise-hashicorp"]
description = "Consul is a distributed, highly available, and data center aware solution to connect and configure applications across dynamic, distributed infrastructure"

[tools.container]
backends = ["aqua:apple/container", "ubi:apple/container"]
description = "A tool for creating and running Linux containers using lightweight virtual machines on a Mac."
os = ["macos"]
test = ["container --version", "container CLI version {{version}}"]

[tools.container-structure-test]
backends = [
  "aqua:GoogleContainerTools/container-structure-test",
  "asdf:FeryET/asdf-container-structure-test",
]
description = "validate the structure of your container images"

[tools.container-use]
backends = ["aqua:dagger/container-use", "ubi:dagger/container-use"]
description = "Development environments for coding agents. Enable multiple agents to work safely and independently with your preferred stack."
test = ["container-use --version", "container-use version {{version}}"]

[tools.cookiecutter]
backends = ["pipx:cookiecutter", "asdf:shawon-crosen/asdf-cookiecutter"]
description = "Create projects swiftly from cookiecutters (project templates) with this command-line utility. Ideal for generating Python package projects and more"

[tools.copier]
backends = ["pipx:copier", "asdf:looztra/asdf-copier"]
description = "A library and CLI app for rendering project templates"
test = ["copier --version", "copier {{version}}"]

[tools.cpz]
backends = [
  "aqua:SUPERCILEX/fuc/cpz",
  "ubi:SUPERCILEX/fuc[matching=cpz,rename_exe=cpz]",
]
description = "A zippy alternative to cp, a tool to copy files and directories"
test = ["cpz --version", "cpz {{version}}"]

[tools.copper]
backends = [
  "aqua:cloud66-oss/copper",
  "ubi:cloud66-oss/copper",
  "asdf:vladlosev/asdf-copper",
]
description = "A configuration file validator for Kubernetes"
os = ["linux", "macos"]
test = ["copper version", ""]

[tools.coredns]
backends = ["github:coredns/coredns", "asdf:s3than/asdf-coredns"]
description = "CoreDNS: DNS and Service Discovery"
test = ["coredns --version", "CoreDNS-{{version}}"]

[tools.coreutils]
backends = ["aqua:uutils/coreutils", "ubi:uutils/coreutils"]
description = "Cross-platform Rust rewrite of the GNU coreutils"
test = ["coreutils", "coreutils {{version}}"]

[tools.cosign]
backends = ["aqua:sigstore/cosign", "asdf:https://gitlab.com/wt0f/asdf-cosign"]
description = "Code signing and transparency for containers and binaries"
test = ["cosign version", "v{{version}}"]

[tools.coursier]
backends = [
  "github:coursier/coursier[exe=cs]",
  "asdf:jiahuili430/asdf-coursier",
]
description = "Pure Scala Artifact Fetching"

[tools.cowsay]
backends = ["npm:cowsay"]
description = "cowsay is a configurable talking cow, originally written in Perl by Tony Monroe"

[tools.crane]
backends = [
  "aqua:google/go-containerregistry",
  "ubi:google/go-containerregistry[exe=crane]",
  "asdf:dmpe/asdf-crane",
]
description = "Go library and CLIs for working with container registries"
test = ["crane version", "{{version}}"]

[tools.crc]
backends = ["asdf:mise-plugins/mise-crc"]
description = "CRC is a tool to help you run containers. It manages local VMs to run a OpenShift 4.x cluster, Microshift or Podman optimized for testing and development purposes"

[tools.credhub]
backends = [
  "aqua:cloudfoundry/credhub-cli",
  "asdf:mise-plugins/tanzu-plug-in-for-asdf",
]
description = "CredHub CLI provides a command line interface to interact with CredHub servers"
test = ["credhub --version", "CLI Version: {{version}}"]

[tools.crictl]
backends = [
  "aqua:kubernetes-sigs/cri-tools/crictl",
  "asdf:FairwindsOps/asdf-crictl",
]
description = "crictl is a command-line interface for CRI-compatible container runtimes. You can use it to inspect and debug container runtimes and applications on a Kubernetes node"

[tools.croc]
backends = ["aqua:schollz/croc", "ubi:schollz/croc"]
description = "Easily and securely send things from one computer to another 🐊 📦"
test = ["croc --version", "croc version v{{version}}"]

[tools.crossplane]
aliases = ["crossplane-cli"]
backends = ["aqua:crossplane/crossplane", "asdf:joke/asdf-crossplane-cli"]
description = "The Crossplane CLI extends kubectl with functionality to build, push, and install Crossplane packages"

[tools.crush]
backends = ["aqua:charmbracelet/crush"]
description = "The glamourous AI coding agent for your favourite terminal"
test = ["crush --version", "v{{version}}"]

[tools.crystal]
backends = ["asdf:mise-plugins/mise-crystal", "vfox:mise-plugins/vfox-crystal"]
description = "Crystal: A language for humans and computers"

[tools.cspell]
backends = ["npm:cspell"]
description = "A Spell Checker for Code!"
test = ["cspell --version", "{{version}}"]

[tools.ctlptl]
backends = ["aqua:tilt-dev/ctlptl", "asdf:ezcater/asdf-ctlptl"]
description = "Making local Kubernetes clusters fun and easy to set up"

[tools.ctop]
backends = ["aqua:bcicen/ctop", "ubi:bcicen/ctop", "asdf:NeoHsu/asdf-ctop"]
description = "Top-like interface for container metrics"
test = ["ctop -v", "ctop version {{version}}"]

[tools.cue]
backends = ["aqua:cue-lang/cue", "asdf:asdf-community/asdf-cue"]
description = "The home of the CUE language! Validate and define text-based and dynamic configuration"

[tools.curlie]
backends = ["aqua:rs/curlie"]
description = "The power of curl, the ease of use of httpie"
test = ["curlie version", "curlie {{version}}"]

[tools.cyclonedx]
backends = ["aqua:CycloneDX/cyclonedx-cli", "asdf:xeedio/asdf-cyclonedx"]
description = "CycloneDX CLI tool for SBOM analysis, merging, diffs and format conversions"
# TODO: re-enable test when aqua-registry is updated to use gnu instead of musl
# test = ["cyclonedx --version", "{{version}}"]

[tools.dagger]
backends = ["aqua:dagger/dagger", "asdf:virtualstaticvoid/asdf-dagger"]
description = "A portable devkit for CI/CD pipelines"

[tools.dagu]
backends = ["aqua:dagu-org/dagu", "ubi:dagu-org/dagu"]
description = "Yet another cron alternative with a Web UI, but with much more capabilities. It aims to solve greater problems"
test = ["dagu version 2>&1", "{{version}}"]

[tools.danger-js]
backends = ["asdf:mise-plugins/mise-danger-js"]
description = "Danger runs during your CI process, and gives teams the chance to automate common code review chores"

[tools.danger-swift]
backends = ["spm:danger/swift"]
description = "Stop saying 'you forgot to …' in code review"

[tools.dapr]
backends = ["aqua:dapr/cli", "asdf:asdf-community/asdf-dapr-cli"]
description = "Command-line tools for Dapr"
test = ["dapr --version", "CLI version: {{version}}"]

[tools.dart]
backends = ["asdf:mise-plugins/mise-dart", "vfox:mise-plugins/vfox-dart"]
description = "An approachable, portable, and productive language for high-quality apps on any platform"

[tools.dasel]
backends = ["aqua:TomWright/dasel", "asdf:asdf-community/asdf-dasel"]
description = "Select, put and delete data from JSON, TOML, YAML, XML and CSV files with a single tool. Supports conversion between formats and can be used as a Go package"

[tools.databricks-cli]
backends = ["github:databricks/cli[exe=databricks]"]
description = "Databricks CLI"
test = ["databricks --version", "Databricks CLI v{{version}}"]

[tools.datree]
backends = ["aqua:datreeio/datree", "asdf:lukeab/asdf-datree"]
description = "Prevent Kubernetes misconfigurations from reaching production (again  )! From code to cloud, Datree provides an E2E policy enforcement solution to run automatic checks for rule violations. See our docs: https://hub.datree.io"

[tools.daytona]
backends = ["asdf:mise-plugins/mise-daytona"]
description = "Daytona is a Secure and Elastic Infrastructure for Running AI-Generated Code"

[tools.dbmate]
backends = ["aqua:amacneil/dbmate", "asdf:juusujanar/asdf-dbmate"]
description = "A lightweight, framework-agnostic database migration tool"

[tools.deck]
backends = ["aqua:Kong/deck", "asdf:nutellinoit/asdf-deck"]
description = "decK: Configuration management and drift detection for Kong"

[tools.delta]
backends = [
  "aqua:dandavison/delta",
  "ubi:dandavison/delta",
  "asdf:andweeb/asdf-delta",
  "cargo:git-delta",
]
description = "A syntax-highlighting pager for git, diff, and grep output"
test = ["delta --version", "delta {{version}}"]

[tools.deno]
backends = ["core:deno"]
description = "A modern runtime for JavaScript and TypeScript (Builtin plugin)"

[tools.depot]
backends = ["github:depot/cli[exe=depot]", "asdf:depot/asdf-depot"]
description = "Depot CLI, build your Docker images in the cloud"
test = ["depot --version", "depot version {{version}}"]

[tools.desk]
backends = ["aqua:jamesob/desk", "asdf:endorama/asdf-desk"]
description = "A lightweight workspace manager for the shell"
os = ["linux", "macos"]
test = ["desk version", "desk {{version}}"]

[tools.devcontainer-cli]
backends = ["npm:@devcontainers/cli"]
description = "CLI for creating and configuring dev containers from devcontainer.json"
test = ["devcontainer --version", "{{version}}"]

[tools.devspace]
backends = ["aqua:devspace-sh/devspace", "asdf:NeoHsu/asdf-devspace"]
description = "DevSpace - The Fastest Developer Tool for Kubernetes  Automate your deployment workflow with DevSpace and develop software directly inside Kubernetes"

[tools.dhall]
backends = ["aqua:dhall-lang/dhall-haskell", "asdf:mise-plugins/mise-dhall"]
description = "Maintainable configuration files (haskell)"
test = ["dhall --version", "{{version}}"]

[tools.diffoci]
backends = ["aqua:reproducible-containers/diffoci"]
description = "diff for Docker and OCI container images"
test = ["diffoci --version", "diffoci version v{{version}}"]

[tools.difftastic]
backends = [
  "aqua:Wilfred/difftastic",
  "ubi:Wilfred/difftastic[exe=difft]",
  "asdf:volf52/asdf-difftastic",
  "cargo:difftastic",
]
description = "a structural diff that understands syntax"
test = ["difft --version", "Difftastic {{version}}"]

[tools.digdag]
backends = ["asdf:mise-plugins/mise-digdag"]
description = "Simple, Open Source, Multi-Cloud Workflow Engine"

[tools.direnv]
backends = ["aqua:direnv/direnv", "asdf:asdf-community/asdf-direnv"]
description = "unclutter your .profile"

[tools.dive]
backends = [
  "aqua:wagoodman/dive",
  "ubi:wagoodman/dive",
  "asdf:looztra/asdf-dive",
]
description = "A tool for exploring each layer in a docker image"
test = ["dive --version", "dive {{version}}"]

[tools.djinni]
backends = [
  "ubi:cross-language-cpp/djinni-generator[exe=djinni]",
  "asdf:cross-language-cpp/asdf-djinni",
]
description = "Command-line tool that generates gluecode from a djinni-IDL file"
test = ["djinni --version", "djinni generator version {{version}}"]

[tools.dmd]
backends = ["asdf:mise-plugins/mise-dmd"]
description = "D programming language (DMD compiler)"

[tools.docker-cli]
backends = ["aqua:docker/cli"]
description = "Docker CE CLI"
test = ["docker --version | awk '{print $3}' | tr -d ','", "{{version}}"]

[tools.docker-compose]
backends = ["aqua:docker/compose"]
description = "Define and run multi-container applications with Docker"
test = ["docker-cli-plugin-docker-compose --version", "Docker Compose version"]

[tools.docker-slim]
backends = [
  "aqua:mintoolkit/mint",
  "ubi:mintoolkit/mint[extract_all=true]",
  "asdf:xataz/asdf-docker-slim",
]
description = "minT(oolkit): Mint awesome, secure and production ready containers just the way you need them! Don't change anything in your container image and minify it by up to 30x (and for compiled languages even more) making it secure too! (free and open source)"
os = ["linux", "macos"]
test = ["slim --version", ""] # prints out weird version of mint or something

[tools.dockle]
backends = ["aqua:goodwithtech/dockle", "asdf:mathew-fleisch/asdf-dockle"]
description = "Container Image Linter for Security, Helping build the Best-Practice Docker Image, Easy to start"

[tools.doctl]
backends = [
  "aqua:digitalocean/doctl",
  "ubi:digitalocean/doctl",
  "asdf:maristgeek/asdf-doctl",
]
description = "The official command line interface for the DigitalOcean API"
test = ["doctl version", "doctl version {{version}}"]

[tools.doctoolchain]
backends = ["asdf:mise-plugins/mise-doctoolchain"]
description = "a AsciiDoc Toolchain for technical Software Documentation, focused on Software Architecture Documentation"

[tools.docuum]
backends = [
  "aqua:stepchowfun/docuum",
  "ubi:stepchowfun/docuum",
  "cargo:docuum",
  "asdf:bradym/asdf-docuum",
]
description = "Docuum performs least recently used (LRU) eviction of Docker images"
test = ["docuum --version", "Docuum {{version}}"]

[tools.doggo]
backends = ["aqua:mr-karan/doggo", "ubi:mr-karan/doggo"]
description = ":dog: Command-line DNS Client for Humans. Written in Golang"
test = ["doggo --version | awk '{print $1}'", "v{{version}}"]

[tools.dome]
backends = ["asdf:mise-plugins/mise-dome"]
description = "DOME is a framework for making 2D games using the Wren programming language which can be played across platforms"

[tools.doppler]
backends = [
  "github:DopplerHQ/cli[exe=doppler]",
  "asdf:takutakahashi/asdf-doppler",
]
description = "The official CLI for interacting with your Doppler secrets and configuration"
test = ["doppler --version", "v{{version}}"]

[tools.dotenv-linter]
backends = [
  "aqua:dotenv-linter/dotenv-linter",
  "ubi:dotenv-linter/dotenv-linter",
  "asdf:wesleimp/asdf-dotenv-linter",
  "cargo:dotenv-linter",
]
description = "Lightning-fast linter for .env files. Written in Rust"
test = ["dotenv-linter --version", "dotenv-linter {{version}}"]

[tools.dotenvx]
backends = ["aqua:dotenvx/dotenvx", "ubi:dotenvx/dotenvx"]
description = "a secure dotenv–from the creator of `dotenv`"
test = ["dotenvx --version", "{{version}}"]

[tools.dotnet]
backends = ["asdf:mise-plugins/mise-dotnet", "vfox:mise-plugins/vfox-dotnet"]
description = ".Net"

[tools.dotnet-core]
backends = ["asdf:mise-plugins/mise-dotnet-core"]
description = ".Net Core"

[tools.dotslash]
backends = ["github:facebook/dotslash"]
description = "Simplified executable deployment"
test = ["dotslash --version", "DotSlash"]

[tools.dotty]
backends = ["asdf:mise-plugins/mise-dotty"]
description = "The Scala 3 compiler, also known as Dotty"

[tools.dprint]
backends = ["aqua:dprint/dprint", "asdf:asdf-community/asdf-dprint"]
description = "Pluggable and configurable code formatting platform written in Rust"

[tools.draft]
backends = ["aqua:Azure/draft", "asdf:kristoflemmens/asdf-draft"]
description = "A day 0 tool for getting your app on k8s fast"

[tools.driftctl]
backends = ["aqua:snyk/driftctl", "asdf:nlamirault/asdf-driftctl"]
description = "Detect, track and alert on infrastructure drift"

[tools.drone]
backends = [
  "aqua:harness/drone-cli",
  "ubi:harness/drone-cli[exe=drone]",
  "asdf:virtualstaticvoid/asdf-drone",
]
description = "Command Line Tools for Drone CI"
test = ["drone --version", "drone version {{version}}"]

[tools.dt]
backends = ["aqua:so-dang-cool/dt", "asdf:so-dang-cool/asdf-dt"]
description = "dt - duct tape for your unix pipes"

[tools.dtm]
backends = [
  "github:devstream-io/devstream[exe=dtm]",
  "asdf:zhenyuanlau/asdf-dtm",
]
description = "DevStream: the open-source DevOps toolchain manager (DTM)"

[tools.dua]
backends = ["aqua:Byron/dua-cli", "ubi:Byron/dua-cli[exe=dua]", "cargo:dua-cli"]
description = "View disk space usage and delete unwanted data, fast"
test = ["dua --version", "dua {{version}}"]

[tools.duckdb]
backends = ["aqua:duckdb/duckdb", "ubi:duckdb/duckdb"]
description = "DuckDB is an analytical in-process SQL database management system"
test = ["duckdb --version", "{{version}}"]

[tools.duf]
backends = ["aqua:muesli/duf", "asdf:NeoHsu/asdf-duf"]
description = "Disk Usage/Free Utility - a better 'df' alternative"

[tools.dust]
backends = [
  "aqua:bootandy/dust",
  "ubi:bootandy/dust",
  "asdf:looztra/asdf-dust",
  "cargo:du-dust",
]
description = "A more intuitive version of du in rust"
test = ["dust --version", "Dust {{version}}"]

[tools.dvc]
backends = ["asdf:mise-plugins/mise-dvc"]
description = "Data Versioning and ML Experiments"

[tools.dyff]
backends = ["aqua:homeport/dyff", "asdf:https://gitlab.com/wt0f/asdf-dyff"]
description = "A diff tool for YAML files, and sometimes JSON"

[tools.dynatrace-monaco]
backends = [
  "github:Dynatrace/dynatrace-configuration-as-code[exe=monaco]",
  "asdf:nsaputro/asdf-monaco",
]
description = "Monaco—This is the native Dynatrace Configuration as Code tool. Monaco is also the recommended tool for migrating from Dynatrace Managed to Dynatrace SaaS"

[tools.e1s]
backends = ["aqua:keidarcy/e1s", "asdf:tbobm/asdf-e1s"]
description = "E1S - Easily Manage AWS ECS Resources in Terminal(~k9s for ECS)"

[tools.earthly]
backends = ["aqua:earthly/earthly", "asdf:YR-ZR0/asdf-earthly"]
description = "Repeatable builds"

[tools.ecspresso]
backends = ["aqua:kayac/ecspresso", "asdf:kayac/asdf-ecspresso"]
description = "ecspresso is a deployment tool for Amazon ECS"

[tools.edit]
backends = ["aqua:microsoft/edit"]
description = "We all edit"
# test = ["edit --version", "edit version {{version}}"] # exits 1 on CI

[tools.editorconfig-checker]
backends = [
  "aqua:editorconfig-checker/editorconfig-checker",
  "ubi:editorconfig-checker/editorconfig-checker[exe=ec]",
  "asdf:gabitchov/asdf-editorconfig-checker",
]
description = "A tool to verify that your files are in harmony with your .editorconfig"
test = ["ec --version", "v{{version}}"]

[tools.ejson]
backends = ["aqua:Shopify/ejson", "asdf:cipherstash/asdf-ejson"]
description = "EJSON is a small library to manage encrypted secrets using asymmetric encryption"

[tools.eksctl]
backends = ["aqua:eksctl-io/eksctl", "asdf:elementalvoid/asdf-eksctl"]
description = "The official CLI for Amazon EKS"

[tools.elasticsearch]
backends = ["asdf:mise-plugins/mise-elasticsearch"]
description = "Elasticsearch is an open source, distributed search and analytics engine built for speed, scale, and AI applications"

[tools.elixir]
backends = ["core:elixir"]
depends = ["erlang"]
description = "Elixir is a dynamic, functional language for building scalable and maintainable applications"

[tools.elixir-ls]
backends = ["asdf:mise-plugins/mise-elixir-ls"]
description = "A frontend-independent IDE 'smartness' server for Elixir. Implements the 'Language Server Protocol' standard and provides debugger support via the 'Debug Adapter Protocol'"

[tools.elm]
backends = ["github:elm/compiler[bin=elm]", "asdf:asdf-community/asdf-elm"]
description = "Compiler for Elm, a functional language for reliable webapps"
test = ["elm --version", "{{version}}"]

[tools.emsdk]
backends = ["asdf:mise-plugins/mise-emsdk"]
description = "Emscripten is a complete compiler toolchain to WebAssembly, using LLVM, with a special focus on speed, size, and the Web platform"

[tools.envcli]
backends = [
  "aqua:EnvCLI/EnvCLI",
  "ubi:EnvCLI/EnvCLI[exe=envcli]",
  "asdf:zekker6/asdf-envcli",
]
description = "Don't install Node, Go, ... locally - use containers you define within your project. If you have a new machine / other contributors you just have to install docker and envcli to get started"
test = ["envcli --version", "EnvCLI version {{version}}"]

[tools.envsubst]
backends = ["aqua:a8m/envsubst", "asdf:dex4er/asdf-envsubst"]
description = "Environment variables substitution for Go"

[tools.ephemeral-postgres]
backends = ["asdf:mise-plugins/mise-ephemeral-postgres"]
description = "Quickly spin up a temporary PostgreSQL test databases"

[tools.erlang]
backends = ["core:erlang"]
description = "erlang"

[tools.esc]
backends = ["aqua:pulumi/esc", "ubi:pulumi/esc", "asdf:fxsalazar/asdf-esc"]
description = "Pulumi ESC is a centralized, secure service for environments, secrets, and configuration management, optimized for multi-cloud infrastructures and applications"
test = ["esc version", "v{{version}}"]

[tools.esy]
backends = ["asdf:mise-plugins/mise-esy"]
description = "Easy package management for native Reason, OCaml and more"

[tools.etcd]
backends = [
  "aqua:etcd-io/etcd",
  "asdf:particledecay/asdf-etcd",
  "vfox:mise-plugins/vfox-etcd",
]
description = "Distributed reliable key-value store for the most critical data of a distributed system"
test = ["etcd --version", "etcd Version: {{version}}"]

[tools.evans]
backends = ["aqua:ktr0731/evans", "asdf:goki90210/asdf-evans"]
description = "Evans: more expressive universal gRPC client"

[tools.eza]
backends = [
  { full = "aqua:eza-community/eza", platforms = [
    "linux",
  ] },
  { full = "ubi:eza-community/eza", platforms = [
    "linux",
  ] },
  "asdf:mise-plugins/mise-eza",
  "cargo:eza",
]
description = "A modern, maintained replacement for ls"
test = ["eza --version", "v{{version}}"]

[tools.fastfetch]
backends = ["aqua:fastfetch-cli/fastfetch"]
description = "An actively maintained, feature-rich and performance oriented, neofetch like system information tool"
test = ["fastfetch --version | awk '{print $1, $2}'", "fastfetch {{version}}"]

[tools.fd]
backends = [
  "aqua:sharkdp/fd",
  "ubi:sharkdp/fd",
  "asdf:https://gitlab.com/wt0f/asdf-fd",
  "cargo:fd-find",
]
description = "A simple, fast and user-friendly alternative to 'find'"
test = ["fd --version", "fd {{version}}"]

[tools.ffmpeg]
backends = ["asdf:mise-plugins/mise-ffmpeg"]
description = "A complete, cross-platform solution to record, convert and stream audio and video"

[tools.figma-export]
backends = [
  "github:RedMadRobot/figma-export[bin_path=Release]",
  "asdf:younke/asdf-figma-export",
]
description = "Command line utility to export colors, typography, icons and images from Figma to Xcode / Android Studio project"
os = ["macos"]
test = ["figma-export --version", "{{version}}"]

[tools.fillin]
backends = ["aqua:itchyny/fillin", "asdf:ouest/asdf-fillin"]
description = "fill-in your command and execute"

[tools.firebase]
backends = ["aqua:firebase/firebase-tools", "asdf:jthegedus/asdf-firebase"]
description = "The Firebase Command Line Tools"
test = ["firebase --version", "{{version}}"]

[tools.fission]
backends = ["aqua:fission/fission", "asdf:virtualstaticvoid/asdf-fission"]
description = "Fast and Simple Serverless Functions for Kubernetes"

[tools.flamingo]
backends = ["github:flux-subsystem-argo/flamingo", "asdf:log2/asdf-flamingo"]
description = "Flux Subsystem for Argo"
test = ["flamingo -v", "flamingo version {{version}}"]

[tools.flarectl]
backends = [
  "github:cloudflare/cloudflare-go[exe=flarectl]",
  "asdf:mise-plugins/asdf-flarectl",
]
description = "A CLI application for interacting with a Cloudflare account. Powered by cloudflare-go"
# test = ["flarectl --version", "flarectl version {{version}}"] # flarectl removed since v4

[tools.flatc]
backends = [
  "github:google/flatbuffers[exe=flatc]",
  "asdf:TheOpenDictionary/asdf-flatc",
]
description = "The main compiler for FlatBuffers is called flatc and is used to convert schema definitions into generated code files for a variety of languages"
test = ["flatc --version", "flatc version {{version}}"]

[tools.flutter]
backends = ["asdf:mise-plugins/mise-flutter", "vfox:mise-plugins/vfox-flutter"]
description = "Flutter is an open source framework for building beautiful, natively compiled, multi-platform applications from a single codebase"

[tools.fluttergen]
backends = [
  "github:FlutterGen/flutter_gen[exe=fluttergen]",
  "asdf:FlutterGen/asdf-fluttergen",
]
description = "The Flutter code generator for your assets, fonts, colors, … — Get rid of all String-based APIs"
os = ["linux", "macos"]
test = ["fluttergen --version", "v{{version}}"]

[tools.flux2]
backends = ["aqua:fluxcd/flux2", "asdf:tablexi/asdf-flux2"]
description = "Open and extensible continuous delivery solution for Kubernetes. Powered by GitOps Toolkit"
test = ["flux --version", "flux version {{version}}"]

[tools.fly]
backends = [
  "aqua:concourse/concourse/fly",
  "asdf:mise-plugins/tanzu-plug-in-for-asdf",
]
description = "fly cli for concourse ci"

[tools.flyctl]
backends = [
  "aqua:superfly/flyctl",
  "ubi:superfly/flyctl",
  "asdf:chessmango/asdf-flyctl",
]
description = "Command line tools for fly.io services"

[tools.flyway]
backends = ["asdf:mise-plugins/mise-flyway"]
description = "Flyway by Redgate • Database Migrations Made Easy"

[tools.foundry]
backends = [
  "aqua:foundry-rs/foundry",
  "ubi:foundry-rs/foundry[extract_all=true]",
]
description = "Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust"
test = ["forge -V", "{{version}}"]

[tools.func-e]
backends = ["github:tetratelabs/func-e", "asdf:mise-plugins/mise-func-e"]
description = "func-e (pronounced funky) makes running Envoy® easy"
test = ["func-e --version", "func-e version {{version}}"]

[tools.furyctl]
backends = ["github:sighupio/furyctl", "asdf:sighupio/asdf-furyctl"]
description = "furyctl is the SIGHUP Distribution cluster lifecycle manager"
os = ["linux", "macos"]
test = ["furyctl version", "{{version}}"]

[tools.fx]
backends = ["aqua:antonmedv/fx", "asdf:https://gitlab.com/wt0f/asdf-fx"]
description = "Command-line tool and terminal JSON viewer"

[tools.fzf]
backends = ["aqua:junegunn/fzf", "ubi:junegunn/fzf", "asdf:kompiro/asdf-fzf"]
description = ":cherry_blossom: A command-line fuzzy finder"
test = ["fzf --version", "{{version}}"]

[tools.gallery-dl]
backends = ["asdf:mise-plugins/mise-gallery-dl"]
description = "Command-line program to download image galleries and collections from several image hosting sites"

[tools.gam]
backends = ["github:GAM-team/GAM[exe=gam]", "asdf:offbyone/asdf-gam"]
description = "command line management for Google Workspace"

[tools.gator]
backends = [
  "aqua:open-policy-agent/gatekeeper",
  "ubi:open-policy-agent/gatekeeper[exe=gator]",
  "asdf:MxNxPx/asdf-gator",
]
description = "Gatekeeper - Policy Controller for Kubernetes"
test = ["gator --version", "gator version v{{version}}"]

[tools.gauche]
backends = ["asdf:mise-plugins/mise-gauche"]
description = "Gauche is an R7RS Scheme implementation developed to be a handy script interpreter, which allows programmers and system administrators to write small to large scripts for their daily chores"

[tools.gcc-arm-none-eabi]
backends = ["asdf:mise-plugins/mise-gcc-arm-none-eabi"]
description = "Arm GNU Toolchain"

[tools.gcloud]
backends = ["asdf:mise-plugins/mise-gcloud"]
depends = ["python"]
description = "GCloud CLI (Google Cloud SDK)"

[tools.gdu]
backends = ["aqua:dundee/gdu"]
description = "Fast disk usage analyzer with console interface written in Go"

[tools.gemini-cli]
aliases = ["gemini"]
backends = ["npm:@google/gemini-cli"]
description = "Gemini CLI, a command-line AI workflow tool that connects to your tools, understands your code and accelerates your workflows"
test = ["gemini --version", "{{version}}"]

[tools.getenvoy]
backends = [
  "github:tetratelabs-attic/getenvoy",
  "asdf:mise-plugins/mise-getenvoy",
]
description = "historical CLI of getenvoy"
test = ["getenvoy --version", "getenvoy version {{version}}"]

[tools.ggshield]
backends = [
  "aqua:GitGuardian/ggshield",
  "ubi:GitGuardian/ggshield",
  "pipx:ggshield",
]
description = "Detect and validate 500+ types of hardcoded secrets with advanced checks. Use it as a pre-commit hook, GitHub Action, or CLI for proactive secret detection and security."
test = ["ggshield --version", "ggshield, version {{version}}"]

[tools.ghalint]
backends = ["aqua:suzuki-shunsuke/ghalint", "ubi:suzuki-shunsuke/ghalint"]
description = "GitHub Actions linter"
test = ["ghalint version", "{{version}}"]

[tools.ghc]
backends = ["asdf:mise-plugins/mise-ghcup"]
description = "The Glorious Glasgow Haskell Compiler."
test = [
  "ghc --version",
  "The Glorious Glasgow Haskell Compilation System, version {{version}}",
]

[tools.ghcup]
backends = [
  "aqua:haskell/ghcup-hs",
  "ubi:haskell/ghcup-hs[exe=ghcup]",
  "asdf:mise-plugins/mise-ghcup",
]
description = "GHCup is an installer for the general purpose language Haskell"
os = ["linux", "macos"]
test = ["ghcup --version", "The GHCup Haskell installer, version {{version}}"]

[tools.ghidra]
backends = ["asdf:mise-plugins/mise-ghidra"]
description = "Ghidra is a software reverse engineering (SRE) framework"

[tools.ghorg]
backends = ["aqua:gabrie30/ghorg", "asdf:gbloquel/asdf-ghorg"]
description = "Quickly clone an entire org/users repositories into one directory - Supports GitHub, GitLab, Bitbucket, and more"

[tools.ghq]
backends = ["aqua:x-motemen/ghq", "asdf:kajisha/asdf-ghq"]
description = "Remote repository management made easy"

[tools.ginkgo]
backends = [
  "go:github.com/onsi/ginkgo/v2/ginkgo",
  "asdf:mise-plugins/mise-ginkgo",
]
description = "A Modern Testing Framework for Go"
test = ["ginkgo version", "Ginkgo Version {{version}}"]

[tools.git-chglog]
backends = ["aqua:git-chglog/git-chglog", "asdf:GoodwayGroup/asdf-git-chglog"]
description = "CHANGELOG generator implemented in Go (Golang)"

[tools.git-cliff]
backends = ["aqua:orhun/git-cliff", "asdf:jylenhof/asdf-git-cliff"]
description = "A highly customizable Changelog Generator that follows Conventional Commit specifications"
test = ["git-cliff --version", "git-cliff {{version}}"]

[tools.git-lfs]
backends = ["aqua:git-lfs/git-lfs", "ubi:git-lfs/git-lfs"]
description = "Git extension for versioning large files"
test = ["git-lfs --version", "git-lfs/{{version}}"]

[tools.gitconfig]
backends = ["github:0ghny/gitconfig", "asdf:0ghny/asdf-gitconfig"]
description = "Cli to manage multiple gitconfigs with ease"
test = ["gitconfig --version", "gitconfig version {{version}}"]

[tools.github-cli]
aliases = ["gh"]
backends = [
  "aqua:cli/cli",
  "ubi:cli/cli[exe=gh]",
  "asdf:bartlomiejdanek/asdf-github-cli",
]
description = "GitHub’s official command line tool"
test = ["gh --version", "gh version {{version}}"]

[tools.github-markdown-toc]
backends = [
  "aqua:ekalinin/github-markdown-toc",
  "asdf:skyzyx/asdf-github-markdown-toc",
]
description = "Easy TOC creation for GitHub README.md"
test = ["gh-md-toc --version", "{{version}}"]

[tools.gitleaks]
backends = ["aqua:gitleaks/gitleaks", "asdf:jmcvetta/asdf-gitleaks"]
description = "Find secrets with Gitleaks"
test = ["gitleaks --version", "gitleaks version {{version}}"]

[tools.gitsign]
backends = ["aqua:sigstore/gitsign", "asdf:spencergilbert/asdf-gitsign"]
description = "Keyless Git signing using Sigstore"
os = ["linux", "macos"]
test = ["gitsign --version", "gitsign version v{{version}}"]

[tools.gitu]
backends = ["aqua:altsem/gitu", "ubi:altsem/gitu", "cargo:gitu"]
description = "A TUI Git client inspired by Magit"
test = ["gitu --version", "gitu v{{version}}"]

[tools.gitui]
backends = ["aqua:extrawurst/gitui", "asdf:looztra/asdf-gitui", "cargo:gitui"]
description = "Blazing 💥 fast terminal-ui for git written in rust"

[tools.gitversion]
backends = ["aqua:gittools/gitversion", "ubi:gittools/gitversion"]
description = "From git log to SemVer in no time"

[tools.glab]
backends = [
  { full = "ubi:gitlab-org/cli[provider=gitlab,exe=glab]", platforms = [
    "linux",
    "macos",
  ] },
  { full = 'ubi:gitlab-org/cli[provider=gitlab,exe=glab,matching_regex=^glab\.exe$]', platforms = [
    "windows",
  ] },
  "asdf:mise-plugins/mise-glab",
]
description = "gitlab cli"
test = ["glab version", "glab {{version}}"]

[tools.gleam]
backends = ["aqua:gleam-lang/gleam", "asdf:asdf-community/asdf-gleam"]
description = "A friendly language for building type-safe, scalable systems"
test = ["gleam --version", "gleam {{version}}"]

[tools.glen]
backends = ["github:lingrino/glen", "asdf:bradym/asdf-glen"]
description = "cli to export gitlab variables"
test = ["glen version", "{{version}}"]

[tools.glooctl]
backends = ["github:solo-io/gloo", "asdf:halilkaya/asdf-glooctl"]
description = "The Cloud-Native API Gateway and AI Gateway"

[tools.glow]
backends = ["aqua:charmbracelet/glow", "asdf:mise-plugins/asdf-glow"]
description = "Render markdown on the CLI, with pizzazz"

[tools.go]
backends = ["core:go"]
description = "go lang (Builtin plugin)"

[tools.go-containerregistry]
backends = [
  "aqua:google/go-containerregistry",
  "asdf:dex4er/asdf-go-containerregistry",
]
description = "Go library and CLIs for working with container registries"

[tools.go-getter]
backends = ["aqua:hashicorp/go-getter", "asdf:mise-plugins/mise-go-getter"]
description = "Package for downloading things from a string URL using a variety of protocols"
test = ["which go-getter", "go-getter"]

[tools.go-jira]
backends = ["aqua:go-jira/jira", "asdf:dguihal/asdf-go-jira"]
description = "simple jira command line client in Go"

[tools.go-jsonnet]
backends = [
  "aqua:google/go-jsonnet",
  "asdf:https://gitlab.com/craigfurman/asdf-go-jsonnet",
]
description = "This an implementation of Jsonnet in pure Go"

[tools.go-junit-report]
backends = [
  "aqua:jstemmer/go-junit-report",
  "ubi:jstemmer/go-junit-report",
  "asdf:jwillker/asdf-go-junit-report",
]
description = "Convert Go test output to JUnit XML"
test = ["go-junit-report --version", "{{version}}"]

[tools.go-sdk]
backends = ["asdf:mise-plugins/mise-go-sdk"]
description = "Install go sdk"

[tools.go-swagger]
backends = ["aqua:go-swagger/go-swagger", "asdf:jfreeland/asdf-go-swagger"]
description = "Swagger 2.0 implementation for go"
os = ["linux", "macos"]
test = ["swagger version", "version: v{{version}}"]

[tools.goconvey]
backends = [
  "go:github.com/smartystreets/goconvey",
  "asdf:mise-plugins/mise-goconvey",
]
description = "Go testing in the browser. Integrates with `go test`. Write behavioral tests in Go"

[tools.gocryptfs]
backends = ["aqua:rfjakob/gocryptfs", "ubi:rfjakob/gocryptfs"]
description = "Encrypted overlay filesystem written in Go"

[tools.gofumpt]
backends = [
  "aqua:mvdan/gofumpt",
  "ubi:mvdan/gofumpt",
  "asdf:looztra/asdf-gofumpt",
]
description = "A stricter gofmt"
test = ["gofumpt --version", "v{{version}}"]

[tools.gojq]
backends = [
  "aqua:itchyny/gojq",
  "ubi:itchyny/gojq",
  "asdf:jimmidyson/asdf-gojq",
  "go:github.com/itchyny/gojq/cmd/gojq",
]
description = "Pure Go implementation of jq"
test = ["gojq --version", "gojq {{version}}"]

[tools.gokey]
backends = ["aqua:cloudflare/gokey", "ubi:cloudflare/gokey"]
description = "A simple vaultless password manager in Go"
test = ["gokey -p master -r realm -l 8", "hJ2gXSy["]

[tools.golangci-lint]
backends = [
  "aqua:golangci/golangci-lint",
  "ubi:golangci/golangci-lint",
  "asdf:hypnoglow/asdf-golangci-lint",
]
description = "Fast linters Runner for Go"

[tools.golangci-lint-langserver]
backends = [
  "aqua:nametake/golangci-lint-langserver",
  "ubi:nametake/golangci-lint-langserver",
  "go:github.com/nametake/golangci-lint-langserver",
]
description = "golangci-lint language server"
test = ["which golangci-lint-langserver", "golangci-lint-langserver"]

[tools.golines]
backends = [
  { full = "aqua:segmentio/golines", platforms = [
    "linux",
    "macos",
  ] },
  { full = "ubi:segmentio/golines", platforms = [
    "linux",
    "macos",
  ] },
  "go:github.com/segmentio/golines",
]
description = "A golang formatter that fixes long lines"
test = ["golines --version", "golines v{{version}}"]

[tools.gomigrate]
backends = ["aqua:golang-migrate/migrate", "asdf:joschi/asdf-gomigrate"]
description = "Database migrations. CLI and Golang library"
test = ["migrate --version 2>&1", "{{version}}"]

[tools.gomplate]
backends = ["aqua:hairyhenderson/gomplate", "asdf:sneakybeaky/asdf-gomplate"]
description = "A flexible commandline tool for template rendering. Supports lots of local and remote datasources"

[tools.gopass]
backends = ["aqua:gopasspw/gopass", "asdf:trallnag/asdf-gopass"]
description = "The slightly more awesome standard unix password manager for teams"

[tools.goreleaser]
backends = [
  "aqua:goreleaser/goreleaser",
  "ubi:goreleaser/goreleaser",
  "asdf:kforsthoevel/asdf-goreleaser",
]
description = "Deliver Go binaries as fast and easily as possible"

[tools.goss]
backends = ["aqua:goss-org/goss", "asdf:raimon49/asdf-goss"]
description = "Quick and Easy server testing/validation"

[tools.gotestsum]
backends = ["aqua:gotestyourself/gotestsum", "asdf:pmalek/mise-gotestsum"]
description = "'go test' runner with output optimized for humans, JUnit XML for CI integration, and a summary of the test results"

[tools.gping]
backends = ["aqua:orf/gping", "github:orf/gping", "cargo:gping"]
description = "Ping, but with a graph"
test = ["gping --version", "gping {{version}}"]

[tools.graalvm]
backends = ["asdf:mise-plugins/mise-graalvm"]
description = "An advanced JDK with ahead-of-time Native Image compilation"

[tools.gradle]
backends = ["aqua:gradle/gradle", "vfox:mise-plugins/vfox-gradle"]
depends = ["java"]
description = "Gradle is the open source build system of choice for Java, Android, and Kotlin developers"
test = ["gradle -V", "Gradle"]

[tools.gradle-profiler]
backends = ["asdf:mise-plugins/mise-gradle-profiler"]
description = "A tool for gathering profiling and benchmarking information for Gradle builds"

[tools.grails]
backends = ["asdf:mise-plugins/mise-grails"]
description = "A powerful Groovy-based web application framework for the JVM built on top of Spring Boot"

[tools.grain]
backends = [
  "github:grain-lang/grain[version_prefix=grain-v]",
  "asdf:mise-plugins/mise-grain",
]
description = "The Grain compiler toolchain and CLI. Home of the modern web staple"
test = ["grain --version", "{{version}}"]

[tools.granted]
backends = ["aqua:common-fate/granted", "asdf:dex4er/asdf-granted"]
description = "The easiest way to access AWS"

[tools.graphite]
backends = [
  "github:withgraphite/homebrew-tap[exe=gt]",
  "npm:@withgraphite/graphite-cli",
]
description = "Code review for the age of AI"
test = ["gt --version", "{{version}}"]

[tools.grex]
backends = ["aqua:pemistahl/grex", "asdf:ouest/asdf-grex", "cargo:grex"]
description = "A command-line tool and library for generating regular expressions from user-provided test cases"
test = ["grex --version", "grex {{version}}"]

[tools.gron]
backends = ["aqua:tomnomnom/gron", "ubi:tomnomnom/gron"]
description = "Make JSON greppable"
test = ["gron --version", "gron version dev"]

[tools.groovy]
backends = ["asdf:mise-plugins/mise-groovy", "vfox:mise-plugins/vfox-groovy"]
description = "A flexible and extensible Java-like language for the JVM"

[tools.grpc-health-probe]
backends = [
  "aqua:grpc-ecosystem/grpc-health-probe",
  "asdf:zufardhiyaulhaq/asdf-grpc-health-probe",
]
description = "A command-line tool to perform health-checks for gRPC applications in Kubernetes and elsewhere"
os = ["linux", "macos"]
test = ["grpc_health_probe --version", "{{version}}"]

[tools.grpcurl]
backends = ["aqua:fullstorydev/grpcurl", "asdf:asdf-community/asdf-grpcurl"]
description = "Like cURL, but for gRPC: Command-line tool for interacting with gRPC servers"

[tools.grype]
backends = [
  "aqua:anchore/grype",
  "ubi:anchore/grype",
  "asdf:poikilotherm/asdf-grype",
]
description = "A vulnerability scanner for container images and filesystems"
test = ["grype --version", "{{version}}"]

[tools.guile]
backends = ["asdf:mise-plugins/mise-guile"]
description = "GNU Guile"

[tools.gum]
backends = ["aqua:charmbracelet/gum", "asdf:lwiechec/asdf-gum"]
description = "A tool for glamorous shell scripts"

[tools.gup]
backends = ["aqua:nao1215/gup"]
description = 'gup - Update binaries installed by "go install" with goroutines'
test = ["gup version", "gup version v{{version}}"]

[tools.gwvault]
backends = ["aqua:GoodwayGroup/gwvault", "asdf:GoodwayGroup/asdf-gwvault"]
description = "ansible-vault CLI reimplemented in go"

[tools.hadolint]
backends = [
  "aqua:hadolint/hadolint",
  "ubi:hadolint/hadolint",
  "asdf:devlincashman/asdf-hadolint",
]
description = "Dockerfile linter, validate inline bash, written in Haskell"
test = ["hadolint --version", "Haskell Dockerfile Linter {{version}}"]

[tools.hamler]
backends = ["asdf:mise-plugins/mise-hamler"]
description = "Hamler A Haskell-style functional programming language running on Erlang VM"

[tools.harper-cli]
backends = ["aqua:Automattic/harper/harper-cli"]
description = "harper-cli is a small, experimental frontend for Harper. It can be used in any situation where you might need to check a large number of files automatically (like in continuous integration)"
# harper-cli intentionally prints different version. See https://github.com/Automattic/harper/issues/557#issuecomment-2635037944
test = ["harper-cli --version", "harper-cli"]

[tools.harper-ls]
backends = ["aqua:Automattic/harper/harper-ls"]
description = "harper-ls is the Language Server Protocol frontend for Harper"
test = ["harper-ls --version", "harper-ls {{version}}"]

[tools.has]
backends = ["aqua:kdabir/has", "asdf:sylvainmetayer/asdf-has"]
description = "checks presence of various command line tools and their versions on the path"
os = ["linux", "macos"]
test = ["has --version", "v{{version}}"]

[tools.hasura-cli]
backends = ["aqua:hasura/graphql-engine", "asdf:gurukulkarni/asdf-hasura"]
description = "Hasura GraphQL Engine CLI"

[tools.hatch]
backends = ["pipx:hatch"]
description = "Modern, extensible Python project management."
test = ["hatch --version", "{{version}}"]

[tools.haxe]
backends = ["github:HaxeFoundation/haxe", "asdf:mise-plugins/mise-haxe"]
description = "Haxe - The Cross-Platform Toolkit"
test = ["haxe --version", "{{version}}"]

[tools.hcl2json]
backends = ["aqua:tmccombs/hcl2json", "asdf:dex4er/asdf-hcl2json"]
description = "Convert hcl2 to json"

[tools.hcloud]
backends = ["aqua:hetznercloud/cli", "asdf:chessmango/asdf-hcloud"]
description = "A command-line interface for Hetzner Cloud"

[tools.helix]
backends = [
  "aqua:helix-editor/helix",
  "ubi:helix-editor/helix[extract_all=true]",
]
description = "A post-modern modal text editor"
test = ["hx --version", "helix {{version}}"]

[tools.helm]
backends = ["aqua:helm/helm", "asdf:Antiarchitect/asdf-helm"]
description = "The Kubernetes Package Manager"

[tools.helm-cr]
backends = ["aqua:helm/chart-releaser", "asdf:Antiarchitect/asdf-helm-cr"]
description = "Hosting Helm Charts via GitHub Pages and Releases"

[tools.helm-ct]
backends = ["aqua:helm/chart-testing", "asdf:tablexi/asdf-helm-ct"]
description = "CLI tool for linting and testing Helm charts"

[tools.helm-diff]
backends = [
  "ubi:databus23/helm-diff[exe=diff,rename_exe=helm-diff]",
  "asdf:mise-plugins/mise-helm-diff",
]
description = "A helm plugin that shows a diff explaining what a helm upgrade would change"
test = ["helm-diff version", "{{version}}"]

[tools.helm-docs]
backends = ["aqua:norwoodj/helm-docs", "asdf:sudermanjr/asdf-helm-docs"]
description = "A tool for automatically generating markdown documentation for helm charts"

[tools.helm-ls]
backends = ["aqua:mrjosh/helm-ls", "ubi:mrjosh/helm-ls[rename_exe=helm_ls]"]
description = "Helm-ls is a helm language server protocol LSP implementation"
test = [
  "helm_ls version",
  "Helm-ls version: master",
] # helm_ls version returns always "master" - https://github.com/mrjosh/helm-ls/issues/179

[tools.helmfile]
backends = [
  "aqua:helmfile/helmfile",
  "ubi:helmfile/helmfile",
  "asdf:feniix/asdf-helmfile",
]
description = "Declaratively deploy your Kubernetes manifests, Kustomize configs, and Charts as Helm releases. Generate all-in-one manifests for use with ArgoCD"
test = ["helmfile --version", "helmfile version {{version}}"]

[tools.helmsman]
backends = ["github:Praqma/helmsman", "asdf:luisdavim/asdf-helmsman"]
description = "Helmsman is a Helm Charts (k8s applications) as Code tool which allows you to automate the deployment/management of your Helm charts from version controlled code"

[tools.helmwave]
backends = ["aqua:helmwave/helmwave", "ubi:helmwave/helmwave"]
description = "New  wave for @helm"
test = ["helmwave version", "{{version}}"]

[tools.heroku]
aliases = ["heroku-cli"]
backends = ["asdf:mise-plugins/mise-heroku-cli"]
description = "The Heroku Command Line Interface (CLI) is an essential part of using Heroku. With it, you can create and manage Heroku apps directly from the terminal"

[tools.hexyl]
backends = ["aqua:sharkdp/hexyl", "ubi:sharkdp/hexyl", "cargo:hexyl"]
description = "A command-line hex viewer"
test = ["hexyl --version", "hexyl {{version}}"]

[tools.hey]
backends = ["asdf:mise-plugins/mise-hey"]
description = "HTTP load generator, ApacheBench (ab) replacement"

[tools.hishtory]
backends = ["github:ddworken/hishtory", "asdf:asdf-community/asdf-hishtory"]
description = "Your shell history: synced, queryable, and in context"

[tools.hivemind]
backends = ["github:DarthSim/hivemind", "go:github.com/DarthSim/hivemind"]
description = "Process manager for Procfile-based applications"
test = ["hivemind --version", "Hivemind version {{version}}"]

[tools.hk]
backends = ["aqua:jdx/hk", "ubi:jdx/hk"]
description = "git hook and pre-commit lint manager"
test = ["hk --version", "hk {{version}}"]

[tools.hledger]
backends = ["github:simonmichael/hledger", "asdf:airtonix/asdf-hledger"]
description = "Robust, fast, intuitive plain text accounting tool with CLI, TUI and web interfaces"

[tools.hledger-flow]
backends = ["github:apauley/hledger-flow", "asdf:airtonix/asdf-hledger-flow"]
description = "An hledger/ledger-cli workflow focusing on automated statement import and classification"

[tools.hls]
backends = ["asdf:mise-plugins/mise-ghcup"]
description = "Official Haskell IDE support via the language server protocol (LSP)"

[tools.hostctl]
backends = ["aqua:guumaster/hostctl", "asdf:svenluijten/asdf-hostctl"]
description = "Your dev tool to manage /etc/hosts like a pro"

[tools.htmlq]
backends = ["aqua:mgdm/htmlq", "ubi:mgdm/htmlq", "cargo:htmlq"]
description = "Like jq, but for HTML"
test = ["htmlq --version", "htmlq {{version}}"]

[tools.httpie-go]
backends = ["aqua:nojima/httpie-go", "asdf:abatilo/asdf-httpie-go"]
description = "httpie-like HTTP client written in Go"
os = ["linux", "macos"]
test = ["ht --version 2>&1", "httpie-go {{version}}"]

[tools.hub]
backends = ["aqua:mislav/hub", "asdf:mise-plugins/asdf-hub"]
description = "A command-line tool that makes git easier to use with GitHub"

[tools.hugo]
backends = [
  "aqua:gohugoio/hugo",
  "ubi:gohugoio/hugo",
  "asdf:NeoHsu/asdf-hugo",
  "asdf:nklmilojevic/asdf-hugo",
]
description = "The world’s fastest framework for building websites"

[tools.hugo-extended]
backends = ["aqua:gohugoio/hugo/hugo-extended"]
description = "The world’s fastest framework for building websites"

[tools.hurl]
backends = [
  "aqua:Orange-OpenSource/hurl",
  "asdf:raimon49/asdf-hurl",
  "cargo:hurl",
]
description = "Hurl, run and test HTTP requests with plain text"

[tools.hwatch]
backends = [
  "aqua:blacknon/hwatch",
  "ubi:blacknon/hwatch",
  "asdf:chessmango/asdf-hwatch",
]
description = "A modern alternative to the watch command, records the differences in execution results and can check this differences at after"
test = ["hwatch --version", "hwatch {{version}}"]

[tools.hygen]
backends = ["github:jondot/hygen", "asdf:brentjanderson/asdf-hygen"]
description = "The simple, fast, and scalable code generator that lives in your project"

[tools.hyperfine]
backends = [
  "aqua:sharkdp/hyperfine",
  "ubi:sharkdp/hyperfine",
  "asdf:volf52/asdf-hyperfine",
  "cargo:hyperfine",
]
description = "A command-line benchmarking tool"

[tools.iam-policy-json-to-terraform]
backends = [
  "aqua:flosell/iam-policy-json-to-terraform",
  "asdf:carlduevel/asdf-iam-policy-json-to-terraform",
]
description = "Small tool to convert an IAM Policy in JSON format into a Terraform aws_iam_policy_document"
test = ["iam-policy-json-to-terraform --version", "{{version}}"]

[tools.iamlive]
backends = ["aqua:iann0036/iamlive", "asdf:chessmango/asdf-iamlive"]
description = "Generate an IAM policy from AWS calls using client-side monitoring (CSM) or embedded proxy"

[tools.ibmcloud]
backends = ["asdf:mise-plugins/mise-ibmcloud"]
description = "This is the command line client for IBM Cloud"

[tools.idris]
backends = ["asdf:mise-plugins/mise-idris"]
description = "Idris: A Language for Type-Driven Development"

[tools.idris2]
backends = ["asdf:mise-plugins/mise-idris2"]
description = "A purely functional programming language with first class types"

[tools.imagemagick]
backends = ["asdf:mise-plugins/mise-imagemagick"]
description = "ImageMagick is a free, open-source software suite for creating, editing, converting, and displaying images. It supports 200+ formats and offers powerful command-line tools and APIs for automation, scripting, and integration across platforms"

[tools.imgpkg]
backends = ["aqua:carvel-dev/imgpkg", "asdf:vmware-tanzu/asdf-carvel"]
description = "Store application configuration files in Docker/OCI registries"

[tools.infisical]
backends = ["github:Infisical/cli"]
description = "The open source secret management platform: Sync secrets across your team/infrastructure and prevent secret leaks"
test = ["infisical --version", "infisical version {{version}}"]

[tools.infracost]
backends = ["aqua:infracost/infracost", "asdf:dex4er/asdf-infracost"]
description = "Cloud cost estimates for Terraform in pull requests. Love your cloud bill"

[tools.inlets]
backends = ["aqua:inlets/inletsctl", "asdf:nlamirault/asdf-inlets"]
description = "Create inlets servers on the top cloud platforms"

[tools.io]
backends = ["asdf:mise-plugins/mise-io"]
description = "Io is a programming language focused on expressiveness through simplicity"

[tools.istioctl]
backends = ["aqua:istio/istio/istioctl", "asdf:virtualstaticvoid/asdf-istioctl"]
description = "Istio configuration command line utility for service operators to debug and diagnose their Istio mesh"
test = ["istioctl version --remote=false", "client version: {{version}}"]

[tools.janet]
backends = ["asdf:mise-plugins/mise-janet"]
description = "Janet is a functional and imperative programming language"

[tools.jaq]
backends = ["aqua:01mf02/jaq", "ubi:01mf02/jaq", "cargo:jaq"]
description = "A jq clone focussed on correctness, speed, and simplicity"
test = ["jaq --version", "jaq {{version}}"]

[tools.java]
backends = ["core:java"]
description = "jdk java"

[tools.jbang]
backends = ["asdf:mise-plugins/jbang-asdf"]
description = "Lets Students, Educators and Professional Developers create, edit and run self-contained source-only Java programs with unprecedented ease"

[tools.jc]
backends = ["aqua:kellyjonbrazil/jc", "ubi:kellyjonbrazil/jc", "pipx:jc"]
description = "CLI tool and python library that converts the output of popular command-line tools, file-types, and common strings to JSON, YAML, or Dictionaries. This allows piping of output to tools like jq and simplifying automation scripts"
test = ["jc --version", "jc version:  {{version}}"]

[tools.jd]
backends = [
  "aqua:josephburnett/jd",
  "ubi:josephburnett/jd",
  "go:github.com/josephburnett/jd",
]
description = "JSON diff and patch"
test = ["jd --version", "jd version {{version}}"]

[tools.jfrog-cli]
backends = ["asdf:mise-plugins/mise-jfrog-cli"]
description = "Frog CLI is a client that provides a simple interface that automates access to the JFrog products"

[tools.jib]
backends = ["asdf:mise-plugins/mise-jib"]
description = "jib is a general-purpose command-line utility for building Docker or OCI container images from file system content as well as JAR files"
test = ["jib --version", "{{version}}"]

[tools.jiq]
backends = ["aqua:fiatjaf/jiq", "asdf:chessmango/asdf-jiq"]
description = "jid on jq - interactive JSON query tool using jq expressions"

[tools.jj]
aliases = ["jujutsu"]
backends = ["aqua:jj-vcs/jj", "ubi:jj-vcs/jj", "cargo:jj-cli"]
description = "A Git-compatible VCS that is both simple and powerful"

[tools.jjui]
aliases = ["jujutsu-ui"]
backends = ["aqua:idursun/jjui", "ubi:idursun/jjui"]
description = "Jujutsu UI (jjui) is a Text User Interface (TUI) designed for interacting with the Jujutsu version control system"
test = ["jjui --version", "{{version}}"]

[tools.jless]
backends = [
  "aqua:PaulJuliusMartinez/jless",
  "asdf:jc00ke/asdf-jless",
  "cargo:jless",
]
description = "jless is a command-line JSON viewer designed for reading, exploring, and searching through JSON data"

[tools.jmespath]
backends = ["aqua:jmespath/jp", "asdf:skyzyx/asdf-jmespath"]
description = "Command line interface to JMESPath - http://jmespath.org"
test = ["jp --version", "jp version {{version}}"]

[tools.jmeter]
backends = ["asdf:mise-plugins/mise-jmeter"]
description = "The Apache JMeter™ application is open source software, a 100% pure Java application designed to load test functional behavior and measure performance. It was originally designed for testing Web Applications but has since expanded to other test functions"

[tools.jnv]
backends = ["aqua:ynqa/jnv", "asdf:raimon49/asdf-jnv"]
description = "interactive JSON filter using jq"

[tools.jq]
backends = ["aqua:jqlang/jq", "ubi:jqlang/jq", "asdf:mise-plugins/asdf-jq"]
description = "Command-line JSON processor"
test = ["jq --version", "jq-{{version}}"]

[tools.jqp]
backends = ["aqua:noahgorstein/jqp", "asdf:https://gitlab.com/wt0f/asdf-jqp"]
description = "A TUI playground to experiment with jq"

[tools.jreleaser]
backends = ["aqua:jreleaser/jreleaser", "asdf:joschi/asdf-jreleaser"]
description = "Release projects quickly and easily with JReleaser"

[tools.json5]
backends = ["npm:json5"]
description = "JSON5 is an extension to the popular JSON file format that aims to be easier to write and maintain by hand (e.g. for config files). It is not intended to be used for machine-to-machine communication. (Keep using JSON or other file formats for that. 🙂)"
test = ["json5 --version", "{{version}}"]

[tools.jsonnet-bundler]
aliases = ["jb"]
backends = ["aqua:jsonnet-bundler/jsonnet-bundler", "asdf:beardix/asdf-jb"]
description = "A jsonnet package manager"
test = ["jb --version 2>&1", "v{{version}}"]

[tools.jsonschema]
backends = ["aqua:sourcemeta/jsonschema", "ubi:sourcemeta/jsonschema"]
description = "The CLI for working with JSON Schema. Covers formatting, linting, testing, bundling, and more for both local development and CI/CD pipelines"
test = ["jsonschema version", "{{version}}"]

[tools.jules]
backends = ["npm:@google/jules"]
description = "Jules, the asynchronous coding agent from Google, in the terminal"
test = ["jules version", "Version: v{{version}}"]

[tools.julia]
backends = ["asdf:mise-plugins/mise-julia"]
description = "The Julia Programming Language"

[tools.just]
backends = [
  "aqua:casey/just",
  "ubi:casey/just",
  "asdf:olofvndrhr/asdf-just",
  "cargo:just",
]
description = "Just a command runner"
test = ["just --version", "just {{version}}"]

[tools.jwt]
backends = [
  "aqua:mike-engel/jwt-cli",
  "ubi:mike-engel/jwt-cli[exe=jwt]",
  "cargo:jwt-cli",
]
description = "A super fast CLI tool to decode and encode JWTs built in Rust"
test = ["jwt --version", "jwt {{version}}"]

[tools.jwtui]
backends = ["github:jwt-rs/jwt-ui[exe=jwtui]", "cargo:jwt-ui"]
description = "A command line UI for decoding/encoding JSON Web Tokens"

[tools.jx]
backends = ["aqua:jenkins-x/jx", "ubi:jenkins-x/jx", "asdf:vbehar/asdf-jx"]
description = "Jenkins X provides automated CI+CD for Kubernetes with Preview Environments on Pull Requests using Cloud Native pipelines from Tekton"

[tools.k0sctl]
backends = [
  "aqua:k0sproject/k0sctl",
  "ubi:k0sproject/k0sctl",
  "asdf:Its-Alex/asdf-plugin-k0sctl",
]
description = "A bootstrapping and management tool for k0s clusters"
test = ["k0sctl version", "version: v{{version}}"]

[tools.k2tf]
backends = [
  "aqua:sl1pm4t/k2tf",
  "ubi:sl1pm4t/k2tf",
  "asdf:carlduevel/asdf-k2tf",
]
description = "Kubernetes YAML to Terraform HCL converter"
test = ["k2tf --version", "k2tf version: {{version}}"]

[tools.k3d]
backends = ["aqua:k3d-io/k3d", "ubi:k3d-io/k3d", "asdf:spencergilbert/asdf-k3d"]
description = "Little helper to run CNCF's k3s in Docker"
test = ["k3d --version", "k3d version v{{version}}"]

[tools.k3kcli]
backends = [
  'ubi:rancher/k3k[tag_regex=v\\d,matching=k3kcli]',
  "asdf:xanmanning/asdf-k3kcli",
]
description = "K3k, Kubernetes in Kubernetes, is a tool that empowers you to create and manage isolated K3s clusters within your existing Kubernetes environment"
test = ["k3k --version", "k3kcli version v{{version}}"]

[tools.k3s]
backends = ["aqua:k3s-io/k3s", "asdf:mise-plugins/mise-k3s"]
description = "The certified Kubernetes distribution built for IoT & Edge computing"
test = ["k3s --version", "k3s version v{{version}}"]

[tools.k3sup]
backends = ["aqua:alexellis/k3sup", "asdf:cgroschupp/asdf-k3sup"]
description = "bootstrap K3s over SSH in < 60s"

[tools.k6]
backends = ["aqua:grafana/k6", "ubi:grafana/k6", "asdf:gr1m0h/asdf-k6"]
description = "A modern load testing tool, using Go and JavaScript"
test = ["k6 --version", "k6 v{{version}}"]

[tools.k9s]
backends = ["aqua:derailed/k9s", "ubi:derailed/k9s", "asdf:looztra/asdf-k9s"]
description = "Kubernetes CLI To Manage Your Clusters In Style"

[tools.kafka]
backends = ["asdf:mise-plugins/mise-kafka"]
description = "kafka-topics command line (use jdk)"

[tools.kafkactl]
backends = ["aqua:deviceinsight/kafkactl", "asdf:anweber/asdf-kafkactl"]
description = "Command Line Tool for managing Apache Kafka"

[tools.kapp]
backends = ["aqua:carvel-dev/kapp", "asdf:vmware-tanzu/asdf-carvel"]
description = 'kapp is a simple deployment tool focused on the concept of "Kubernetes application" — a set of resources with the same label'

[tools.kbld]
backends = ["aqua:carvel-dev/kbld", "asdf:vmware-tanzu/asdf-carvel"]
description = "kbld seamlessly incorporates image building and image pushing into your development and deployment workflows"

[tools.kcat]
backends = ["asdf:mise-plugins/mise-kcat"]
description = "Generic command line non-JVM Apache Kafka producer and consumer"

[tools.kcctl]
backends = ["github:kcctl/kcctl", "asdf:joschi/asdf-kcctl"]
description = "A modern and intuitive command line client for Kafka Connect"

[tools.kcl]
backends = ["aqua:kcl-lang/cli", "asdf:mise-plugins/mise-kcl"]
description = "The KCL Command Line Interface (CLI)"
test = ["kcl --version", "kcl version {{version}}"]

[tools.kconf]
backends = ["aqua:particledecay/kconf", "asdf:particledecay/asdf-kconf"]
description = "Manage multiple kubeconfigs easily"

[tools.ki]
backends = [
  "aqua:Kotlin/kotlin-interactive-shell",
  "ubi:Kotlin/kotlin-interactive-shell[exe=ki]",
  "asdf:comdotlinux/asdf-ki",
]
description = "Kotlin Language Interactive Shell"
test = ["ki --version", "{{version}}"]

[tools.killport]
backends = ["aqua:jkfran/killport", "ubi:jkfran/killport", "cargo:killport"]
description = "A command-line tool to easily kill processes running on a specified port"
test = ["killport --version", "killport {{version}}"]

[tools.kind]
backends = [
  "aqua:kubernetes-sigs/kind",
  "ubi:kubernetes-sigs/kind",
  "asdf:johnlayton/asdf-kind",
]
description = "Kubernetes IN Docker - local clusters for testing Kubernetes"
test = ["kind --version", "kind version {{version}}"]

[tools.kiota]
backends = ["aqua:microsoft/kiota", "asdf:asdf-community/asdf-kiota"]
description = "OpenAPI based HTTP Client code generator"

[tools.kn]
backends = ["aqua:knative/client", "asdf:joke/asdf-kn"]
description = "Knative developer experience, docs, reference Knative CLI implementation"
test = ["kn version", "Version:"]

[tools.ko]
backends = ["aqua:ko-build/ko", "asdf:zasdaym/asdf-ko"]
description = "Build and deploy Go applications on Kubernetes"
test = ["ko version", "{{version}}"]

[tools.koka]
backends = ["github:koka-lang/koka", "asdf:susurri/asdf-koka"]
description = "Koka language compiler and interpreter"

[tools.kompose]
backends = [
  "aqua:kubernetes/kompose",
  "ubi:kubernetes/kompose",
  "asdf:technikhil314/asdf-kompose",
]
description = "Go from Docker Compose to Kubernetes"
test = ["kompose version", "{{version}}"]

[tools.kops]
backends = ["aqua:kubernetes/kops", "asdf:Antiarchitect/asdf-kops"]
description = "Kubernetes Operations (kops) - Production Grade K8s Installation, Upgrades, and Management"

[tools.kotlin]
backends = ["asdf:mise-plugins/mise-kotlin", "vfox:mise-plugins/vfox-kotlin"]
description = "Kotlin is a modern but already mature programming language designed to make developers happier. It's concise, safe, interoperable with Java and other languages, and provides many ways to reuse code between multiple platforms for productive programming"

[tools.kpack]
aliases = ["kp"]
backends = [
  "github:vmware-tanzu/kpack-cli[exe=kp]",
  "asdf:asdf-community/asdf-kpack-cli",
]
description = "A command line interface for interacting with kpack"
test = ["kp version", "{{version}}"]

[tools.kpt]
backends = ["aqua:kptdev/kpt", "asdf:nlamirault/asdf-kpt"]
description = "Automate Kubernetes Configuration Editing"
os = ["linux", "macos"]

[tools.krab]
backends = ["aqua:ohkrab/krab", "ubi:ohkrab/krab", "asdf:ohkrab/asdf-krab"]
description = "Krab is a migration and automation tool for PostgreSQL based on HCL syntax"
test = ["krab --version 2>&1", "{{version}}"]

[tools.krew]
backends = ["aqua:kubernetes-sigs/krew", "asdf:bjw-s/asdf-krew"]
description = "Find and install kubectl plugins"

[tools.kscript]
backends = [
  "github:kscripting/kscript[bin_path=bin]",
  "asdf:edgelevel/asdf-kscript",
]
description = "Scripting enhancements for Kotlin"

[tools.ksops]
backends = [
  "aqua:viaduct-ai/kustomize-sops",
  "ubi:viaduct-ai/kustomize-sops[exe=ksops]",
  "asdf:janpieper/asdf-ksops",
]
description = "KSOPS - A Flexible Kustomize Plugin for SOPS Encrypted Resources"

[tools.ktlint]
backends = ["aqua:pinterest/ktlint", "asdf:mise-plugins/mise-ktlint"]
depends = ["java"]
description = "An anti-bikeshedding Kotlin linter with built-in formatter"
test = ["ktlint --version", "ktlint version {{version}}"]

[tools.kube-capacity]
backends = ["aqua:robscott/kube-capacity", "asdf:looztra/asdf-kube-capacity"]
description = "A simple CLI that provides an overview of the resource requests, limits, and utilization in a Kubernetes cluster"

[tools.kube-code-generator]
backends = ["asdf:mise-plugins/mise-kube-code-generator"]
description = "Generators for kube-like API types"

[tools.kube-controller-tools]
backends = [
  "github:kubernetes-sigs/controller-tools[exe=controller-gen]",
  "asdf:jimmidyson/asdf-kube-controller-tools",
]
description = "Tools to use with the controller-runtime libraries"

[tools.kube-credential-cache]
backends = [
  "aqua:ryodocx/kube-credential-cache",
  "asdf:ryodocx/kube-credential-cache",
]
description = "Accelerator cache for kubernetes access"

[tools.kube-linter]
backends = ["aqua:stackrox/kube-linter", "asdf:devlincashman/asdf-kube-linter"]
description = "KubeLinter is a static analysis tool that checks Kubernetes YAML files and Helm charts to ensure the applications represented in them adhere to best practices"

[tools.kube-score]
backends = ["aqua:zegl/kube-score", "asdf:bageljp/asdf-kube-score"]
description = "Kubernetes object analysis with recommendations for improved reliability and security. kube-score actively prevents downtime and bugs in your Kubernetes YAML and Charts. Static code analysis for Kubernetes"

[tools.kubebuilder]
backends = [
  "aqua:kubernetes-sigs/kubebuilder",
  "asdf:virtualstaticvoid/asdf-kubebuilder",
]
description = "Kubebuilder - SDK for building Kubernetes APIs using CRDs"

[tools.kubecm]
backends = ["aqua:sunny0826/kubecm", "asdf:samhvw8/asdf-kubecm"]
description = "Manage your kubeconfig more easily"

[tools.kubecolor]
backends = ["aqua:kubecolor/kubecolor", "asdf:dex4er/asdf-kubecolor"]
depends = ["kubectl"]
description = "Colorize your kubectl output"
test = ["kubecolor --kubecolor-version", "{{version}}"]

[tools.kubeconform]
backends = ["aqua:yannh/kubeconform", "asdf:lirlia/asdf-kubeconform"]
description = "A FAST Kubernetes manifests validator, with support for Custom Resources"

[tools.kubectl]
backends = [
  "aqua:kubernetes/kubernetes/kubectl",
  "asdf:asdf-community/asdf-kubectl",
]
description = "kubectl cli"
test = ["kubectl version --client", "Client Version: v{{version}}"]

[tools.kubectl-convert]
backends = [
  "aqua:kubernetes/kubernetes/kubectl-convert",
  "asdf:iul1an/asdf-kubectl-convert",
]
description = "A plugin for Kubernetes command-line tool kubectl, which allows you to convert manifests between different API versions. This can be particularly helpful to migrate manifests to a non-deprecated api version with newer Kubernetes release"

[tools.kubectl-kots]
backends = ["aqua:replicatedhq/kots", "asdf:ganta/asdf-kubectl-kots"]
description = "KOTS provides the framework, tools and integrations that enable the delivery and management of 3rd-party Kubernetes applications, a.k.a. Kubernetes Off-The-Shelf (KOTS) Software"
test = ["kots version", "Replicated KOTS {{version}}"]

[tools.kubectl-kuttl]
aliases = ["kuttl"]
backends = ["aqua:kudobuilder/kuttl", "asdf:jimmidyson/asdf-kuttl"]
description = "Kubernetes Test TooL (kuttl)"
os = ["linux", "macos"]
test = ["kubectl-kuttl --version", "kubectl-kuttl version {{version}}"]

[tools.kubectl-rolesum]
aliases = ["kubectl-bindrole"]
backends = [
  "aqua:Ladicle/kubectl-rolesum",
  "asdf:looztra/asdf-kubectl-bindrole",
]
description = "Summarize Kubernetes RBAC roles for the specified subjects"

[tools.kubectx]
backends = ["aqua:ahmetb/kubectx", "asdf:https://gitlab.com/wt0f/asdf-kubectx"]
description = "Faster way to switch between clusters and namespaces in kubectl"

[tools.kubefedctl]
backends = ["aqua:kubernetes-retired/kubefed", "asdf:kvokka/asdf-kubefedctl"]
description = "kubefedctl controls a Kubernetes Cluster Federation"
test = [
  "kubefedctl version",
  "kubefedctl version:",
] # may not have version in output

[tools.kubefirst]
backends = ["github:konstructio/kubefirst", "asdf:Claywd/asdf-kubefirst"]
description = "The Kubefirst CLI creates instant GitOps platforms that integrate some of the best tools in cloud native from scratch in minutes"

[tools.kubelogin]
backends = ["aqua:int128/kubelogin"]
description = "kubectl plugin for Kubernetes OpenID Connect authentication (kubectl oidc-login)"

[tools.kubemqctl]
backends = ["aqua:kubemq-io/kubemqctl", "asdf:johnlayton/asdf-kubemqctl"]
description = "Kubemqctl is a command line interface (CLI) for KubeMQ, Kubernetes Message Broker"

[tools.kubens]
backends = ["aqua:ahmetb/kubectx/kubens"]
description = "Faster way to switch between clusters and namespaces in kubectl"

[tools.kubent]
backends = [
  "aqua:doitintl/kube-no-trouble",
  "asdf:virtualstaticvoid/asdf-kubent",
]
description = "Easily check your clusters for use of deprecated APIs"
test = ["kubent --version 2>&1", "version {{version}}"]

[tools.kubeone]
backends = ["aqua:kubermatic/kubeone", "aqua:kubermatic/kubeone"]
description = "Kubermatic KubeOne automate cluster operations on all your cloud, on-prem, edge, and IoT environments"
test = ["kubeone version | jq -r '.kubeone.gitVersion'", "{{version}}"]

[tools.kubergrunt]
backends = ["aqua:gruntwork-io/kubergrunt", "asdf:NeoHsu/asdf-kubergrunt"]
description = "Kubergrunt is a standalone go binary with a collection of commands to fill in the gaps between Terraform, Helm, and Kubectl. https://www.gruntwork.io"

[tools.kubeseal]
backends = [
  "aqua:bitnami-labs/sealed-secrets",
  "asdf:stefansedich/asdf-kubeseal",
]
description = "A Kubernetes controller and tool for one-way encrypted Secrets"
test = ["kubeseal --version", "kubeseal version: {{version}}"]

[tools.kubesec]
backends = ["aqua:controlplaneio/kubesec", "asdf:vitalis/asdf-kubesec"]
description = "Security risk analysis for Kubernetes resources"

[tools.kubeshark]
backends = ["aqua:kubeshark/kubeshark", "asdf:carnei-ro/asdf-kubeshark"]
description = "The API traffic analyzer for Kubernetes providing real-time K8s protocol-level visibility, capturing and monitoring all traffic and payloads going in, out and across containers, pods, nodes and clusters. Inspired by Wireshark, purposely built for Kubernetes"

[tools.kubespy]
backends = ["aqua:pulumi/kubespy", "asdf:jfreeland/asdf-kubespy"]
description = "Tools for observing Kubernetes resources in real time, powered by Pulumi"

[tools.kubeswitch]
backends = ["aqua:danielfoehrKn/kubeswitch", "github:danielfoehrKn/kubeswitch"]
description = "The kubectx for operators"
test = ["switcher --version", "switcher version v{{version}}"]

[tools.kubeval]
backends = ["aqua:instrumenta/kubeval", "asdf:stefansedich/asdf-kubeval"]
description = "Validate your Kubernetes configuration files, supports multiple Kubernetes versions"

[tools.kubevela]
backends = ["aqua:kubevela/kubevela", "asdf:gustavclausen/asdf-kubevela"]
description = "The Modern Application Platform"
test = ["vela version", "CLI Version: {{version}}"]

[tools.kubie]
backends = ["aqua:sbstp/kubie", "asdf:johnhamelink/asdf-kubie"]
description = "A more powerful alternative to kubectx and kubens"

[tools.kustomize]
backends = ["aqua:kubernetes-sigs/kustomize", "asdf:Banno/asdf-kustomize"]
description = "Customization of kubernetes YAML configurations"
test = ["kustomize version", "v{{version}}"]

[tools.kwokctl]
backends = ["aqua:kubernetes-sigs/kwok/kwokctl"]
description = "kwokctl is a CLI tool designed to streamline the creation and management of clusters, with nodes simulated by kwok"
test = ["kwokctl --version", "kwok version v{{version}}"]

[tools.kwt]
backends = ["aqua:carvel-dev/kwt", "asdf:vmware-tanzu/asdf-carvel"]
description = "Kubernetes Workstation Tools CLI"

[tools.kyverno]
backends = [
  "aqua:kyverno/kyverno",
  "asdf:https://github.com/hobaen/asdf-kyverno-cli.git",
]
description = "Cloud Native Policy Management"

[tools.lab]
backends = ["aqua:zaquestion/lab", "asdf:particledecay/asdf-lab"]
description = "Lab wraps Git or Hub, making it simple to clone, fork, and interact with repositories on GitLab"

[tools.lane]
backends = ["github:CodeReaper/lane", "asdf:CodeReaper/asdf-lane"]
description = "lane is a task automation helper"

[tools.lazydocker]
backends = ["aqua:jesseduffield/lazydocker", "ubi:jesseduffield/lazydocker"]
description = "The lazier way to manage everything docker"
test = ["lazydocker --version", "Version: {{version}}"]

[tools.lazygit]
backends = ["aqua:jesseduffield/lazygit", "asdf:nklmilojevic/asdf-lazygit"]
description = "simple terminal UI for git commands"

[tools.lazyjournal]
backends = ["aqua:Lifailon/lazyjournal", "ubi:Lifailon/lazyjournal"]
description = "TUI for journalctl, file system logs, as well Docker and Podman containers for quick viewing and filtering with fuzzy find, regex support (like fzf and grep) and coloring the output, written in Go with the gocui library"
test = ["lazyjournal --version", "{{version}}"]

[tools.lazyssh]
backends = ["aqua:Adembc/lazyssh", "ubi:Adembc/lazyssh"]
description = "A terminal-based SSH manager inspired by lazydocker and k9s - Written in go"
test = ["lazyssh --help", "lazyssh [flags]"]

[tools.lean]
backends = ["asdf:mise-plugins/mise-lean"]
description = "Lean is a theorem prover and programming language that enables correct, maintainable, and formally verified code"

[tools.lefthook]
backends = [
  "aqua:evilmartians/lefthook",
  "ubi:evilmartians/lefthook",
  "npm:lefthook",
  "asdf:jtzero/asdf-lefthook",
  "go:github.com/evilmartians/lefthook",
]
description = "Fast and powerful Git hooks manager for any type of projects"
test = ["lefthook version", "{{version}}"]

[tools.leiningen]
backends = ["asdf:mise-plugins/mise-lein"]
description = "for automating Clojure projects without setting your hair on fire"

[tools.levant]
backends = ["aqua:hashicorp/levant", "asdf:mise-plugins/mise-hashicorp"]
description = "An open source templating and deployment tool for HashiCorp Nomad jobs"

[tools.lfe]
backends = ["asdf:mise-plugins/mise-lfe"]
description = "Lisp Flavoured Erlang (LFE)"

[tools.libsql-server]
backends = [
  "github:tursodatabase/libsql[version_prefix=libsql-server-v]",
  "asdf:jonasb/asdf-libsql-server",
]
description = "server mode of libSQL, which is a fork of SQLite that is both Open Source, and Open Contributions"
os = ["linux", "macos"]
test = ["sqld --version", "sqld sqld {{version}}"]

[tools.license-plist]
backends = [
  "aqua:mono0926/LicensePlist",
  "ubi:mono0926/LicensePlist[exe=license-plist]",
  "asdf:MacPaw/asdf-license-plist",
]
description = "A license list generator of all your dependencies for iOS applications"
os = ["macos"]
test = ["license-plist --version", "{{version}}"]

[tools.lima]
backends = ["aqua:lima-vm/lima", "asdf:CrouchingMuppet/asdf-lima"]
description = "Linux virtual machines, with a focus on running containers"
test = ["lima --version", "limactl version {{version}}"]

[tools.linkerd]
backends = ["aqua:linkerd/linkerd2", "asdf:kforsthoevel/asdf-linkerd"]
description = "Ultralight, security-first service mesh for Kubernetes. Main repo for Linkerd 2.x"

[tools.liqoctl]
backends = ["aqua:liqotech/liqo", "asdf:pdemagny/asdf-liqoctl"]
description = "Enable dynamic and seamless Kubernetes multi-cluster topologies"

[tools.liquibase]
backends = ["asdf:mise-plugins/mise-liquibase"]
description = "Liquibase helps millions of developers track, version, and deploy database schema changes"

[tools.litestream]
backends = ["aqua:benbjohnson/litestream", "asdf:threkk/asdf-litestream"]
description = "Streaming replication for SQLite"

[tools.llvm-objcopy]
backends = ["asdf:mise-plugins/mise-llvm"]
description = "object copying and editing tool"

[tools.llvm-objdump]
backends = ["asdf:mise-plugins/mise-llvm"]
description = "LLVM’s object file dumper"

[tools.lnav]
backends = ["aqua:tstack/lnav", "ubi:tstack/lnav"]
description = "Log file navigator"
test = ["lnav --version", "lnav {{version}}"]

[tools.localstack]
backends = ["github:localstack/localstack-cli[exe=localstack]"]
description = "The LocalStack CLI packaged using pyinstaller"
test = ["localstack --version", "LocalStack CLI {{version}}"]

[tools.logtalk]
backends = ["asdf:mise-plugins/mise-logtalk"]
description = "Logtalk is a declarative object-oriented logic programming language that extends and leverages the Prolog language with modern code encapsulation and code reuse mechanisms while also providing improved predicate semantics"

[tools.loki-logcli]
backends = ["aqua:grafana/loki/logcli", "asdf:comdotlinux/asdf-loki-logcli"]
description = "LogCLI is a command-line tool for querying and exploring logs in Grafana Loki"

[tools.ls-lint]
backends = [
  "aqua:loeffel-io/ls-lint",
  "ubi:loeffel-io/ls-lint",
  "npm:@ls-lint/ls-lint",
  "asdf:Ameausoone/asdf-ls-lint",
]
description = "An extremely fast directory and filename linter - Bring some structure to your project filesystem"
test = ["ls-lint --version", "ls-lint v{{version}}"]

[tools.lsd]
backends = ["aqua:lsd-rs/lsd", "asdf:mise-plugins/asdf-lsd", "cargo:lsd"]
description = "The next gen ls command"

[tools.lua]
backends = ["asdf:mise-plugins/mise-lua"]
description = "Lua language"

[tools.lua-language-server]
backends = [
  "aqua:LuaLS/lua-language-server",
  "asdf:bellini666/asdf-lua-language-server",
]
description = "A language server that offers Lua language support - programmed in Lua"

[tools.luajit]
backends = ["asdf:mise-plugins/mise-luaJIT"]
description = "a Just-In-Time Compiler for Lua"

[tools.luau]
backends = ["aqua:luau-lang/luau"]
description = "A fast, small, safe, gradually typed embeddable scripting language derived from Lua"
test = ["echo 'print(_VERSION)' | luau", "Luau"]

[tools.lychee]
backends = ["aqua:lycheeverse/lychee", "ubi:lycheeverse/lychee", "cargo:lychee"]
description = "Fast, async, stream-based link checker written in Rust. Finds broken URLs and mail addresses inside Markdown, HTML, reStructuredText, websites and more"
test = ["lychee --version", "lychee {{version}}"]

[tools.maestro]
backends = ["github:mobile-dev-inc/maestro", "asdf:dotanuki-labs/asdf-maestro"]
description = "Painless E2E Automation for Mobile and Web"

[tools.mage]
backends = ["aqua:magefile/mage", "asdf:mathew-fleisch/asdf-mage"]
description = "a Make/rake-like dev tool using Go"

[tools.magika]
backends = ["cargo:magika-cli"]
description = "Fast and accurate AI powered file content types detection"
test = ["magika --version", "magika {{version | trim_start_matches(pat='v')}}"]

[tools.make]
backends = ["asdf:mise-plugins/mise-make"]
description = "GNU Make is a tool which controls the generation of executables and other non-source files of a program from the program's source files"

[tools.mani]
backends = ["aqua:alajmo/mani", "ubi:alajmo/mani", "asdf:anweber/asdf-mani"]
description = "CLI tool to help you manage repositories"
test = ["mani --version", "Version: {{version}}"]

[tools.mark]
backends = ["github:kovetskiy/mark", "asdf:jfreeland/asdf-mark"]
description = "Sync your markdown files with Confluence pages"

[tools.markdownlint-cli2]
backends = [
  "npm:markdownlint-cli2",
  "asdf:paulo-ferraz-oliveira/asdf-markdownlint-cli2",
]
description = "A fast, flexible, configuration-based command-line interface for linting Markdown/CommonMark files with the markdownlint library"
test = ["markdownlint-cli2 --version", "markdownlint-cli2 v{{version}}"]

[tools.marksman]
backends = ["aqua:artempyanykh/marksman"]
description = "Write Markdown with code assist and intelligence in the comfort of your favourite editor"
test = ["marksman --version", ""]

[tools.marp-cli]
backends = ["aqua:marp-team/marp-cli", "asdf:xataz/asdf-marp-cli"]
description = "A CLI interface for Marp and Marpit based converters"

[tools.mask]
backends = ["aqua:jacobdeichert/mask", "asdf:aaaaninja/asdf-mask"]
description = "A CLI task runner defined by a simple markdown file"
test = ["mask --version", "mask {{version}}"]

[tools.maven]
backends = [
  "aqua:apache/maven",
  "asdf:mise-plugins/mise-maven",
  "vfox:mise-plugins/vfox-maven",
]
description = "Apache Maven core"
test = ["mvn --version", "Apache Maven {{version}}"]

[tools.mc]
backends = ["asdf:mise-plugins/mise-mc"]
description = "Unix like utilities for object store (minio)"

[tools.mdbook]
backends = [
  "aqua:rust-lang/mdBook",
  "asdf:cipherstash/asdf-mdbook",
  "cargo:mdbook",
]
description = "Create book from markdown files. Like Gitbook but implemented in Rust"
test = ["mdbook --version", "mdbook v{{version}}"]

[tools.mdbook-linkcheck]
backends = [
  "ubi:Michael-F-Bryan/mdbook-linkcheck",
  "asdf:mise-plugins/mise-mdbook-linkcheck",
  "cargo:mdbook-linkcheck",
]
description = "A backend for `mdbook` which will check your links for you"
test = ["mdbook-linkcheck --version", "mdbook-linkcheck {{version}}"]

[tools.melange]
backends = ["aqua:chainguard-dev/melange", "asdf:omissis/asdf-melange"]
description = "build APKs from source code"
os = ["linux", "macos"]
test = ["melange version", "GitVersion:    v{{version}}"]

[tools.melt]
backends = ["github:charmbracelet/melt", "asdf:chessmango/asdf-melt"]
description = "Backup and restore Ed25519 SSH keys with seed words 🫠"

[tools.memcached]
backends = ["asdf:mise-plugins/mise-memcached"]
description = "Memcached is a high performance multithreaded event-based key/value cache store intended to be used in a distributed system"

[tools.mercury]
backends = ["asdf:mise-plugins/mise-mercury"]
description = "Mercury is a logic/functional programming language which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features"

[tools.meson]
backends = ["asdf:mise-plugins/mise-meson"]
description = "Meson is an open source build system meant to be both extremely fast, and, even more importantly, as user friendly as possible"

[tools.micronaut]
backends = ["asdf:mise-plugins/mise-micronaut"]
description = "A modern, JVM-based, full-stack framework for building modular, easily testable microservice and serverless applications"

[tools.mill]
backends = ["asdf:mise-plugins/mise-mill"]
description = "Mill is a build tool for Java, Scala and Kotlin: 3-6x faster than Maven or Gradle, less fiddling with plugins, and more easily explorable in your IDE"

[tools.mimirtool]
backends = [
  "aqua:grafana/mimir/mimirtool",
  "asdf:asdf-community/asdf-mimirtool",
]
description = "Mimirtool is a command-line tool that operators and tenants can use to execute a number of common tasks that involve Grafana Mimir or Grafana Cloud Metrics"
os = ["linux", "macos"]
test = ["mimirtool version", "Mimirtool, version {{version}}"]

[tools.minify]
backends = ["aqua:tdewolff/minify", "asdf:axilleas/asdf-minify"]
description = "Go minifiers for web formats"

[tools.minikube]
backends = ["aqua:kubernetes/minikube", "asdf:alvarobp/asdf-minikube"]
description = "Run Kubernetes locally"

[tools.minio]
backends = ["asdf:mise-plugins/mise-minio"]
description = "MinIO AIStor is a high-performance S3-compatible object store licensed under the MinIO Commercial License"

[tools.minishift]
backends = ["aqua:minishift/minishift", "asdf:sqtran/asdf-minishift"]
description = "Run OpenShift 3.x locally"

[tools.minisign]
backends = ["aqua:jedisct1/minisign"]
description = "A dead simple tool to sign files and verify digital signatures"

[tools.mint]
backends = ["github:mint-lang/mint", "asdf:mint-lang/asdf-mint"]
description = "🍃 A refreshing programming language for the front-end web"

[tools.mirrord]
backends = [
  "aqua:metalbear-co/mirrord",
  "ubi:metalbear-co/mirrord",
  "asdf:metalbear-co/asdf-mirrord",
]
description = "Connect your local process and your cloud environment, and run local code in cloud conditions"
test = ["mirrord --version", "mirrord {{version}}"]

[tools.mitmproxy]
backends = ["asdf:mise-plugins/mise-mitmproxy"]
description = "mitmproxy is a free and open source interactive HTTPS proxy"

[tools.mkcert]
backends = [
  "aqua:FiloSottile/mkcert",
  "ubi:FiloSottile/mkcert",
  "asdf:salasrod/asdf-mkcert",
]
description = "A simple zero-config tool to make locally trusted development certificates with any names you'd like"
test = ["mkcert --version", "v{{version}}"]

[tools.mlton]
backends = ["asdf:mise-plugins/mise-mlton"]
description = "MLton is a whole-program optimizing compiler for the Standard ML programming language"

[tools.mockery]
backends = ["aqua:vektra/mockery", "asdf:cabify/asdf-mockery"]
description = "A mock code autogenerator for Go"

[tools.mockolo]
backends = ["github:uber/mockolo", "asdf:mise-plugins/mise-mockolo"]
description = "Efficient Mock Generator for Swift"
test = ["mockolo --help", "Show help information"]

[tools.mold]
backends = ["aqua:rui314/mold", "ubi:rui314/mold"]
description = "Mold: A Modern Linker"
test = ["mold --version", "mold {{version}}"]

[tools.monarch]
backends = ["asdf:mise-plugins/mise-monarch"]
description = "Monarch is a tool for Flutter developers. It makes building front-ends a pleasant experience"

[tools.mongodb]
backends = ["asdf:mise-plugins/mise-mongodb", "vfox:echocat/vfox-mongod"]
description = "MongoDB"

[tools.mongosh]
backends = ["github:mongodb-js/mongosh", "asdf:itspngu/asdf-mongosh"]
description = "The MongoDB Shell"

[tools.mprocs]
backends = ["aqua:pvolok/mprocs", "ubi:pvolok/mprocs"]
description = "Run multiple commands in parallel"
test = ["mprocs --version", "mprocs {{version}}"]

[tools.mssqldef]
backends = ["aqua:sqldef/sqldef/mssqldef"]
description = "Idempotent schema management for MsSQL and more"

[tools.mutanus]
backends = ["asdf:mise-plugins/mise-mutanus"]
description = "Command line tool written in Swift dedicated to perform Mutation Testing of your Swift project"

[tools.mvnd]
backends = ["aqua:apache/maven-mvnd", "asdf:joschi/asdf-mvnd"]
description = "Apache Maven Daemon"

[tools.mysql]
backends = ["asdf:mise-plugins/mise-mysql"]
description = "MySQL Database"

[tools.mysqldef]
backends = ["aqua:sqldef/sqldef/mysqldef"]
description = "Idempotent schema management for MySQL and more"

[tools.nancy]
backends = ["aqua:sonatype-nexus-community/nancy", "asdf:iilyak/asdf-nancy"]
description = "A tool to check for vulnerabilities in your Golang dependencies, powered by Sonatype OSS Index"

[tools.nano]
backends = ["asdf:mise-plugins/mise-nano"]
description = "GNU nano was designed to be a free replacement for the Pico text editor, part of the Pine email suite from The University of Washington. It aimed to 'emulate Pico as closely as is reasonable and then include extra functionality'"

[tools.nasm]
backends = ["asdf:mise-plugins/mise-nasm"]
description = "Netwide Assembler (NASM), an assembler for the x86 CPU architecture portable to nearly every modern platform, and with code generation for many platforms old and new"

[tools.navi]
backends = ["aqua:denisidoro/navi", "ubi:denisidoro/navi", "cargo:navi"]
description = "An interactive cheatsheet tool for the command-line"
test = ["navi --version", "navi {{version}}"]

[tools.neko]
backends = ["github:HaxeFoundation/neko", "asdf:asdf-community/asdf-neko"]
description = "The Neko Virtual Machine"

[tools.nelm]
backends = ["aqua:werf/nelm"]
description = "Nelm is a Helm 4 alternative - it is a Kubernetes deployment tool that manages Helm Charts and deploys them to Kubernetes"
test = ["nelm version | grep full", "full: {{version}}"]

[tools.neonctl]
backends = ["aqua:neondatabase/neonctl", "ubi:neondatabase/neonctl"]
description = "Neon CLI tool. The Neon CLI is a command-line interface that lets you manage Neon Serverless Postgres directly from the terminal"
test = ["neonctl --version", "{{version}}"]

[tools.neovim]
backends = ["aqua:neovim/neovim", "asdf:richin13/asdf-neovim"]
description = "Vim-fork focused on extensibility and usability"

[tools.nerdctl]
backends = ["aqua:containerd/nerdctl", "asdf:dmpe/asdf-nerdctl"]
description = "contaiNERD CTL - Docker-compatible CLI for containerd, with support for Compose, Rootless, eStargz, OCIcrypt, IPFS, "
test = ["nerdctl --version", "nerdctl version {{version}}"]

[tools.newrelic]
aliases = ["newrelic-cli"]
backends = [
  "aqua:newrelic/newrelic-cli",
  "ubi:newrelic/newrelic-cli[exe=newrelic]",
  "asdf:NeoHsu/asdf-newrelic-cli",
]
description = "The New Relic Command Line Interface"
test = ["newrelic --version", "newrelic version {{version}}"]

[tools.nfpm]
backends = [
  "aqua:goreleaser/nfpm",
  "ubi:goreleaser/nfpm",
  "asdf:ORCID/asdf-nfpm",
]
description = "nFPM is Not FPM - a simple deb, rpm and apk packager written in Go"
test = ["nfpm --version", "{{version}}"]

[tools.ni]
backends = ["npm:@antfu/ni"]
description = "ni - use the right package manager"
test = ["ni --version", "@antfu/ni  \u001B[36mv{{version}}\u001B[39m"]

[tools.nim]
backends = ["asdf:mise-plugins/mise-nim"]
description = "Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula"

[tools.ninja]
backends = ["aqua:ninja-build/ninja", "asdf:asdf-community/asdf-ninja"]
description = "a small build system with a focus on speed"

[tools.node]
backends = ["core:node"]
description = "Node.js® is a free, open-source, cross-platform JavaScript runtime environment that lets developers create servers, web apps, command line tools and scripts (Builtin plugin)"

[tools.nomad]
backends = ["aqua:hashicorp/nomad", "asdf:mise-plugins/mise-hashicorp"]
description = "Nomad is an easy-to-use, flexible, and performant workload orchestrator that can deploy a mix of microservice, batch, containerized, and non-containerized applications. Nomad is easy to operate and scale and has native Consul and Vault integrations"

[tools.nomad-pack]
backends = ["asdf:mise-plugins/mise-hashicorp"]
description = "Nomad Pack is a templating and packaging tool used with HashiCorp Nomad"

[tools.notation]
backends = ["aqua:notaryproject/notation", "asdf:bodgit/asdf-notation"]
description = "A CLI tool to sign and verify artifacts"

[tools.nova]
backends = ["aqua:FairwindsOps/nova", "asdf:elementalvoid/asdf-nova"]
description = "Find outdated or deprecated Helm charts running in your cluster"

[tools.nsc]
backends = ["github:nats-io/nsc", "asdf:dex4er/asdf-nsc"]
description = "Tool for creating nkey/jwt based configurations"

[tools.numbat]
backends = ["aqua:sharkdp/numbat", "ubi:sharkdp/numbat", "cargo:numbat-cli"]
description = "A statically typed programming language for scientific computations with first class support for physical dimensions and units"
test = ["numbat --version", "numbat {{version}}"]

[tools.oapi-codegen]
backends = [
  "go:github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen",
  "asdf:dylanrayboss/asdf-oapi-codegen",
]
description = "oapi-codegen is a command-line tool and library to convert OpenAPI specifications to Go code, be it server-side implementations, API clients, or simply HTTP models"

[tools.oauth2c]
backends = ["aqua:cloudentity/oauth2c", "ubi:cloudentity/oauth2c"]
description = "User-friendly OAuth2 CLI"
test = ["oauth2c version 2>&1", "oauth2c version {{version}}"]

[tools.oc]
backends = ["asdf:mise-plugins/mise-oc"]
description = "OpenShift Client CLI (oc)"

[tools.ocaml]
backends = ["asdf:mise-plugins/mise-ocaml"]
description = "An industrial-strength functional programming language with an emphasis on expressiveness and safety"

[tools.oci]
backends = ["asdf:mise-plugins/mise-oci"]
description = "Oracle Cloud Infrastructure CLI"

[tools.octosql]
backends = ["github:cube2222/octosql"]
description = "OctoSQL is a query tool that allows you to join, analyse and transform data from multiple databases and file formats using SQL"
test = ["octosql --version", "octosql version {{version}}"]

[tools.odin]
backends = ["github:odin-lang/Odin[exe=odin]", "asdf:jtakakura/asdf-odin"]
description = "Odin Programming Language"

[tools.odo]
backends = ["aqua:redhat-developer/odo", "asdf:rm3l/asdf-odo"]
description = "A fast, and iterative CLI tool for container-based application development"

[tools.okta-aws]
aliases = ["okta-aws-cli"]
backends = [
  "aqua:okta/okta-aws-cli",
  "asdf:bennythejudge/asdf-plugin-okta-aws-cli",
]
description = "A CLI for having Okta as the IdP for AWS CLI operations"

[tools.okteto]
backends = ["aqua:okteto/okteto", "asdf:BradenM/asdf-okteto"]
description = "Develop your applications directly in your Kubernetes Cluster"

[tools.ollama]
backends = ["aqua:ollama/ollama", "asdf:virtualstaticvoid/asdf-ollama"]
description = "Get up and running with Llama 3.1, Mistral, Gemma 2, and other large language models"

[tools.om]
backends = ["aqua:pivotal-cf/om", "asdf:mise-plugins/tanzu-plug-in-for-asdf"]
description = "General command line utility for working with VMware Tanzu Operations Manager"
test = ["om version", "{{version}}"]

[tools.omnictl]
backends = ["aqua:siderolabs/omni/omnictl", "ubi:siderolabs/omni[exe=omnictl]"]
description = "CLI for Omni - SideroLabs' Kubernetes management platform for bare metal deployments"
test = ["omnictl --version", "omnictl version v{{version}}"]

[tools.onyx]
backends = ["github:onyx-lang/onyx", "asdf:jtakakura/asdf-onyx"]
description = "The compiler and developer toolchain for Onyx"

[tools.opa]
backends = ["aqua:open-policy-agent/opa", "asdf:tochukwuvictor/asdf-opa"]
description = "Open Policy Agent (OPA) is an open source, general-purpose policy engine"

[tools.opam]
backends = [
  "github:ocaml/opam[asset_pattern=opam-*-{gnu_arch}-{os}]",
  "asdf:asdf-community/asdf-opam",
]
description = "(ocaml) opam is a source-based package manager. It supports multiple simultaneous compiler installations, flexible package constraints, and a Git-friendly development workflow"
test = ["opam --version", "{{version}}"]

[tools.openbao]
backends = ["github:openbao/openbao[exe=bao]"]
description = "OpenBao exists to provide a software solution to manage, store, and distribute sensitive data including secrets, certificates, and keys"

[tools.opencode]
backends = ["aqua:sst/opencode", "ubi:sst/opencode"]
description = "AI coding agent, built for the terminal"
test = ["opencode --version", "{{version}}"]

[tools.openfaas-cli]
backends = ["aqua:openfaas/faas-cli", "asdf:zekker6/asdf-faas-cli"]
description = "Official CLI for OpenFaaS"

[tools.opengrep]
backends = ["aqua:opengrep/opengrep", "ubi:opengrep/opengrep"]
description = "Static code analysis engine to find security issues in code"
test = ["opengrep --version", "{{version}}"]

[tools.openresty]
backends = ["asdf:mise-plugins/mise-openresty"]
description = "OpenResty® is a dynamic web platform based on NGINX and LuaJIT"

[tools.opensearch]
backends = ["asdf:mise-plugins/mise-opensearch"]
description = "Open source distributed and RESTful search engine"

[tools.opensearch-cli]
backends = [
  "github:opensearch-project/opensearch-cli",
  "asdf:mise-plugins/mise-opensearch-cli",
]
description = "A full-featured command line interface (CLI) for OpenSearch"
test = ["opensearch-cli --version", "opensearch-cli version {{version}}"]

[tools.openshift-install]
backends = ["asdf:mise-plugins/mise-openshift-install"]
description = "Install an OpenShift 4.x cluster"

[tools.opentofu]
backends = [
  "aqua:opentofu/opentofu",
  "ubi:opentofu/opentofu[exe=tofu]",
  "asdf:virtualroot/asdf-opentofu",
]
description = "OpenTofu lets you declaratively manage your cloud infrastructure"
idiomatic_files = [".opentofu-version"]
test = ["tofu --version", "OpenTofu v{{version}}"]

[tools.operator-sdk]
backends = [
  "aqua:operator-framework/operator-sdk",
  "asdf:Medium/asdf-operator-sdk",
]
description = "SDK for building Kubernetes applications. Provides high level APIs, useful abstractions, and project scaffolding"

[tools.opsgenie-lamp]
backends = [
  "ubi:opsgenie/opsgenie-lamp",
  "asdf:mise-plugins/mise-opsgenie-lamp",
]
description = "OpsGenie Lamp with Go SDK"
test = ["opsgenie-lamp --version", "lamp version "] # 3.1.4 reports 3.2.0

[tools.oras]
backends = ["aqua:oras-project/oras", "asdf:bodgit/asdf-oras"]
description = "ORAS CLI"

[tools.osqueryi]
backends = ["asdf:mise-plugins/mise-osqueryi"]
description = "SQL powered operating system instrumentation, monitoring, and analytics interactive shell"

[tools.osv-scanner]
backends = ["aqua:google/osv-scanner"]
description = "Vulnerability scanner written in Go which uses the data provided by https://osv.dev"
test = ["osv-scanner --version", "osv-scanner version: {{version}}"]

[tools.overmind]
backends = ["github:DarthSim/overmind", "go:github.com/DarthSim/overmind/v2"]
description = "Process manager for Procfile-based applications and tmux"

[tools.oxipng]
backends = ["aqua:oxipng/oxipng", "ubi:oxipng/oxipng", "cargo:oxipng"]
description = "Oxipng is a multithreaded lossless PNG/APNG compression optimizer"
test = ["oxipng --version", "oxipng {{version}}"]

[tools.oxker]
backends = ["aqua:mrjackwills/oxker", "ubi:mrjackwills/oxker", "cargo:oxker"]
description = "A simple tui to view & control docker containers"
test = ["oxker --version", "oxker {{version}}"]

[tools.oxlint]
backends = ["aqua:oxc-project/oxc/oxlint", "ubi:oxc-project/oxc", "npm:oxlint"]
description = "This is the linter for oxc."
# TODO: Re-enable test once the aqua registry is fixed
# The latest release has incorrect binary naming (oxlint.linux-x64-gnu.node instead of oxlint)
# test = ["oxlint --version", "Version: {{version}}"]

[tools.pachctl]
backends = ["aqua:pachyderm/pachyderm", "asdf:abatilo/asdf-pachctl"]
description = "Data-Centric Pipelines and Data Versioning"
test = [
  "pachctl help",
  "",
] # version subcommand fails with invalid configuration

[tools.packer]
backends = ["aqua:hashicorp/packer", "asdf:mise-plugins/mise-hashicorp"]
description = "Packer is a tool for creating identical machine images for multiple platforms from a single source configuration"
idiomatic_files = [".packer-version"]
test = ["packer --version", "Packer v{{version}}"]

[tools.pandoc]
backends = ["github:jgm/pandoc", "asdf:Fbrisset/asdf-pandoc"]
description = "Universal markup converter"

[tools.patat]
backends = ["github:jaspervdj/patat", "asdf:airtonix/asdf-patat"]
description = "Terminal-based presentations using Pandoc"

[tools.pdm]
backends = ["pipx:pdm", "asdf:1oglop1/asdf-pdm"]
description = "A modern Python package and dependency manager supporting the latest PEP standards"
test = ["pdm --version", "PDM, version {{version}}"]

[tools.peco]
backends = ["aqua:peco/peco", "asdf:asdf-community/asdf-peco"]
description = "Simplistic interactive filtering tool"

[tools.periphery]
backends = ["aqua:peripheryapp/periphery", "asdf:mise-plugins/mise-periphery"]
description = "A tool to identify unused code in Swift projects"

[tools.perl]
backends = ["aqua:skaji/relocatable-perl", "asdf:ouest/asdf-perl"]
description = "self-contained, portable perl binaries"

[tools.php]
backends = ["asdf:mise-plugins/asdf-php", "vfox:mise-plugins/vfox-php"]
description = "popular general-purpose scripting language that is especially suited to web development. Fast, flexible and pragmatic, PHP powers everything from your blog to the most popular websites in the world"

[tools.pinact]
backends = ["aqua:suzuki-shunsuke/pinact", "ubi:suzuki-shunsuke/pinact"]
description = "pinact is a CLI to edit GitHub Workflow and Composite action files and pin versions of Actions and Reusable Workflows. pinact can also update their versions and verify version annotations"
test = ["pinact version", "{{version}}"]

[tools.pint]
backends = ["aqua:cloudflare/pint", "asdf:sam-burrell/asdf-pint"]
description = "Prometheus rule linter/validator"

[tools.pipectl]
backends = ["aqua:pipe-cd/pipecd/pipectl", "asdf:pipe-cd/asdf-pipectl"]
description = "The One CD for All {applications, platforms, operations}"
os = ["linux", "macos"]
test = ["pipectl version", "Version: v{{version}}"]

[tools.pipelight]
backends = ["asdf:mise-plugins/mise-pipelight"]
description = "Tiny automation pipelines. Bring CI/CD to the smallest projects. Self-hosted, Lightweight, CLI only"

[tools.pipenv]
backends = ["asdf:mise-plugins/mise-pipenv"]
depends = ["python"]
description = "Python Development Workflow for Humans"

[tools.pipx]
backends = ["aqua:pypa/pipx", "asdf:mise-plugins/mise-pipx"]
depends = ["python"]
test = ["pipx --version", "{{version}}"]

[tools.pitchfork]
backends = ["aqua:jdx/pitchfork", "ubi:jdx/pitchfork"]
description = "Daemons with DX"
test = ["pitchfork --version", "pitchfork {{version}}"]

[tools.pivnet]
backends = [
  "aqua:pivotal-cf/pivnet-cli",
  "asdf:mise-plugins/tanzu-plug-in-for-asdf",
]
description = "CLI to interact with Tanzu Network API V2 interface"
test = ["pivnet version", "{{version}}"]

[tools.pixi]
backends = ["github:prefix-dev/pixi"]
description = "Package management made easy"
test = ["pixi -V", "pixi {{version}}"]

[tools.pkl]
backends = ["aqua:apple/pkl", "ubi:apple/pkl", "asdf:mise-plugins/asdf-pkl"]
description = "A configuration as code language with rich validation and tooling"
test = ["pkl --version", "Pkl {{version}}"]

[tools.please]
backends = ["aqua:thought-machine/please", "asdf:asdf-community/asdf-please"]
description = "High-performance extensible build system for reproducible multi-language builds"

[tools.pluto]
backends = [
  "aqua:FairwindsOps/pluto",
  "ubi:FairwindsOps/pluto",
  "asdf:FairwindsOps/asdf-pluto",
]
description = "A cli tool to help discover deprecated apiVersions in Kubernetes"
test = ["pluto version", "Version:{{version}}"]

[tools.pnpm]
backends = ["aqua:pnpm/pnpm", "ubi:pnpm/pnpm", "npm:pnpm"]
description = "Fast, disk space efficient package manager"
test = ["pnpm --version", "{{version}}"]

[tools.podman]
backends = [
  "github:containers/podman[matching=podman-remote]",
  "asdf:tvon/asdf-podman",
]
description = "Podman: A tool for managing OCI containers and pods"

[tools.poetry]
backends = ["asdf:mise-plugins/mise-poetry"]
depends = ["python"]
description = "Python packaging and dependency management made easy"

[tools.polaris]
backends = ["aqua:FairwindsOps/polaris", "asdf:particledecay/asdf-polaris"]
description = "Validation of best practices in your Kubernetes clusters"

[tools.popeye]
backends = ["aqua:derailed/popeye", "asdf:nlamirault/asdf-popeye"]
description = "A Kubernetes cluster resource sanitizer"

[tools.postgis]
backends = ["asdf:mise-plugins/mise-postgis"]
description = "PostGIS extends the capabilities of the PostgreSQL relational database by adding support for storing, indexing, and querying geospatial data"

[tools.postgres]
backends = ["asdf:mise-plugins/mise-postgres"]
description = "PostgreSQL is a powerful, open source object-relational database system with over 35 years of active development that has earned it a strong reputation for reliability, feature robustness, and performance"

[tools.powerline-go]
backends = [
  "aqua:justjanne/powerline-go",
  "ubi:justjanne/powerline-go",
  "asdf:dex4er/asdf-powerline-go",
]
description = "A beautiful and useful low-latency prompt for your shell, written in go"

[tools.powerpipe]
backends = ["aqua:turbot/powerpipe", "asdf:jc00ke/asdf-powerpipe"]
description = "Powerpipe: Dashboards for DevOps. Visualize cloud configurations. Assess security posture against a massive library of benchmarks. Build custom dashboards with code"

[tools.powershell-core]
aliases = ["powershell"]
backends = [
  "aqua:PowerShell/PowerShell",
  "asdf:daveneeley/asdf-powershell-core",
]
description = "PowerShell for every system"
test = ["pwsh --version", "PowerShell {{version}}"]

[tools.pre-commit]
backends = [
  "aqua:pre-commit/pre-commit",
  "ubi:pre-commit/pre-commit",
  "asdf:jonathanmorley/asdf-pre-commit",
  "pipx:pre-commit",
]
description = "A framework for managing and maintaining multi-language pre-commit hooks"
test = ["pre-commit --version", "pre-commit {{version}}"]

[tools.prek]
backends = ["aqua:j178/prek"]
test = ["prek --version", "prek {{version}}"]

[tools.prettier]
backends = ["npm:prettier"]
description = "Prettier is an opinionated code formatter. It enforces a consistent style by parsing your code and re-printing it with its own rules that take the maximum line length into account, wrapping code when necessary"
test = ["prettier --version", "{{version}}"]

[tools.process-compose]
backends = ["github:F1bonacc1/process-compose"]
description = "Process Compose is a simple and flexible scheduler and orchestrator to manage non-containerized applications."
test = ["process-compose version --short", "{{version}}"]

[tools.promtool]
backends = ["aqua:prometheus/prometheus", "asdf:asdf-community/asdf-promtool"]
description = "The Prometheus monitoring system and time series database"
test = ["promtool --version", "promtool, version {{version}}"]

[tools.protoc]
aliases = ["protobuf"]
backends = [
  "aqua:protocolbuffers/protobuf/protoc",
  "asdf:paxosglobal/asdf-protoc",
]
description = "Protocol Buffers Compiler - Google's data interchange format"

[tools.protoc-gen-connect-go]
backends = [
  "go:connectrpc.com/connect/cmd/protoc-gen-connect-go",
  "asdf:dylanrayboss/asdf-protoc-gen-connect-go",
]
description = "The Go implementation of Connect: Protobuf RPC that works"

[tools.protoc-gen-go]
backends = [
  "aqua:protocolbuffers/protobuf-go/protoc-gen-go",
  "asdf:pbr0ck3r/asdf-protoc-gen-go",
]
description = "protoc-gen-go is a plugin for the Google protocol buffer compiler to generate Go code"

[tools.protoc-gen-go-grpc]
backends = [
  "aqua:grpc/grpc-go/protoc-gen-go-grpc",
  "asdf:pbr0ck3r/asdf-protoc-gen-go-grpc",
]
description = "This tool generates Go language bindings of services in protobuf definition files for gRPC"
test = ["protoc-gen-go-grpc --version", "protoc-gen-go-grpc {{version}}"]

[tools.protoc-gen-grpc-web]
backends = ["asdf:mise-plugins/mise-protoc-gen-grpc-web"]
description = "A JavaScript implementation of gRPC for browser clients"

[tools.protoc-gen-js]
backends = [
  "github:protocolbuffers/protobuf-javascript[exe=protoc-gen-js]",
  "asdf:pbr0ck3r/asdf-protoc-gen-js",
]
description = "This directory contains the JavaScript Protocol Buffers runtime library"

[tools.protoc-gen-validate]
backends = [
  "aqua:bufbuild/protoc-gen-validate",
  "go:github.com/envoyproxy/protoc-gen-validate",
]
description = "Protocol Buffer Validation - Being replaced by github.com/bufbuild/protovalidate"
test = ["which protoc-gen-validate", "protoc-gen-validate"]

[tools.protolint]
backends = ["aqua:yoheimuta/protolint", "asdf:spencergilbert/asdf-protolint"]
description = "A pluggable linter and fixer to enforce Protocol Buffer style and conventions"

[tools.protonge]
backends = ["asdf:mise-plugins/mise-protonge"]
description = "Compatibility tool for Steam Play based on Wine and additional components"

[tools.psc-package]
backends = ["github:purescript/psc-package", "asdf:nsaunders/asdf-psc-package"]
description = "A package manager for PureScript based on package sets"

[tools.psqldef]
backends = ["aqua:sqldef/sqldef/psqldef"]
description = "Idempotent schema management for PostgreSQL"

[tools.pulumi]
backends = ["aqua:pulumi/pulumi", "asdf:canha/asdf-pulumi"]
description = "Pulumi - Infrastructure as Code in any programming language"
test = ["pulumi version", "v{{version}}"]

[tools.purerl]
backends = ["github:purerl/purerl", "asdf:GoNZooo/asdf-purerl"]
description = "Erlang backend for the PureScript compiler"

[tools.purescript]
backends = [
  "github:purescript/purescript[exe=purs]",
  "asdf:jrrom/asdf-purescript",
]
description = "A strongly-typed language that compiles to JavaScript"

[tools.purty]
backends = ["asdf:mise-plugins/mise-purty"]
description = "PureScript pretty-printer"

[tools.python]
backends = ["core:python"]
description = "python language"

[tools.qdns]
backends = ["github:natesales/q", "asdf:moritz-makandra/asdf-plugin-qdns"]
description = "A tiny command line DNS client with support for UDP, TCP, DoT, DoH, DoQ and ODoH"

[tools.qsv]
backends = ["github:dathere/qsv", "asdf:vjda/asdf-qsv"]
description = "Blazing-fast Data-Wrangling toolkit"
test = ["qsv --version", "qsv {{version}}"]

[tools.quarkus]
backends = ["asdf:mise-plugins/mise-quarkus"]
description = "The quarkus command lets you create projects, manage extensions and do essential build and development tasks using the underlying project build tool"

[tools.r]
backends = ["asdf:mise-plugins/mise-r"]
description = "R is a free software environment for statistical computing and graphics"

[tools.rabbitmq]
backends = ["asdf:mise-plugins/asdf-rabbitmq"]
description = "RabbitMQ is a reliable and mature messaging and streaming broker, which is easy to deploy on cloud environments, on-premises, and on your local machine"

[tools.racket]
backends = ["asdf:mise-plugins/mise-racket"]
description = "Racket, the Programming Language"

[tools.railway]
backends = ["github:railwayapp/cli[exe=railway]", "cargo:railwayapp"]
description = "Railway CLI"
test = ["railway --version", "railway {{version}}"]

[tools.raku]
backends = ["asdf:mise-plugins/mise-raku"]
description = "The Raku Programming Language"

[tools.rancher]
backends = ["aqua:rancher/cli", "asdf:abinet/asdf-rancher"]
description = "Rancher CLI"
test = ["rancher --version", "rancher version v{{version}}"]

[tools.rbac-lookup]
backends = ["aqua:FairwindsOps/rbac-lookup", "asdf:looztra/asdf-rbac-lookup"]
description = "Easily find roles and cluster roles attached to any user, service account, or group name in your Kubernetes cluster"

[tools.rclone]
backends = [
  "aqua:rclone/rclone",
  "ubi:rclone/rclone",
  "asdf:johnlayton/asdf-rclone",
]
description = '"rsync for cloud storage" - Google Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Wasabi, Google Cloud Storage, Yandex Files'
test = ["rclone version", "rclone v{{version}}"]

[tools.rebar]
backends = ["asdf:mise-plugins/mise-rebar"]
depends = ["erlang"]
description = "Erlang build tool that makes it easy to compile and test Erlang applications and releases"

[tools.reckoner]
backends = ["github:FairwindsOps/reckoner", "asdf:FairwindsOps/asdf-reckoner"]
description = "Declaratively install and manage multiple Helm chart releases"

[tools.redis]
backends = ["asdf:mise-plugins/mise-redis"]
description = "Cache & in-memory datastore"

[tools.redis-cli]
backends = ["asdf:mise-plugins/mise-redis-cli"]
description = "the Redis command line interface"

[tools.redo]
backends = ["aqua:barthr/redo", "ubi:barthr/redo", "asdf:chessmango/asdf-redo"]
description = "Redo is the ultimate tool to create reusable functions from your history in an interactive way"
test = ["which redo", "redo"]

[tools.redpanda-connect]
aliases = ["benthos"]
backends = ["aqua:redpanda-data/connect", "asdf:benthosdev/benthos-asdf"]
description = "Fancy stream processing made operationally mundane"
test = ["redpanda-connect --version", "Version: {{version}}"]

[tools.reg]
backends = ["aqua:genuinetools/reg", "asdf:looztra/asdf-reg"]
description = "Docker registry v2 command line client and repo listing generator with security checks"

[tools.regal]
backends = ["aqua:StyraInc/regal", "asdf:mise-plugins/mise-regal"]
description = "Regal is a linter for Rego, with the goal of making your Rego magnificent"

[tools.regctl]
backends = ["aqua:regclient/regclient/regctl", "asdf:ORCID/asdf-regctl"]
description = "Docker and OCI Registry Client in Go and tooling using those libraries"

[tools.regsync]
backends = ["aqua:regclient/regclient/regsync", "asdf:rsrchboy/asdf-regsync"]
description = "regsync is a registry synchronization utility used to update mirrors of OCI compatible container registries"

[tools.restic]
backends = ["aqua:restic/restic", "asdf:xataz/asdf-restic"]
description = "Fast, secure, efficient backup program"
test = ["restic version", "restic {{version}}"]

[tools.restish]
backends = [
  "aqua:rest-sh/restish",
  "ubi:rest-sh/restish",
  "go:github.com/danielgtaylor/restish",
]
description = "Restish is a CLI for interacting with REST-ish HTTP APIs with some nice features built-in"
test = ["restish --version", "restish version {{version}}"]

[tools.resvg]
backends = ["aqua:linebender/resvg", "cargo:resvg"]
description = "An SVG rendering library."
test = ["resvg --version", "{{version}}"]

[tools.revive]
backends = ["aqua:mgechev/revive", "asdf:bjw-s/asdf-revive"]
description = "~6x faster, stricter, configurable, extensible, and beautiful drop-in replacement for golint"

[tools.richgo]
backends = ["aqua:kyoh86/richgo", "asdf:paxosglobal/asdf-richgo"]
description = "Enrich `go test` outputs with text decorations"

[tools.ripgrep]
aliases = ["rg"]
backends = [
  "aqua:BurntSushi/ripgrep",
  "ubi:BurntSushi/ripgrep[exe=rg]",
  "asdf:https://gitlab.com/wt0f/asdf-ripgrep",
  "cargo:ripgrep",
]
description = "ripgrep recursively searches directories for a regex pattern while respecting your gitignore"
test = ["rg --version", "ripgrep {{version}}"]

[tools.ripgrep-all]
backends = [
  "aqua:phiresky/ripgrep-all",
  "ubi:phiresky/ripgrep-all[exe=rga]",
  "cargo:ripgrep_all",
]
description = "rga: ripgrep, but also search in PDFs, E-Books, Office documents, zip, tar.gz, etc"
test = ["rga --version", "ripgrep-all {{version}}"]

[tools.ripsecrets]
backends = [
  "aqua:sirwart/ripsecrets",
  "asdf:https://github.com/boris-smidt-klarrio/asdf-ripsecrets",
]
description = "A command-line tool to prevent committing secret keys into your source code"
test = ["ripsecrets --version", "ripsecrets {{version}}"]

[tools.rke]
backends = ["aqua:rancher/rke", "asdf:particledecay/asdf-rke"]
description = "Rancher Kubernetes Engine (RKE), an extremely simple, lightning fast Kubernetes distribution that runs entirely within containers"

[tools.rlwrap]
backends = ["asdf:mise-plugins/mise-rlwrap"]
description = "rlwrap is a 'readline wrapper', a small utility that uses the GNU Readline library to allow the editing of keyboard input for any command"

[tools.rmz]
backends = [
  "aqua:SUPERCILEX/fuc/rmz",
  "ubi:SUPERCILEX/fuc[matching=rmz,rename_exe=rmz]",
]
description = "A zippy alternative to rm, a tool to remove files and directories"
test = ["rmz --version", "rmz {{version}}"]

[tools.rocq]
aliases = ["coq"]
backends = ["asdf:mise-plugins/mise-coq"]
depends = ["ocaml", "opam"]
description = "Rocq: A trustworthy, industrial-strength interactive theorem prover and dependently-typed programming language for mechanised reasoning in mathematics, computer science and more"

[tools.ruby]
backends = ["core:ruby"]
description = "Ruby language"

[tools.ruff]
backends = [
  "aqua:astral-sh/ruff",
  "ubi:astral-sh/ruff",
  "asdf:simhem/asdf-ruff",
]
description = "An extremely fast Python linter and code formatter, written in Rust"
test = ["ruff --version", "ruff {{version}}"]

[tools.rust]
backends = ["core:rust", "asdf:code-lever/asdf-rust"]
description = "Rust language"

[tools.rust-analyzer]
backends = ["aqua:rust-lang/rust-analyzer", "asdf:Xyven1/asdf-rust-analyzer"]
description = "A Rust compiler front-end for IDEs"

[tools.rustic]
backends = ["aqua:rustic-rs/rustic", "ubi:rustic-rs/rustic", "cargo:rustic-rs"]
description = "rustic - fast, encrypted, and deduplicated backups powered by Rust"
test = ["rustic --version", "rustic v{{version}}"]

[tools.rye]
backends = ["aqua:astral-sh/rye", "asdf:Azuki-bar/asdf-rye", "cargo:rye"]
description = "a Hassle-Free Python Experience"

[tools.saml2aws]
backends = ["aqua:Versent/saml2aws", "asdf:elementalvoid/asdf-saml2aws"]
description = "CLI tool which enables you to login and retrieve AWS temporary credentials using a SAML IDP"

[tools.sampler]
backends = ["aqua:sqshq/sampler", "ubi:sqshq/sampler"]
description = "Tool for shell commands execution, visualization and alerting. Configured with a simple YAML file"
test = ["sampler --version 2>&1", "{{version}}"]

[tools.sbcl]
backends = ["asdf:mise-plugins/mise-sbcl"]
description = "Steel Bank Common Lisp"

[tools.sbt]
backends = ["asdf:mise-plugins/mise-sbt"]
depends = ["java"]
description = "sbt, the interactive build tool"

[tools.scala]
backends = ["asdf:mise-plugins/mise-scala", "vfox:mise-plugins/vfox-scala"]
description = "Scala language"

[tools.scala-cli]
backends = ["github:VirtusLab/scala-cli", "asdf:mise-plugins/mise-scala-cli"]
description = "Scala CLI is a command-line tool to interact with the Scala language. It lets you compile, run, test, and package your Scala code (and more!)"

[tools.scaleway]
aliases = ["scaleway-cli"]
backends = [
  "aqua:scaleway/scaleway-cli",
  "asdf:albarralnunez/asdf-plugin-scaleway-cli",
]
description = "Command Line Interface for Scaleway"

[tools.scalingo-cli]
backends = ["aqua:Scalingo/cli", "asdf:brandon-welsch/asdf-scalingo-cli"]
description = "Command Line client for Scalingo PaaS"

[tools.scarb]
backends = ["github:software-mansion/scarb", "asdf:software-mansion/asdf-scarb"]
description = "The Cairo package manager"

[tools.sccache]
backends = [
  "aqua:mozilla/sccache",
  "ubi:mozilla/sccache",
  "asdf:emersonmx/asdf-sccache",
  "cargo:sccache",
]
description = "sccache is ccache with cloud storage"
test = ["sccache --version", "sccache {{version}}"]

[tools.schemacrawler]
backends = ["asdf:mise-plugins/mise-schemacrawler"]
description = "Free database schema discovery and comprehension tool"

[tools.scie-pants]
backends = ["github:pantsbuild/scie-pants", "asdf:robzr/asdf-scie-pants"]
description = "Protects your Pants from the elements"

[tools.scooter]
backends = [
  "aqua:thomasschafer/scooter",
  "ubi:thomasschafer/scooter",
  "cargo:scooter",
]
description = "Interactive find-and-replace in the terminal"
test = ["scooter --version", "scooter {{version}}"]

[tools.scorecard]
backends = ["aqua:ossf/scorecard"]
description = "OpenSSF Scorecard - Security health metrics for Open Source"
test = ["scorecard version", "v{{version}}"]

[tools.sd]
backends = ["aqua:chmln/sd", "ubi:chmln/sd", "cargo:sd"]
description = "Intuitive find & replace CLI (sed alternative)"
test = ["sd --version", "sd {{version}}"]

[tools.seed7]
backends = ["asdf:mise-plugins/mise-seed7"]
description = "Seed7 is a general purpose programming language designed by Thomas Mertes"

[tools.semgrep]
backends = ["pipx:semgrep", "asdf:mise-plugins/mise-semgrep"]
description = "Lightweight static analysis for many languages. Find bug variants with patterns that look like source code."
test = ["semgrep --version", "{{version}}"]

[tools.semtag]
backends = ["asdf:mise-plugins/mise-semtag"]
description = "Semantic Tagging Script for Git"

[tools.semver]
backends = [
  # "aqua:fsaintjacques/semver-tool", # see https://github.com/jdx/mise/discussions/5833
  "vfox:mise-plugins/mise-semver",
  "asdf:mathew-fleisch/asdf-semver",
]
description = "semver bash implementation"
test = ["semver --version", "semver: {{version}}"]

[tools.sentinel]
backends = ["asdf:mise-plugins/mise-hashicorp"]
description = "Sentinel is a policy as code tool that lets you control what users of HashiCorp products are allowed to do. It enforces policies proactively, preventing end users from deploying changes that are not allowed"

[tools.sentry]
aliases = ["sentry-cli"]
backends = ["aqua:getsentry/sentry-cli", "ubi:getsentry/sentry-cli"]
description = "A command line utility to work with Sentry"
test = ["sentry-cli --version", "sentry-cli {{version}}"]

[tools.serf]
backends = ["asdf:mise-plugins/mise-hashicorp"]
description = "Serf is a decentralized solution for service discovery and orchestration that is lightweight, highly available, and fault tolerant"

[tools.serverless]
backends = ["asdf:mise-plugins/mise-serverless"]
description = "Serverless Framework"

[tools.setup-envtest]
backends = ["asdf:mise-plugins/mise-setup-envtest"]
description = "This is a small tool that manages binaries for envtest. It can be used to download new binaries, list currently installed and available ones, and clean up versions"

[tools.shell2http]
backends = ["aqua:msoap/shell2http", "asdf:ORCID/asdf-shell2http"]
description = "Executing shell commands via HTTP server"

[tools.shellcheck]
backends = [
  "aqua:koalaman/shellcheck",
  "ubi:koalaman/shellcheck",
  "asdf:luizm/asdf-shellcheck",
]
description = "ShellCheck, a static analysis tool for shell scripts"
os = ["linux", "macos"]
test = ["shellcheck --version", "version: {{version}}"]

[tools.shellspec]
backends = ["aqua:shellspec/shellspec", "asdf:poikilotherm/asdf-shellspec"]
description = "A full-featured BDD unit testing framework for bash, ksh, zsh, dash and all POSIX shells"

[tools.shfmt]
backends = [
  "aqua:mvdan/sh",
  "ubi:mvdan/sh",
  "asdf:luizm/asdf-shfmt",
  "go:mvdan.cc/sh/v3/cmd/shfmt",
]
description = "A shell parser, formatter, and interpreter with bash support; includes shfmt"
os = ["linux", "macos"]
test = ["shfmt --version", "v{{version}}"]

[tools.shorebird]
backends = ["asdf:mise-plugins/mise-shorebird"]
description = "Code Push for Flutter and other tools for Flutter businesses"

[tools.signadot]
backends = ["github:signadot/cli[exe=signadot]"]
description = "Command-line interface for Signadot"
test = ["signadot --version", "signadot version v{{version}}"]

[tools.sinker]
backends = ["aqua:plexsystems/sinker", "asdf:elementalvoid/asdf-sinker"]
description = "A tool to sync images from one container registry to another"

[tools.skaffold]
backends = [
  "aqua:GoogleContainerTools/skaffold",
  "asdf:nklmilojevic/asdf-skaffold",
]
description = "Easy and Repeatable Kubernetes Development"

[tools.skate]
backends = ["aqua:charmbracelet/skate", "asdf:chessmango/asdf-skate"]
description = "A personal key value store"

[tools.skeema]
backends = ["aqua:skeema/skeema", "ubi:skeema/skeema"]
description = "Declarative pure-SQL schema management for MySQL and MariaDB (Community Edition)"
test = [
  "skeema version | awk -F, '{print $1}'",
  "skeema version {{version}}-community",
]

[tools.sloth]
backends = ["aqua:slok/sloth", "asdf:slok/asdf-sloth"]
description = "Easy and simple Prometheus SLO (service level objectives) generator"

[tools.slsa-verifier]
backends = [
  "aqua:slsa-framework/slsa-verifier",
  "github:slsa-framework/slsa-verifier",
  "go:github.com/slsa-framework/slsa-verifier/v2/cli/slsa-verifier",
]
description = "Verify provenance from SLSA compliant builders"
test = ["slsa-verifier version", "{{version}}"]

[tools.smithy]
backends = ["asdf:mise-plugins/mise-smithy"]
description = "Smithy is a language for defining services and SDKs"

[tools.smlnj]
backends = ["asdf:mise-plugins/mise-smlnj"]
description = "Standard ML of New Jersey (abbreviated SML/NJ) is a compiler for the Standard ML '97 programming language with associated libraries, tools, and documentation"

[tools.snyk]
backends = ["aqua:snyk/cli", "asdf:nirfuchs/asdf-snyk"]
description = "Snyk CLI scans and monitors your projects for security vulnerabilities"

[tools.soft-serve]
backends = [
  "github:charmbracelet/soft-serve[exe=soft]",
  "asdf:chessmango/asdf-soft-serve",
]
description = "The mighty, self-hostable Git server for the command line"

[tools.solidity]
backends = [
  "github:ethereum/solidity[exe=solc]",
  "asdf:diegodorado/asdf-solidity",
]
description = "Solidity, the Smart Contract Programming Language"

[tools.sonar-scanner-cli]
backends = [
  "aqua:SonarSource/sonar-scanner-cli",
  "asdf:virtualstaticvoid/asdf-sonarscanner",
]
description = "Scanner CLI for SonarQube (Server, Cloud)"
test = ["sonar-scanner --version", "SonarScanner CLI {{version}}"]

[tools.sonobuoy]
backends = ["github:vmware-tanzu/sonobuoy", "asdf:Nick-Triller/asdf-sonobuoy"]
description = "Sonobuoy is a diagnostic tool that makes it easier to understand the state of a Kubernetes cluster by running a set of Kubernetes conformance tests and other plugins in an accessible and non-destructive manner"

[tools.sops]
backends = [
  "aqua:getsops/sops",
  "ubi:getsops/sops",
  "asdf:mise-plugins/mise-sops",
]
description = "Simple and flexible tool for managing secrets"

[tools.sopstool]
backends = ["aqua:ibotta/sopstool", "asdf:elementalvoid/asdf-sopstool"]
description = "SOPS multi-file wrapper"

[tools.soracom]
backends = ["github:soracom/soracom-cli", "asdf:gr1m0h/asdf-soracom"]
description = "Provides `soracom` command, a command line tool for calling SORACOM APIs"

[tools.sourcery]
backends = ["asdf:mise-plugins/mise-sourcery"]
description = "Meta-programming for Swift, stop writing boilerplate code"

[tools.spacectl]
backends = ["aqua:spacelift-io/spacectl", "asdf:bodgit/asdf-spacectl"]
description = "Spacelift client and CLI"

[tools.spago]
backends = ["github:purescript/spago", "asdf:jrrom/asdf-spago"]
description = "🍝 PureScript package manager and build tool"

[tools.spark]
backends = ["aqua:apache/spark", "asdf:mise-plugins/mise-spark"]
depends = ["java"]
description = "Apache Spark - A unified analytics engine for large-scale data processing"
test = ["spark-shell --version 2>&1", "version {{version}}"]

[tools.specstory]
backends = ["aqua:specstoryai/getspecstory", "ubi:specstoryai/getspecstory"]
description = "You don’t write prompts. You author intent. Enhance your AI development workflow with SpecStory"
os = ["linux", "macos"]
test = ["specstory --version", "{{version}} (SpecStory)"]

[tools.spectral]
backends = ["aqua:stoplightio/spectral", "asdf:vbyrd/asdf-spectral"]
description = "A flexible JSON/YAML linter for creating automated style guides, with baked in support for OpenAPI (v3.1, v3.0, and v2.0), Arazzo v1.0, as well as AsyncAPI v2.x"

[tools.spin]
backends = ["aqua:spinnaker/spin", "asdf:pavloos/asdf-spin"]
description = "Spinnaker CLI"

[tools.spring-boot]
backends = ["asdf:mise-plugins/mise-spring-boot"]
description = "Spring Boot CLI"

[tools.spruce]
backends = ["aqua:geofffranks/spruce", "asdf:woneill/asdf-spruce"]
description = "Standalone, daemon-less, unprivileged Dockerfile and OCI compatible container image builder"

[tools.sqlite]
backends = ["asdf:mise-plugins/mise-sqlite"]
description = "SQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine. SQLite is the most used database engine in the world"

[tools.sqlite3def]
backends = ["aqua:sqldef/sqldef/sqlite3def"]
description = "The easiest idempotent SQLite3 Server schema management by SQL"

[tools.sshi]
backends = ["aqua:aakso/ssh-inscribe/sshi"]
description = "SSH CA Client/Server"
test = ["sshi version", "local: {{version}}"]

[tools.sshuttle]
backends = ["asdf:mise-plugins/mise-sshuttle"]
description = "sshuttle: where transparent proxy meets VPN meets ssh"

[tools.sst]
backends = ["github:sst/sst"]
description = "Build full-stack apps on your own infrastructure"
test = ["sst version", "sst {{version}}"]

[tools.stack]
backends = ["aqua:commercialhaskell/stack", "asdf:mise-plugins/mise-ghcup"]
description = "The Haskell Tool Stack"
test = ["stack --version", "Version {{version}}"]

[tools.starboard]
backends = [
  "aqua:aquasecurity/starboard",
  "asdf:zufardhiyaulhaq/asdf-starboard",
]
description = "Kubernetes-native security toolkit"

[tools.starknet-foundry]
backends = ["github:foundry-rs/starknet-foundry[exe=snforge]"]
description = "Starknet testing framework (like Truffle, Hardhat and DappTools but for Starknet)"

[tools.starknet-foundry-sncast]
backends = ["github:foundry-rs/starknet-foundry[exe=sncast]"]
description = "All-in-one tool for interacting with Starknet smart contracts, sending transactions and getting chain data"

[tools.starship]
backends = [
  "aqua:starship/starship",
  "ubi:starship/starship",
  "asdf:gr1m0h/asdf-starship",
  "cargo:starship",
]
description = "The minimal, blazing-fast, and infinitely customizable prompt for any shell"
test = ["starship --version", "starship {{version}}"]

[tools.staticcheck]
backends = [
  "aqua:dominikh/go-tools/staticcheck",
  "asdf:pbr0ck3r/asdf-staticcheck",
  "go:honnef.co/go/tools/cmd/staticcheck",
]
description = "Staticcheck - The advanced Go linter"
test = ["staticcheck --version", "staticcheck {{version}}"]

[tools.steampipe]
backends = ["aqua:turbot/steampipe", "asdf:carnei-ro/asdf-steampipe"]
description = "Use SQL to instantly query your cloud services (AWS, Azure, GCP and more). Open source CLI. No DB required"
test = ["steampipe --version", "Steampipe v{{version}}"]

[tools.step]
backends = ["aqua:smallstep/cli", "asdf:log2/asdf-step"]
description = "A zero trust swiss army knife for working with X509, OAuth, JWT, OATH OTP, etc"

[tools.stern]
backends = ["aqua:stern/stern", "asdf:looztra/asdf-stern"]
description = "⎈ Multi pod and container log tailing for Kubernetes -- Friendly fork of https://github.com/wercker/stern"

[tools.stripe]
aliases = ["stripe-cli"]
backends = ["aqua:stripe/stripe-cli", "asdf:offbyone/asdf-stripe"]
description = "A command-line tool for Stripe"

[tools.stylua]
backends = [
  "aqua:JohnnyMorganz/StyLua",
  "asdf:jc00ke/asdf-stylua",
  "cargo:stylua",
]
description = "A Lua code formatter"
test = ["stylua --version", "stylua {{version}}"]

[tools.sui]
backends = ["github:MystenLabs/sui", "asdf:placeholder-soft/asdf-sui"]
description = "ui, a next-generation smart contract platform with high throughput, low latency, and an asset-oriented programming model powered by the Move programming language"

[tools.supabase]
backends = ["aqua:supabase/cli"]
description = "Supabase CLI. Manage postgres migrations, run Supabase locally, deploy edge functions. Postgres backups. Generating types from your database schema"
test = ["supabase --version", "{{version}}"]

[tools.superfile]
backends = ["aqua:yorukot/superfile"]
description = "Pretty fancy and modern terminal file manager"
test = ["spf --version", "superfile version v{{version}}"]

[tools.superhtml]
backends = ["github:kristoff-it/superhtml"]
description = "HTML Validator, Formatter, LSP, and Templating Language Library"
test = ["superhtml version 2>&1", "{{version}}"]

[tools.sver]
backends = ["aqua:mitoma/sver", "asdf:robzr/asdf-sver"]
description = "Version generator based on source code"

[tools.svu]
backends = ["aqua:caarlos0/svu", "asdf:asdf-community/asdf-svu"]
description = "semantic version utility"

[tools.swag]
backends = ["aqua:swaggo/swag", "asdf:behoof4mind/asdf-swag"]
description = "Automatically generate RESTful API documentation with Swagger 2.0 for Go"

[tools.swift]
backends = ["core:swift"]
description = "Swift Lang (Core)"
os = ["linux", "macos"]

[tools.swift-package-list]
backends = ["asdf:mise-plugins/mise-swift-package-list"]
description = "A command-line tool to get all used Swift Package dependencies"

[tools.swiftformat]
backends = ["asdf:mise-plugins/mise-swiftformat"]
description = "A command-line tool and Xcode Extension for formatting Swift code"

[tools.swiftgen]
backends = ["asdf:mise-plugins/mise-swiftgen"]
description = "The Swift code generator for your assets, storyboards, Localizable.strings, … — Get rid of all String-based APIs!"

[tools.swiftlint]
backends = ["aqua:realm/SwiftLint", "asdf:mise-plugins/mise-swiftlint"]
description = "A tool to enforce Swift style and conventions"
test = ["swiftlint --version", "{{version}}"]

[tools.swiprolog]
backends = ["asdf:mise-plugins/mise-swiprolog"]
description = "SWI-Prolog offers a comprehensive free Prolog environment"

[tools.syft]
backends = ["aqua:anchore/syft", "asdf:davidgp1701/asdf-syft"]
description = "CLI tool and library for generating a Software Bill of Materials from container images and filesystems"

[tools.tailpipe]
backends = ["aqua:turbot/tailpipe"]
description = "select * from logs! Tailpipe is an open source SIEM for instant log insights, powered by DuckDB. Analyze millions of events in seconds, right from your terminal"
test = ["tailpipe --version", "Tailpipe v{{version}}"]

[tools.talhelper]
backends = ["aqua:budimanjojo/talhelper", "asdf:bjw-s/asdf-talhelper"]
description = "A tool to help creating Talos kubernetes cluster"

[tools.talosctl]
aliases = ["talos"]
backends = ["aqua:siderolabs/talos", "ubi:siderolabs/talos[exe=talosctl]"]
description = "Talos is a modern OS for Kubernetes. talosctl is a CLI for out-of-band management of Kubernetes nodes created by Talos"
test = ["talosctl version --client --short", "Talos v{{version}}"]

[tools.tanka]
backends = ["aqua:grafana/tanka", "asdf:trotttrotttrott/asdf-tanka"]
description = "Flexible, reusable and concise configuration for Kubernetes"

[tools.tanzu]
backends = ["github:vmware-tanzu/tanzu-cli[rename_exe=tanzu]"]
description = "The Tanzu Core CLI project provides the core functionality of the Tanzu CLI. The CLI is based on a plugin architecture where CLI command functionality can be delivered through independently developed plugin binaries"
test = ["tanzu version", "version: v{{version}}"]

[tools.taplo]
backends = ["aqua:tamasfe/taplo", "ubi:tamasfe/taplo", "cargo:taplo-cli"]
description = "A TOML toolkit written in Rust"
test = ["taplo --version", "taplo {{version}}"]

[tools.task]
backends = [
  "aqua:go-task/task",
  "ubi:go-task/task",
  "asdf:particledecay/asdf-task",
]
description = "A task runner / simpler Make alternative written in Go"
test = ["task --version", "{{version}}"]

[tools.tbls]
backends = ["aqua:k1LoW/tbls", "ubi:k1LoW/tbls"]
description = "A CI-Friendly tool to document a database written in Go"
test = ["tbls version", "{{version}}"]

[tools.tctl]
backends = ["aqua:temporalio/tctl", "asdf:eko/asdf-tctl"]
description = "Temporal CLI"

[tools.tekton]
aliases = ["tekton-cli"]
backends = ["aqua:tektoncd/cli", "asdf:johnhamelink/asdf-tekton-cli"]
description = "A CLI for interacting with Tekton"

[tools.teleport-community]
backends = ["asdf:mise-plugins/mise-teleport-community"]
description = "Teleport provides connectivity, authentication, access controls and audit for infrastructure (community version)"

[tools.teleport-ent]
backends = ["asdf:mise-plugins/mise-teleport-ent"]
description = "Teleport provides connectivity, authentication, access controls and audit for infrastructure (Enterprise version)"

[tools.telepresence]
backends = [
  "aqua:telepresenceio/telepresence",
  "asdf:pirackr/asdf-telepresence",
]
description = "Local development against a remote Kubernetes or OpenShift cluster"

[tools.television]
backends = ["aqua:alexpasmantier/television"]
description = "The revolution will (not) be televised"
test = ["tv --version", "television {{version}}"]

[tools.teller]
backends = ["aqua:tellerops/teller", "asdf:pdemagny/asdf-teller"]
description = "Cloud native secrets management for developers - never leave your command line for secrets"

[tools.temporal]
backends = ["aqua:temporalio/temporal", "asdf:asdf-community/asdf-temporal"]
description = "Temporal service and CLI"

[tools.terradozer]
backends = ["aqua:jckuester/terradozer", "asdf:chessmango/asdf-terradozer"]
description = "Terraform destroy without configuration files"

[tools.terraform]
backends = [
  "aqua:hashicorp/terraform",
  "asdf:mise-plugins/mise-hashicorp",
  "vfox:mise-plugins/vfox-terraform",
]
description = "Terraform enables you to safely and predictably create, change, and improve infrastructure. It is an open source tool that codifies APIs into declarative configuration files that can be shared amongst team members, treated as code, edited, reviewed, and versioned"
idiomatic_files = [".terraform-version"]
test = ["terraform version", "Terraform v{{version}}"]

[tools.terraform-docs]
backends = [
  "aqua:terraform-docs/terraform-docs",
  "asdf:looztra/asdf-terraform-docs",
]
description = "Generate documentation from Terraform modules in various output formats"

[tools.terraform-ls]
backends = ["aqua:hashicorp/terraform-ls", "asdf:mise-plugins/mise-hashicorp"]
description = "Terraform Language Server"

[tools.terraform-lsp]
backends = [
  "aqua:juliosueiras/terraform-lsp",
  "asdf:bartlomiejdanek/asdf-terraform-lsp",
]
description = "Language Server Protocol for Terraform"

[tools.terraform-validator]
backends = [
  "aqua:thazelart/terraform-validator",
  "asdf:looztra/asdf-terraform-validator",
]
description = "A norms and conventions validator for Terraform"

[tools.terraformer]
backends = [
  "aqua:GoogleCloudPlatform/terraformer",
  "asdf:gr1m0h/asdf-terraformer",
]
description = "CLI tool to generate terraform files from existing infrastructure (reverse Terraform). Infrastructure to Code"

[tools.terragrunt]
backends = ["aqua:gruntwork-io/terragrunt", "asdf:gruntwork-io/asdf-terragrunt"]
description = "Terragrunt is a thin wrapper for Terraform that provides extra tools for working with multiple Terraform modules"
idiomatic_files = [".terragrunt-version"]
test = ["terragrunt --version", "terragrunt version v{{version}}"]

[tools.terramate]
backends = ["aqua:terramate-io/terramate", "asdf:martinlindner/asdf-terramate"]
description = "Open-source Infrastructure as Code (IaC) orchestration platform: GitOps workflows, orchestration, code generation, observability, drift detection, asset management, policies, Slack notifications, and more. Integrates with Terraform, OpenTofu, Terragrunt, Kubernetes, GitHub Actions, GitLab CI/CD, BitBucket Pipelines, and any other CI/CD platform"
idiomatic_files = [".terramate-version"]

[tools.terrascan]
backends = ["aqua:tenable/terrascan", "asdf:hpdobrica/asdf-terrascan"]
description = "Detect compliance and security violations across Infrastructure as Code to mitigate risk before provisioning cloud native infrastructure"

[tools.tf-summarize]
backends = ["aqua:dineshba/tf-summarize", "asdf:adamcrews/asdf-tf-summarize"]
description = "A command-line utility to print the summary of the terraform plan"

[tools.tfc-agent]
backends = ["asdf:mise-plugins/mise-hashicorp"]
description = "HCP Terraform Agents allow HCP Terraform to communicate with isolated, private, or on-premises infrastructure"

[tools.tfctl]
backends = ["aqua:flux-iac/tofu-controller/tfctl", "asdf:deas/asdf-tfctl"]
description = "A GitOps OpenTofu and Terraform controller for Flux"

[tools.tfenv]
backends = ["aqua:tfutils/tfenv", "asdf:carlduevel/asdf-tfenv"]
description = "Terraform version manager"

[tools.tflint]
backends = [
  "aqua:terraform-linters/tflint",
  "ubi:terraform-linters/tflint",
  "asdf:skyzyx/asdf-tflint",
]
description = "A Pluggable Terraform Linter"
test = ["tflint --version", "TFLint version {{version}}"]

[tools.tfmigrate]
backends = ["aqua:minamijoyo/tfmigrate", "asdf:dex4er/asdf-tfmigrate"]
description = "A Terraform / OpenTofu state migration tool for GitOps"

[tools.tfnotify]
backends = ["aqua:mercari/tfnotify", "asdf:jnavarrof/asdf-tfnotify"]
description = "A CLI command to parse Terraform execution result and notify it to GitHub"

[tools.tfsec]
backends = ["aqua:aquasecurity/tfsec", "asdf:woneill/asdf-tfsec"]
description = "Security scanner for your Terraform code"

[tools.tfstate-lookup]
backends = [
  "aqua:fujiwara/tfstate-lookup",
  "asdf:carnei-ro/asdf-tfstate-lookup",
]
description = "Lookup resource attributes in tfstate"

[tools.tfswitch]
backends = [
  "github:warrensbox/terraform-switcher[exe=tfswitch]",
  "asdf:iul1an/asdf-tfswitch",
]
description = "A command line tool to switch between different versions of terraform (install with homebrew and more)"

[tools.tfupdate]
backends = ["aqua:minamijoyo/tfupdate", "asdf:yuokada/asdf-tfupdate"]
description = "Update version constraints in your Terraform configurations"

[tools.thrift]
backends = ["asdf:mise-plugins/mise-thrift"]
description = "Thrift is a lightweight, language-independent software stack for point-to-point RPC implementation"

[tools.tilt]
backends = ["aqua:tilt-dev/tilt", "asdf:eaceaser/asdf-tilt"]
description = "Define your dev environment as code. For microservice apps on Kubernetes"

[tools.timoni]
backends = ["aqua:stefanprodan/timoni", "asdf:Smana/asdf-timoni"]
description = "Timoni is a package manager for Kubernetes, powered by CUE and inspired by Helm"

[tools.tiny]
backends = ["asdf:mise-plugins/mise-tiny"]
description = "rtx-tiny is mostly a fake plugin to check mise in CI"

[tools.tinymist]
backends = [
  "aqua:Myriad-Dreamin/tinymist",
  "ubi:Myriad-Dreamin/tinymist",
  "cargo:tinymist",
]
description = "Tinymist is an integrated language service for Typst."
test = [
  "tinymist --version",
  "",
  # 0.14.4 doesn't print version
  # "Build Git Describe:  v{{version}}",
]

[tools.tinytex]
backends = ["asdf:mise-plugins/mise-tinytex"]
description = "A lightweight, cross-platform, portable, and easy-to-maintain LaTeX distribution based on TeX Live"

[tools.titan]
backends = ["github:titan-data/titan", "asdf:gabitchov/asdf-titan"]
description = "Titan is an open source project for developers to manage their data like code"

[tools.tlrc]
backends = ["aqua:tldr-pages/tlrc", "ubi:tldr-pages/tlrc", "cargo:tlrc"]
description = "A tldr client written in Rust"
test = ["tldr --version", "tlrc v{{version}}"]

[tools.tmux]
backends = ["asdf:mise-plugins/mise-tmux"]
description = "tmux is a terminal multiplexer. It lets you switch easily between several programs in one terminal, detach them (they keep running in the background) and reattach them to a different terminal"

[tools.tokei]
backends = [
  # v13.0.0 doesn't have binaries
  "cargo:tokei",
  "aqua:XAMPPRocky/tokei",
  "ubi:XAMPPRocky/tokei",
  "asdf:gasuketsu/asdf-tokei",
]
description = "Count your code, quickly"
test = ["tokei --version", "tokei {{version}}"]

[tools.tombi]
backends = ["aqua:tombi-toml/tombi", "ubi:tombi-toml/tombi"]
description = "TOML Formatter / Linter / Language Server"
test = ["tombi --version", "tombi {{version}}"]

[tools.tomcat]
backends = ["asdf:mise-plugins/mise-tomcat"]
description = "The Apache Tomcat® software is an open source implementation of the Jakarta Servlet, Jakarta Pages, Jakarta Expression Language, Jakarta WebSocket, Jakarta Annotations and Jakarta Authentication specifications. These specifications are part of the Jakarta EE platform"

[tools.tonnage]
backends = ["github:elementalvoid/tonnage", "asdf:elementalvoid/asdf-tonnage"]
description = "Tonnage is a small utility to summarize the resource capacity and allocation of a Kubernetes cluster"

[tools.traefik]
backends = ["github:traefik/traefik", "asdf:Dabolus/asdf-traefik"]
description = "The Cloud Native Application Proxy"

[tools.transifex]
backends = ["github:transifex/cli[exe=tx]", "asdf:ORCID/asdf-transifex"]
description = "The Transifex command-line client"

[tools.trdsql]
backends = ["aqua:noborus/trdsql", "asdf:johnlayton/asdf-trdsql"]
description = "CLI tool that can execute SQL queries on CSV, LTSV, JSON and TBLN. Can output to various formats"

[tools.tree-sitter]
backends = ["aqua:tree-sitter/tree-sitter", "asdf:ivanvc/asdf-tree-sitter"]
description = "An incremental parsing system for programming tools"

[tools.tridentctl]
backends = [
  "aqua:NetApp/trident/tridentctl",
  "asdf:asdf-community/asdf-tridentctl",
]
depends = ["kubectl"]
description = "Storage orchestrator for containers"
os = ["linux", "macos"]
test = ["tridentctl version --client", "{{version}}"]

[tools.trivy]
backends = ["aqua:aquasecurity/trivy", "asdf:zufardhiyaulhaq/asdf-trivy"]
description = "Find vulnerabilities, misconfigurations, secrets, SBOM in containers, Kubernetes, code repositories, clouds and more"

[tools.trufflehog]
backends = [
  "aqua:trufflesecurity/trufflehog",
  "github:trufflesecurity/trufflehog",
]
test = ["trufflehog --version", "trufflehog {{version}}"]

[tools.trunk]
backends = ["npm:@trunkio/launcher"]
description = "Trunk is a comprehensive code quality tool that runs linters, formatters, and security scanners to help maintain high-quality codebases (https://trunk.io)"
test = [
  "trunk --help",
  "trunk [flags] [subcommand]",
] # --version can't be used because we know the launcher version, but we get the binary version

[tools.trzsz-ssh]
aliases = ["tssh"]
backends = [
  "aqua:trzsz/trzsz-ssh",
  "ubi:trzsz/trzsz-ssh",
  "go:github.com/trzsz/trzsz-ssh/cmd/tssh",
]
description = "trzsz-ssh ( tssh ) is an ssh client designed as a drop-in replacement for the openssh client. It aims to provide complete compatibility with openssh, mirroring all its features, while also offering additional useful features. Such as login prompt, batch login, remember password, automated interaction, trzsz, zmodem(rz/sz), udp mode like mosh, etc."
test = ["tssh --version 2>&1", "trzsz ssh {{version}}"]

[tools.tsuru]
backends = [
  "github:tsuru/tsuru-client[exe=tsuru]",
  "asdf:virtualstaticvoid/asdf-tsuru",
]
description = "tsuru-client is a tsuru command line tool for application developers"

[tools.ttyd]
backends = ["aqua:tsl0922/ttyd", "asdf:ivanvc/asdf-ttyd"]
description = "Share your terminal over the web"

[tools.tuist]
backends = ["asdf:mise-plugins/mise-tuist"]
description = "A toolchain to generate Xcode projects from Swift packages"
os = ["macos"]

[tools.tusd]
backends = ["github:tus/tusd"]
description = "Reference server implementation in Go of tus: the open protocol for resumable file uploads"
test = ["tusd --version | head -n1", "Version: v{{version}}"]

[tools.typos]
backends = [
  "aqua:crate-ci/typos",
  "ubi:crate-ci/typos",
  "asdf:aschiavon91/asdf-typos",
  "cargo:typos-cli",
]
description = "Source code spell checker"
test = ["typos --version", "typos-cli {{version}}"]

[tools.typst]
backends = [
  "aqua:typst/typst",
  "ubi:typst/typst",
  "asdf:stephane-klein/asdf-typst",
  "cargo:typst-cli",
]
description = "A new markup-based typesetting system that is powerful and easy to learn"
test = ["typst --version", "typst {{version}}"]

[tools.typstyle]
backends = [
  "aqua:Enter-tainer/typstyle",
  "ubi:Enter-tainer/typstyle",
  "cargo:typstyle",
]
description = "Beautiful and reliable typst code formatter"
test = [
  "typstyle --version | grep 'Version:' | awk '{print $2}'",
  "{{version}}",
]

[tools.uaa]
aliases = ["uaa-cli"]
backends = [
  "aqua:cloudfoundry/uaa-cli",
  "ubi:cloudfoundry/uaa-cli[exe=uaa]",
  "asdf:mise-plugins/tanzu-plug-in-for-asdf",
]
description = "CLI for UAA written in Go"
test = ["uaa version", "{{version}}"]

[tools.ubi]
backends = ["aqua:houseabsolute/ubi", "ubi:houseabsolute/ubi"]
description = "The Universal Binary Installer"
test = ["ubi --version", "ubi {{version}}"]

[tools.unison]
backends = ["github:unisonweb/unison", "asdf:susurri/asdf-unison"]
description = "A friendly programming language from the future"

[tools.upctl]
backends = ["aqua:UpCloudLtd/upcloud-cli"]
description = "UpCloud command line client (upctl)"
test = ["upctl version", "{{version}}"]

[tools.updatecli]
backends = ["aqua:updatecli/updatecli", "asdf:updatecli/asdf-updatecli"]
description = "A Declarative Dependency Management tool"

[tools.upt]
backends = ["github:sigoden/upt", "asdf:ORCID/asdf-upt"]
description = "Universal Package-management Tool for any OS"

[tools.upx]
backends = ["aqua:upx/upx", "asdf:jimmidyson/asdf-upx"]
description = "UPX - the Ultimate Packer for eXecutables"

[tools.usage]
backends = [
  { full = "aqua:jdx/usage", platforms = [
    "linux",
    "macos",
  ] },
  { full = "ubi:jdx/usage", platforms = [
    "linux",
    "macos",
  ] },
  { full = "asdf:mise-plugins/mise-usage", platforms = [
    "linux",
    "macos",
  ] },
  "cargo:usage-cli",
]
description = "A specification for CLIs"
os = ["linux", "macos", "freebsd"]
test = ["usage --version", "usage-cli {{version}}"]

[tools.usql]
backends = ["aqua:xo/usql", "asdf:itspngu/asdf-usql"]
description = "Universal command-line interface for SQL databases"

[tools.uv]
backends = [
  "aqua:astral-sh/uv",
  "ubi:astral-sh/uv",
  "asdf:asdf-community/asdf-uv",
  "pipx:uv",
]
description = "An extremely fast Python package installer and resolver, written in Rust"
test = ["uv --version", "uv {{version}}"]

[tools.v]
backends = ["asdf:mise-plugins/mise-v"]
description = "V - https://vlang.io"

[tools.vacuum]
backends = ["aqua:daveshanley/vacuum"]
description = "vacuum is the worlds fastest OpenAPI 3, OpenAPI 2 / Swagger linter and quality analysis tool. Built in go, it tears through API specs faster than you can think. vacuum is compatible with Spectral rulesets and generates compatible reports"
test = ["vacuum version", "{{version}}"]

[tools.vale]
backends = ["aqua:errata-ai/vale", "asdf:pdemagny/asdf-vale"]
description = ":pencil: A markup-aware linter for prose built with speed and extensibility in mind"

[tools.vals]
backends = ["aqua:helmfile/vals", "asdf:dex4er/asdf-vals"]
description = "Helm-like configuration values loader with support for various sources"

[tools.vault]
backends = ["aqua:hashicorp/vault", "asdf:mise-plugins/mise-hashicorp"]
description = "A tool for secrets management, encryption as a service, and privileged access management"
test = ["vault version", "Vault v{{version}}"]

[tools.vcluster]
backends = [
  "aqua:loft-sh/vcluster",
  "asdf:https://gitlab.com/wt0f/asdf-vcluster",
]
description = "vCluster - Create fully functional virtual Kubernetes clusters - Each vcluster runs inside a namespace of the underlying k8s cluster. It's cheaper than creating separate full-blown clusters and it offers better multi-tenancy and isolation than regular namespaces"

[tools.velad]
backends = ["github:kubevela/velad", "asdf:mise-plugins/mise-velad"]
description = "Lightweight KubeVela that runs as Daemon in single node with high availability"
test = ["velad version", "Version: v{{version}}"]

[tools.velero]
backends = ["aqua:vmware-tanzu/velero", "asdf:looztra/asdf-velero"]
description = "Backup and migrate Kubernetes applications and their persistent volumes"

[tools.vendir]
backends = ["aqua:carvel-dev/vendir", "asdf:vmware-tanzu/asdf-carvel"]
description = "Easy way to vendor portions of git repos, github releases, helm charts, docker image contents, etc. declaratively"

[tools.venom]
backends = ["aqua:ovh/venom", "asdf:aabouzaid/asdf-venom"]
description = "Manage and run your integration tests with efficiency - Venom run executors (script, HTTP Request, web, imap, etc... ) and assertions"

[tools.vespa-cli]
backends = ["github:vespa-engine/vespa"]
description = "The command-line tool for Vespa.ai."
test = ["vespa version", "Vespa CLI version {{version}}"]

[tools.vfox]
backends = ["aqua:version-fox/vfox", "ubi:version-fox/vfox"]
description = "A cross-platform and extendable version manager with support for Java, Node.js, Flutter, .Net & more"
test = ["vfox --version", "vfox version {{version}}"]

[tools.vhs]
backends = ["aqua:charmbracelet/vhs", "asdf:chessmango/asdf-vhs"]
description = "Your CLI home video recorder"

[tools.victoria-metrics]
backends = ["aqua:VictoriaMetrics/VictoriaMetrics/victoria-metrics"]
description = "VictoriaMetrics: fast, cost-effective monitoring solution and time series database"

[tools.viddy]
backends = ["aqua:sachaos/viddy", "asdf:ryodocx/asdf-viddy"]
description = "A modern watch command. Time machine and pager etc"

[tools.vim]
backends = ["asdf:mise-plugins/mise-vim"]
description = "Vim is an advanced text editor that seeks to provide the power of the de-facto Unix editor 'Vi', with a more complete feature set. It's useful whether you're already using vi or using a different editor"

[tools.vivid]
backends = ["aqua:sharkdp/vivid", "ubi:sharkdp/vivid", "cargo:vivid"]
description = "A themeable LS_COLORS generator with a rich filetype datebase"
test = ["vivid --version", "vivid {{version}}"]

[tools.vlang]
backends = ["vfox:mise-plugins/vfox-vlang"]
description = "The V Programming Language. Simple, fast, safe, compiled. For developing maintainable software"

[tools.vlt]
backends = ["asdf:mise-plugins/mise-hashicorp"]
description = "vault (old version)"

[tools.vultr]
aliases = ["vultr-cli"]
backends = ["github:vultr/vultr-cli", "asdf:ikuradon/asdf-vultr-cli"]
description = "Official command line tool for Vultr services"
test = ["vultr-cli version", "Vultr-CLI v{{version}}"]

[tools.wait-for-gh-rate-limit]
backends = ["github:jdx/wait-for-gh-rate-limit"]
description = "CLI to wait for github rate limits to reset if they are expired"

[tools.wash]
backends = ["aqua:wasmCloud/wasmCloud/wash"]
description = "wasmCloud Shell (wash)"
test = ["wash --version | head -n1 | awk '{print $2}'", "v{{version}}"]

[tools.wasi-sdk]
backends = ["asdf:mise-plugins/mise-wasi-sdk"]
description = "WASI-enabled WebAssembly C/C++ toolchain"

[tools.wasm3]
backends = ["asdf:mise-plugins/mise-wasm3"]
description = "A fast WebAssembly interpreter and the most universal WASM runtime"

[tools.wasm4]
backends = [
  "aqua:aduros/wasm4",
  "ubi:aduros/wasm4[exe=w4]",
  "asdf:jtakakura/asdf-wasm4",
]
description = "Build retro games using WebAssembly for a fantasy console"
test = ["w4 --version", "{{version}}"]

[tools.wasmer]
backends = ["aqua:wasmerio/wasmer", "asdf:tachyonicbytes/asdf-wasmer"]
description = "The leading WebAssembly Runtime supporting WASI and Emscripten"

[tools.wasmtime]
backends = [
  "aqua:bytecodealliance/wasmtime",
  "asdf:tachyonicbytes/asdf-wasmtime",
]
description = "A lightweight WebAssembly runtime that is fast, secure, and standards-compliant"

[tools.watchexec]
backends = [
  "aqua:watchexec/watchexec",
  "ubi:watchexec/watchexec",
  "cargo:watchexec-cli",
]
description = "Executes commands in response to file modifications"
test = ["watchexec --version", "watchexec {{version}}"]

[tools.waypoint]
backends = ["aqua:hashicorp/waypoint", "asdf:mise-plugins/mise-hashicorp"]
description = "A tool to build, deploy, and release any application on any platform"

[tools.weave-gitops]
backends = [
  "github:weaveworks/weave-gitops[exe=gitops]",
  "asdf:deas/asdf-weave-gitops",
]
description = "Command line utility for managing Kubernetes applications via GitOps"

[tools.websocat]
backends = [
  "aqua:vi/websocat",
  "asdf:bdellegrazie/asdf-websocat",
  "cargo:websocat",
]
description = "Command-line client for WebSockets, like netcat (or curl) for ws:// with advanced socat-like functions"

[tools.werf]
backends = ["aqua:werf/werf"]
description = "A solution for implementing efficient and consistent software delivery to Kubernetes facilitating best practices"
test = ["werf version", "v{{version}}"]

[tools.wren]
aliases = ["wren-cli"]
backends = [
  "aqua:wren-lang/wren-cli",
  "ubi:wren-lang/wren-cli[exe=wren_cli]",
  "asdf:jtakakura/asdf-wren-cli",
]
description = "A command line tool for the Wren programming language"
test = ["wren_cli --version", "wren {{version}}"]

[tools.wrangler]
backends = ["npm:wrangler"]
description = "A command line tool for building Cloudflare Workers"
test = ["wrangler --version", "{{version}}"]

[tools.wrk]
backends = ["asdf:mise-plugins/mise-wrk"]
description = "Modern HTTP benchmarking tool"

[tools.wtfutil]
backends = ["aqua:wtfutil/wtf", "asdf:NeoHsu/asdf-wtfutil"]
description = "WTF is the personal information dashboard for your terminal"
test = ["wtfutil --version", "WTF v{{version}}"]

[tools.xc]
backends = ["aqua:joerdav/xc", "asdf:airtonix/asdf-xc"]
description = "Markdown defined task runner"

[tools.xcbeautify]
backends = [
  "aqua:cpisciotta/xcbeautify",
  "ubi:cpisciotta/xcbeautify",
  "asdf:mise-plugins/asdf-xcbeautify",
]
description = "A little beautifier tool for xcodebuild"
test = ["which xcbeautify", "xcbeautify"]

[tools.xchtmlreport]
backends = ["asdf:mise-plugins/mise-xchtmlreport"]
description = "Xcode-like HTML report for Unit and UI Tests"

[tools.xcodegen]
backends = ["asdf:mise-plugins/mise-xcodegen"]
description = "A Swift command line tool for generating your Xcode project"

[tools.xcodes]
backends = ["aqua:XcodesOrg/xcodes"]
description = "The best command-line tool to install and switch between multiple versions of Xcode"
os = ["macos"]
test = ["xcodes version", "{{version}}"]

[tools.xcresultparser]
backends = ["asdf:mise-plugins/mise-xcresultparser"]
description = "Parse the binary xcresult bundle from Xcode builds and testruns"

[tools.xcsift]
backends = ["github:ldomaradzki/xcsift"]
description = "Swift tool to parse and format xcodebuild output for coding agents"
os = ["macos"]
test = ["xcsift --version", "{{version}}"]

[tools.xh]
backends = [
  "aqua:ducaale/xh",
  "ubi:ducaale/xh",
  "asdf:NeoHsu/asdf-xh",
  "cargo:xh",
]
description = "Friendly and fast tool for sending HTTP requests"
test = ["xh -V", "xh {{version}}"]

[tools.xxh]
backends = ["pipx:xxh-xxh"]
description = "🚀 Bring your favorite shell wherever you go through the ssh. Xonsh shell, fish, zsh, osquery and so on."
test = ["xxh --version", "xxh/{{version}}"]

[tools.yadm]
backends = ["asdf:mise-plugins/mise-yadm"]
description = "Yet Another Dotfiles Manager"

[tools.yamlfmt]
backends = [
  "aqua:google/yamlfmt",
  "ubi:google/yamlfmt",
  "asdf:mise-plugins/asdf-yamlfmt",
  "go:github.com/google/yamlfmt/cmd/yamlfmt",
]
description = "An extensible command line tool or library to format yaml files"
test = ["yamlfmt --version", "yamlfmt {{version}}"]

[tools.yamllint]
backends = ["pipx:yamllint", "asdf:ericcornelissen/asdf-yamllint"]
description = "A linter for YAML files"
test = ["yamllint --version", "yamllint {{version}}"]

[tools.yamlscript]
backends = [
  "aqua:yaml/yamlscript",
  "ubi:yaml/yamlscript[matching_regex=^ys,extract_all=true]",
  "asdf:mise-plugins/mise-yamlscript",
]
description = "YS — YAML Done Wisely"
test = ["ys --version", "{{version}}"]

[tools.yarn]
backends = [
  "vfox:mise-plugins/vfox-yarn",
  "asdf:mise-plugins/mise-yarn",
  "aqua:yarnpkg/berry",
  "npm:@yarnpkg/cli-dist",
]
description = "Yarn is a package manager that doubles down as project manager. Whether you work on simple projects or industry monorepos, whether you're an open source developer or an enterprise user, Yarn has your back"
test = ["yarn --version", "{{version}}"]

[tools.yay]
backends = ["asdf:mise-plugins/mise-yay"]
description = "Yet another Yogurt - An AUR Helper written in Go"

[tools.yazi]
backends = ["aqua:sxyazi/yazi", "cargo:yazi-fm"]
description = "Blazing fast terminal file manager written in Rust, based on async I/O"
test = ["yazi --version", "Yazi {{version}}"]

[tools.yj]
backends = ["aqua:sclevine/yj", "ubi:sclevine/yj", "asdf:ryodocx/asdf-yj"]
description = "CLI - Convert between YAML, TOML, JSON, and HCL. Preserves map order"
test = ["yj -v", "v{{version}}"]

[tools.yor]
backends = ["aqua:bridgecrewio/yor", "asdf:ordinaryexperts/asdf-yor"]
description = "Extensible auto-tagger for your IaC files. The ultimate way to link entities in the cloud back to the codified resource which created it"
test = ["yor --version", "yor version {{version}}"]

[tools.youtube-dl]
backends = [
  "aqua:ytdl-org/ytdl-nightly",
  "ubi:ytdl-org/ytdl-nightly[matching_regex=^youtube-dl$,rename_exe=youtube-dl]",
  "asdf:mise-plugins/mise-youtube-dl",
]
description = "Command-line program to download videos from YouTube.com and other video sites"
test = ["youtube-dl --version", "{{version}}"]

[tools.yq]
backends = [
  "aqua:mikefarah/yq",
  "ubi:mikefarah/yq",
  "asdf:sudermanjr/asdf-yq",
  "go:github.com/mikefarah/yq/v4",
]
description = "yq is a portable command-line YAML processor"
test = ["yq --version", "version v{{version}}"]

[tools.yt-dlp]
backends = ["github:yt-dlp/yt-dlp[rename_exe=yt-dlp]", "asdf:duhow/asdf-yt-dlp"]
description = "A feature-rich command-line audio/video downloader"
test = ["yt-dlp --version", "{{version}}"]

[tools.ytt]
backends = ["aqua:carvel-dev/ytt", "asdf:vmware-tanzu/asdf-carvel"]
description = "YAML templating tool that works on YAML structure instead of text"
test = ["ytt --version", "ytt version {{version}}"]

[tools.zbctl]
backends = ["npm:zbctl"]
description = "zbctl is a command line interface designed to create and read resources inside zeebe broker."
test = ["zbctl version", "zbctl {{version}}"]

[tools.zellij]
backends = [
  "aqua:zellij-org/zellij",
  "ubi:zellij-org/zellij",
  "asdf:chessmango/asdf-zellij",
  "cargo:zellij",
]
description = "A terminal workspace with batteries included"
test = ["zellij --version", "zellij {{version}}"]

[tools.zephyr]
backends = [
  "aqua:MaybeJustJames/zephyr",
  "ubi:MaybeJustJames/zephyr",
  "asdf:nsaunders/asdf-zephyr",
]
description = "Tree shaking breeze for PureScript CoreFn AST"
test = ["zephyr --version", "{{version}}"]

[tools.zig]
backends = ["core:zig"]
description = "Zig is a general-purpose programming language and toolchain for maintaining robust, optimal and reusable software"

[tools.fnox]
backends = ["github:jdx/fnox"]
description = "Fort Knox for your secrets"
test = ["fnox --version", "fnox {{version}}"]

[tools.zigmod]
backends = ["github:nektro/zigmod", "asdf:mise-plugins/asdf-zigmod"]
description = "A package manager for the Zig programming language"
test = ["zigmod version", "{{version}}"]

[tools.zizmor]
backends = ["aqua:zizmorcore/zizmor", "ubi:zizmorcore/zizmor", "cargo:zizmor"]
description = "Static analysis for GitHub Actions"
test = ["zizmor --version", "zizmor {{version}}"]

[tools.zls]
backends = ["aqua:zigtools/zls", "ubi:zigtools/zls"]
description = "A Zig language server supporting Zig developers with features like autocomplete and goto definition"
test = ["zls --version", "{{version}}"]

[tools.zola]
backends = ["aqua:getzola/zola", "ubi:getzola/zola", "asdf:salasrod/asdf-zola"]
description = "A fast static site generator in a single binary with everything built-in. https://www.getzola.org"
test = ["zola --version", "zola {{version}}"]

[tools.zoxide]
backends = ["aqua:ajeetdsouza/zoxide", "ubi:ajeetdsouza/zoxide", "cargo:zoxide"]
description = "A smarter cd command. Supports all major shells"
test = ["zoxide --version", "zoxide {{version}}"]

[tools.zprint]
backends = ["asdf:mise-plugins/mise-zprint"]
description = "Executables, uberjar, and library to beautifully format Clojure and Clojurescript source code and s-expressions"
