Browse recipes

Adds currently staged changes to the most recent commit and lets you edit its message, without creating a new commit.

Points an existing remote at a new URL, for example after a repository is renamed, transferred, or when switching between HTTPS and SSH.

Copies the changes of a single commit from another branch onto the current branch as a new commit, without merging the whole branch.

Creates an annotated tag marking the current commit as a release and pushes it to the remote so CI and collaborators can see it.

Creates a new branch from the current commit and switches to it, keeping any uncommitted changes in the working tree.

Deletes a fully merged local branch. Refuses to delete a branch whose commits are not reachable from the current branch, so no work is lost.

Removes a branch from the remote repository, typically after its pull request has merged. The local branch of the same name is untouched.

Throws away every uncommitted change in tracked files, returning the working tree to the state of the last commit.

Searches history for commits that added or removed a given string, showing when and where a line of code appeared or disappeared.

Overwrites a remote branch with rewritten local history using --force-with-lease, which refuses to clobber commits you have not seen.

Replays the current branch's commits on top of the latest default branch, producing a linear history and surfacing conflicts before merging.

Recreates a branch that was deleted locally by finding its last commit in the reflog and pointing a new branch at it.

Previews and then deletes untracked files and directories from the working tree, leaving tracked files and ignored files untouched.

Renames the branch you are on, both locally and on the remote: the new name is pushed and the old remote branch is removed.

Creates a new commit that undoes the changes of an earlier commit, without rewriting history — the safe way to undo on a shared branch.

Publishes the current local branch to the remote and links it to that remote branch, so future plain `git push`/`git pull` work without an explicit branch name.

Combines the last several commits on the current branch into a single commit, keeping all their changes but replacing the commit history.

Saves uncommitted changes (including untracked files) to the stash and cleans the working tree, so you can switch tasks without committing.

Removes a file from git tracking while keeping it on disk, and adds it to .gitignore so it is not accidentally committed again.

Brings a fork's default branch up to date with the original repository by fetching upstream and fast-forwarding the local and fork branches.

Moves the current branch back one commit while keeping the removed commit's changes staged, so they can be amended or committed again.

Removes files from the staging area so they will not be part of the next commit, while leaving the changes intact in the working tree.

Archives the contents of a named Docker volume into a compressed tar file in the current directory, using a throwaway container. The volume is only read.

Builds a Docker image from the Dockerfile in the current directory and tags it, so it can be run locally or pushed to a registry.

Inspects Docker disk usage, then removes unused containers, networks, images, build cache, and anonymous volumes to reclaim local disk space.

Copies a file or directory from a container's filesystem to the host, for example to retrieve generated output or a config file for inspection. The container is not modified.

Reads a stopped container's exit code, out-of-memory flag, and final log lines to diagnose why it stopped, without restarting or modifying it.

Shows a container's full configuration — image, environment, mounts, network settings, and restart policy — without changing anything.

Shows every container on the local Docker host, including stopped ones, so you can see what is running, what exited, and which ports are published.

Starts an interactive shell in a running container so you can inspect files and processes from the inside. The container itself keeps running unchanged.

Downloads an exact image tag from a registry so the version running locally is explicit and reproducible, instead of whatever latest points to.

Deletes a specific image from the local Docker host to reclaim disk space. Containers and other images are not touched.

Stops and starts a container in place, keeping its configuration, network settings, and volumes. Useful to recover a hung service or apply an updated file mounted from the host.

Extracts a tar backup created by the volume backup recipe into a named volume, overwriting files that also exist in the archive. Used to recover data or move a volume between hosts.

Starts a detached container from an image and publishes one of its ports on the host, so services inside the container are reachable from localhost.

Takes a one-shot snapshot of CPU, memory, network, and disk I/O for all running containers to identify which one is consuming resources.

Starts all services defined in the compose file of the current directory in the background, creating containers, networks, and volumes as needed.

Starts Docker when commands fail with "Cannot connect to the Docker daemon", using Docker Desktop on macOS and Windows or systemd on Linux.

Gracefully stops a running container and deletes it, discarding its writable layer. The image and any named volumes it used are kept.

Stops all services of the compose stack in the current directory and removes their containers and networks. Named volumes and images are preserved, so data survives and the stack can be started again.

Applies a registry-qualified tag to a local image and uploads it, making the image available to other machines and deploy environments.

Shows the recent log output of a container and then follows new lines live, without changing the container or its logging configuration.

Renames every file with one extension to another (for example .jpeg to .jpg) in a directory, previewing the changes before applying them.

Sets Unix permission bits on a file or directory tree — for example locking an SSH key to 600 or opening a shared directory to a group.

Transfers ownership of a path to another user — typically after copying files as root or fixing a web server's document root.

Shows how much disk space is free overall and which immediate subdirectories consume the most, to find where space is going.

Shows which files differ, and which exist only on one side, between two directory trees — for checking a backup, a deploy, or a copy operation.

Packs a directory into a single compressed archive for backup or transfer — tar.gz on macOS/Linux, zip on Windows.

Creates a symlink so a file or directory is reachable from another path — commonly used for dotfiles, shared configs, and versioned tool installs.

Permanently removes a directory tree after inspecting what it contains — the careful version of rm -rf.

Unpacks a tar.gz or zip archive into a target directory, first listing its contents so you know what will be written where.

Detects files with identical content by hashing them, so you can reclaim space from repeated downloads, copies, and exports.

Searches a directory tree for files whose names match a glob pattern, such as every "*.log" file or a misplaced config file.

Lists files changed within the last N minutes — useful for spotting what an installer touched, which logs are active, or what you just edited.

Locates the files consuming the most disk space under a directory, so you can decide what to archive or delete when space runs low.

Streams new lines appended to a file in real time — the standard way to watch a log while reproducing a bug or monitoring a running job.

Adds execute permission to a script or binary so it can be run directly, the usual fix for "permission denied" on a freshly written script.

Recursively searches file contents for a string, showing each matching file and line — the standard way to find where something is defined, configured, or logged.

Splits a large file into fixed-size chunks that fit upload or attachment limits, and shows how to reassemble them into the original file.

Mirrors a source directory to a destination with rsync (or robocopy on Windows), copying only what changed — the standard local backup move.

Queries several public resolvers directly for the same record, so you can see whether a recent DNS change has propagated or is still cached.

Downloads a file to a chosen path, following redirects, and resumes from where it stopped if the transfer is interrupted — useful for large files on unreliable connections.

Identifies the local process listening on a TCP port without changing the process or network configuration.

Clears the operating system's DNS resolver cache so stale records are discarded and the next lookup fetches fresh answers, typically after a DNS change or when a site resolves to an outdated address.

Shows the subject, issuer, and validity dates of the TLS certificate a server presents, useful for diagnosing expiry and hostname-mismatch errors.

Frees a TCP port by stopping the process listening on it, after first showing which process holds the port so you do not kill the wrong one.

Shows every TCP port with a listening process on the local machine, with the owning process for each, without changing any network state.

Queries DNS for a specific record type on a domain, useful for verifying DNS configuration, mail setup, and domain ownership records.

Breaks down how long an HTTP request spends in DNS lookup, TCP connect, TLS handshake, and time to first byte, to pinpoint where latency comes from.

Sends a fixed number of ICMP echo requests to a host to confirm basic network reachability and measure round-trip latency.

Releases the current DHCP lease and requests a new one, which briefly drops connectivity — the standard fix for a stale or self-assigned (169.254.x.x) address after switching networks.

Lists currently established TCP connections and the processes that own them, useful for seeing what a machine is talking to right now.

Lists the IP addresses assigned to this machine's network interfaces, useful for reaching the machine from another device on the same network.

Displays the kernel routing table, including the default gateway, useful for diagnosing why traffic to a network takes an unexpected path or fails.

Prints the public IP address this machine appears as on the internet, useful for configuring firewall allowlists or debugging NAT and VPN setups.

Sends a request to a URL and prints the HTTP status code, following redirects, to quickly confirm whether an endpoint is up and healthy.

Checks whether a TCP port on a remote host accepts connections, useful for diagnosing firewalls, security groups, and whether a service is up.

Shows every network hop between this machine and a remote host, useful for locating where latency or packet loss is introduced along the path.

Reviews npm audit findings, then installs advisory fixes that remain within declared dependency ranges without forcing semver-major upgrades.

Checks the resolved dependency tree against npm security advisories without changing installed packages or package metadata.

Compares installed and declared dependency versions with registry releases without modifying package.json, the lockfile, or node_modules.

Reports the active Node.js and npm versions without changing the runtime or project, so you can confirm that local tooling meets project requirements.

Verifies the npm cache and, if problems persist, wipes it entirely so corrupted tarballs and metadata are re-downloaded on the next install.

Inspects the current package metadata, then resolves dependency versions into package-lock.json without installing packages into node_modules.

Starts a script under the V8 inspector, paused on the first line, so breakpoints can be set from Chrome DevTools or an editor before any code runs.

Inspects the dependency tree, then moves compatible packages higher in the tree to reduce duplicate installations and update the lockfile as needed.

Traces the dependency chain that caused a package to be installed without changing the lockfile or node_modules.

Raises the V8 old-space heap ceiling for Node.js processes in the current shell, fixing "JavaScript heap out of memory" crashes in large builds.

Checks for existing package metadata, then creates a package.json with npm defaults so the directory can manage scripts and dependencies.

Reads registry metadata for a package before installation, including its latest version, license, dependencies, and distribution integrity value.

Reads the package engine declarations without installing dependencies or changing files, so you can compare them with the active runtime.

Inspects the current declaration, then installs a package for development use and records it under devDependencies with its resolved lockfile entry.

Inspects the current declaration, then installs a package as a runtime dependency and records the resolved version in package metadata and the lockfile.

Symlinks a locally checked-out package into a consuming project so changes are picked up immediately, without publishing to a registry.

Lists packages installed at the project root without changing package metadata or installed modules.

Shows every package installed globally for the active Node.js version and where they live on disk, useful before upgrades or when a CLI is missing.

Shows which files npm would include in a published package archive without creating a tarball, publishing anything, or running package lifecycle scripts.

Identifies packages not declared by the project, then removes them from node_modules while preserving declared production and development dependencies.

Recompiles installed native addons against the active Node.js version, fixing NODE_MODULE_VERSION mismatch errors after a Node.js upgrade.

Verifies that a package lock is present, then removes the existing dependency tree and installs exactly the versions recorded in package-lock.json.

Lists the scripts declared by a project, then runs one through npm with the project-local binaries and environment available on the script path.

Finds Node.js processes, identifies the runaway one by CPU usage and command line, and stops it — gracefully first, forcefully only if needed.

Installs (if needed) and activates a specific Node.js version using nvm, so the shell matches the version a project expects.

Records the installed version, then removes a direct dependency from node_modules, package.json, and the package lock.

Upgrades one package to its latest published version, updating both package.json and the lockfile, after checking how far behind it is.

Inspects available updates, then refreshes installed packages and the lockfile to the newest versions allowed by package.json.

Executes a SQL migration file against the database within a transaction so the entire change succeeds or rolls back atomically.

Opens an interactive psql session to a named database so you can run queries, inspect schema, or manage objects directly.

Dumps an entire PostgreSQL database to a compressed SQL file so you can restore it later or archive it before making risky changes.

Creates a new, empty PostgreSQL database owned by the current user, ready for schema and data.

Prints the column names, types, nullability, and defaults for a table so you understand its schema before writing queries or modifications.

Permanently removes a database and everything inside it — tables, views, functions, and data — after first confirming what will be lost.

Runs a read-only SQL query (SELECT, EXPLAIN, SHOW, or WITH) against the connected database and prints the result set, so you can inspect data or test a query before embedding it in application code. Write and DDL statements are rejected before the query is ever substituted into a command.

Writes the contents of a table to a CSV file on the server so you can share data with other tools or archive a snapshot.

Loads data from a CSV file into an existing table so you can seed data, migrate from another system, or restore an archived snapshot.

Shows every database accessible to the current connection so you can confirm which databases exist before connecting or operating on one.

Shows every index defined on a table including column coverage, type, and size so you can evaluate query performance and index overhead.

Shows every table in the connected database, including schema-qualified names, so you can survey the data model before writing queries or performing schema changes.

Loads a PostgreSQL dump file into a database, reconstructing schema and data from a previous backup.

Lists every connection currently open on the server with the connected user, database, application name, client address, and query state so you can identify idle sessions or pending queries.

Displays every query currently executing on the server with its duration, so you can spot long-running or blocked queries that may need attention.

Reports the total disk space used by a table including its indexes and TOAST data, so you can identify which tables consume the most storage.

Generates the full DDL statement that would recreate the table, including columns, defaults, constraints, indexes, and triggers.

Reports the total on-disk size of a database so you can monitor storage growth and plan capacity.

Forcefully closes a specific backend process, freeing locks and resources held by a stuck or idle session.

Reclaims storage occupied by dead rows and refreshes query planner statistics so the optimizer makes better decisions.