NO-INSTALL-LINTERS : run linters / formatters / type-checkers without installing them

Overview

This skill teaches how to use all major "run it without pre-installing it" executors across ecosystems to lint, format, and type-check code without adding project dependencies or global installs. Supported ecosystems:

• •Node.js: bunx, npx/npm exec, pnpm dlx, yarn dlx, deno run npm:...
• •Python: uvx (uv tool run), pipx run
• •Deno built-ins: deno lint, deno fmt, deno check (no package install)
• •Containers: docker run --rm ...
• •Windows PowerShell module one-offs: Save-Module + Import-Module (temp path)

Most of these download + cache somewhere (global cache, temp dir, tool cache), but they don't require you to pre-install the tool as a project dependency or global app.

Prerequisites

• •At least one "no-install" runner must be available on the system: uvx, bunx, npx, pnpm, yarn, deno, docker, or pwsh
• •For Python tools (ruff, black, mypy, pyright, etc.): uvx (from uv) or pipx must be installed
• •For Node.js tools (eslint, prettier, biome, etc.): bunx, npx, pnpm, or yarn must be installed
• •For container-based tools: Docker must be installed and running
• •The smart_exec.py script (included in scripts/) auto-detects available runners

Instructions

1. •Identify the file type you need to lint or format (Python, JS/TS, CSS, YAML, Dockerfile, etc.)
2. •Consult the runner table below to find which tool handles that file type
3. •Pick the best available runner from the columns marked [OK] for your tool
4. •Run the command using the syntax shown in the table cell
5. •Alternatively, use smart_exec.py run <tool> [args] to auto-detect the best runner

All major "execute without installing" runners

CHOOSE THE BEST RUNNER. Here is a table with every tools + every "run without installing" executers

Legend

• •[OK] = practical, common, and works
• •[~] = works, but usually needs extra flags / awkward / less common
• •[-] = not applicable

Commands are examples; replace . / globs / filenames as needed.

Notes on quirks and peculiarities of the tools

npm-package-json-lint: command name vs package name

The package name is npm-package-json-lint, but the CLI command documented by the project is typically:

npmPkgJsonLint .

When you run via bunx/npx/pnpm dlx/yarn dlx, you can reliably do:

npx --yes npm-package-json-lint -- npmPkgJsonLint .
# or:
pnpm dlx npm-package-json-lint npmPkgJsonLint .

(If bunx npm-package-json-lint . works in your environment, keep it -- but the npmPkgJsonLint form is the official CLI name.)

YAML: Node vs Python options

• •yaml-lint exists on npm (works with bunx/npx/pnpm dlx/yarn dlx/deno npm:).
• •yamllint is a common Python YAML linter (works with uvx/pipx run).

"No install" does not mean "no download"

Even "instant-run" tools download packages/binaries to caches (npm cache, uv cache, pipx venv cache, Docker image cache, etc.). The goal here is: no global install and no project dependency changes.

PowerShell "npx-like" one-off runner template (Windows)

This is the most reliable "no-install" approach for PowerShell-module-based linters:

$dir = Join-Path $env:TEMP ("psmods_" + [guid]::NewGuid().ToString("n"))
Save-Module -Name PSScriptAnalyzer -Path $dir -Force

# Resolve the module path (works across versions):
$psd1 = Get-ChildItem -Path (Join-Path $dir "PSScriptAnalyzer") -Recurse -Filter "PSScriptAnalyzer.psd1" |
  Select-Object -First 1 -ExpandProperty FullName
Import-Module $psd1 -Force

Invoke-ScriptAnalyzer -Path . -Recurse

Save-Module saves to a path and isn't installed into system module paths.

Provided script to automate the choice of runners

For common tools, you can use the provided python script to automate the choice of runners from those available on the user system. Run it from the scripts subdir inside this skill directory:

./scripts/smart_exec.py

smart_exec.py is a "smart runner" that:

• •Detects available executors on this machine (uvx/uv, pipx, bunx/bun x, pnpm dlx, npx, npm exec, yarn dlx, deno, docker, pwsh/powershell)
• •Chooses the best executor for a requested tool (linter/formatter/type-checker/etc.)
• •Executes it via subprocess, preserving exit code

Notes:

• •Uses Bun's documented -p/--package support when binary name != package name (e.g. @stoplight/spectral -> spectral). (see: https://bun.com/docs/pm/bunx)
• •Uses npm's recommended npm exec --package=... -- <cmd> form. (see: https://docs.npmjs.com/cli/v8/commands/npm-exec)
• •Supports Deno built-ins (deno lint/fmt/check) as truly "no install" tools, plus deno run npm: for npm CLIs
• •Support PowerShell "download to temp + import" execution for module-based tools (e.g. PSScriptAnalyzer)
• •Support special commands: executors, db, and which subcommands + JSON output + dry-run mode
• •"No install" here means: no project dependency changes and no global install of the tool itself. Executors may still download/cache packages/binaries (npm cache, uv cache, docker images, etc.).
• •Heuristics are adjustable: edit TOOL_DB and PRIORITY.

Usage Examples:

  smart_exec.py executors
  smart_exec.py db
  smart_exec.py which ruff check .
  smart_exec.py run ruff check .
  smart_exec.py run eslint .
  smart_exec.py run prettier --check .
  smart_exec.py run npm-package-json-lint .
  smart_exec.py run deno-fmt -- --check
  smart_exec.py run Invoke-ScriptAnalyzer -- -Path . -Recurse

Output

All linters, formatters, and type-checkers produce output on stdout/stderr with a non-zero exit code on failure. Typical output patterns:

• •Linters (eslint, ruff check, shellcheck): list of diagnostics with file, line number, rule ID, and message. Exit code 1 means issues found.
• •Formatters (prettier --check, ruff format --check, biome check): list of files that would be reformatted. Exit code 1 means files need formatting.
• •Type checkers (mypy, pyright, tsc --noEmit): list of type errors with file, line, and description. Exit code 1 means type errors found.
• •smart_exec.py: preserves the tool's original exit code and output. With --json flag, wraps the result in a JSON envelope containing executor, command, exit_code, and output.

Error Handling

• •If no runner is available for the requested tool, smart_exec.py exits with an error message listing which runners it looked for and why each was unavailable.
• •If the tool package does not exist in the registry (npm, PyPI), the runner itself will print a "not found" error. Check the package name in the runner table above.
• •If a runner times out or hangs, kill the process and try a different runner from the table.
• •If bunx fails with permission errors, try npx --yes instead (some systems restrict bun's cache directory).
• •If uvx cannot resolve a tool, ensure uv is version 0.4+ (older versions lack uvx alias support).
• •If docker run fails, check that the Docker daemon is running (docker info) and that the image exists.

Examples

Example 1: Lint Python files with ruff (no install)

uvx ruff@latest check .

Example 2: Format JavaScript with prettier (no install)

bunx prettier --write "src/**/*.js"

Example 3: Type-check TypeScript (no install)

npx --yes tsc --noEmit -p tsconfig.json

Example 4: Lint a Dockerfile with hadolint via docker

docker run --rm -i hadolint/hadolint < Dockerfile

Example 5: Use smart_exec.py to auto-pick the runner

./scripts/smart_exec.py run ruff check .
./scripts/smart_exec.py run eslint src/
./scripts/smart_exec.py which prettier --check .

Example 6: Lint shell scripts with ShellCheck (no install)

npx --yes shellcheck script.sh

Workflow Checklist

Copy this checklist and track your progress when running a linter, formatter, or type-checker without installing it:

• • Identify the tool to run (e.g. ruff, eslint, prettier, mypy, shellcheck)
• • Determine the tool's ecosystem (Python, Node.js, Deno, native, container)
• • Check which runners are available on the system (uvx, bunx, npx, pnpm dlx, yarn dlx, deno, docker, pwsh)
• • Consult the runner table above to find the best runner for the tool
• • Run the tool using the chosen runner's syntax from the table
• • Alternatively, use smart_exec.py run <tool> [args] to auto-detect the best runner
• • Review the tool's output (diagnostics, formatting diffs, type errors)
• • Fix any reported issues in the source files
• • Re-run the tool to confirm all issues are resolved (exit code 0)

Resources

• •uvx is an alias of uv tool run: https://docs.astral.sh/uv/concepts/tools/
• •bunx: https://bun.com/docs/pm/bunx
• •npx / npm exec: https://docs.npmjs.com/cli/v8/commands/npx
• •pnpm dlx: https://pnpm.io/cli/dlx
• •yarn dlx: https://yarnpkg.com/cli/dlx
• •Deno lint/format: https://docs.deno.com/runtime/fundamentals/linting_and_formatting/
• •Save-Module (PowerShellGet): https://learn.microsoft.com/en-us/powershell/module/powershellget/save-module?view=powershellget-2.x