system
stringclasses 1
value | command
stringlengths 1
20
| response
stringlengths 101
1.77k
|
|---|---|---|
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-revert | # git revert
> Create new commits which reverse the effect of earlier ones. More
> information: https://git-scm.com/docs/git-revert.
* Revert the most recent commit:
`git revert {{HEAD}}`
* Revert the 5th last commit:
`git revert HEAD~{{4}}`
* Revert a specific commit:
`git revert {{0c01a9}}`
* Revert multiple commits:
`git revert {{branch_name~5..branch_name~2}}`
* Don't create new commits, just change the working tree:
`git revert -n {{0c01a9..9a1743}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | ldapsearch | # ldapsearch
> Query an LDAP directory. More information: https://docs.ldap.com/ldap-
> sdk/docs/tool-usages/ldapsearch.html.
* Query an LDAP server for all items that are a member of the given group and return the object's displayName value:
`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}} -b
{{base_ou}} '{{memberOf=group1}}' displayName`
* Query an LDAP server with a no-newline password file for all items that are a member of the given group and return the object's displayName value:
`ldapsearch -D '{{admin_DN}}' -y '{{password_file}}' -h {{ldap_host}} -b
{{base_ou}} '{{memberOf=group1}}' displayName`
* Return 5 items that match the given filter:
`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}} -b
{{base_ou}} '{{memberOf=group1}}' -z 5 displayName`
* Wait up to 7 seconds for a response:
`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}} -b
{{base_ou}} '{{memberOf=group1}}' -l 7 displayName`
* Invert the filter:
`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}} -b
{{base_ou}} '(!(memberOf={{group1}}))' displayName`
* Return all items that are part of multiple groups, returning the display name for each item:
`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}}
'(&({{memberOf=group1}})({{memberOf=group2}})({{memberOf=group3}}))'
"displayName"`
* Return all items that are members of at least 1 of the specified groups:
`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}}
'(|({{memberOf=group1}})({{memberOf=group1}})({{memberOf=group3}}))'
displayName`
* Combine multiple boolean logic filters:
`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}}
'(&({{memberOf=group1}})({{memberOf=group2}})(!({{memberOf=group3}})))'
displayName` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-repack | # git repack
> Pack unpacked objects in a Git repository. More information: https://git-
> scm.com/docs/git-repack.
* Pack unpacked objects in the current directory:
`git repack`
* Also remove redundant objects after packing:
`git repack -d` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-bisect | # git bisect
> Use binary search to find the commit that introduced a bug. Git
> automatically jumps back and forth in the commit graph to progressively
> narrow down the faulty commit. More information: https://git-
> scm.com/docs/git-bisect.
* Start a bisect session on a commit range bounded by a known buggy commit, and a known clean (typically older) one:
`git bisect start {{bad_commit}} {{good_commit}}`
* For each commit that `git bisect` selects, mark it as "bad" or "good" after testing it for the issue:
`git bisect {{good|bad}}`
* After `git bisect` pinpoints the faulty commit, end the bisect session and return to the previous branch:
`git bisect reset`
* Skip a commit during a bisect (e.g. one that fails the tests due to a different issue):
`git bisect skip`
* Display a log of what has been done so far:
`git bisect log` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-branch | # git branch
> Main Git command for working with branches. More information: https://git-
> scm.com/docs/git-branch.
* List all branches (local and remote; the current branch is highlighted by `*`):
`git branch --all`
* List which branches include a specific Git commit in their history:
`git branch --all --contains {{commit_hash}}`
* Show the name of the current branch:
`git branch --show-current`
* Create new branch based on the current commit:
`git branch {{branch_name}}`
* Create new branch based on a specific commit:
`git branch {{branch_name}} {{commit_hash}}`
* Rename a branch (must not have it checked out to do this):
`git branch -m {{old_branch_name}} {{new_branch_name}}`
* Delete a local branch (must not have it checked out to do this):
`git branch -d {{branch_name}}`
* Delete a remote branch:
`git push {{remote_name}} --delete {{remote_branch_name}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-bundle | # git bundle
> Package objects and references into an archive. More information:
> https://git-scm.com/docs/git-bundle.
* Create a bundle file that contains all objects and references of a specific branch:
`git bundle create {{path/to/file.bundle}} {{branch_name}}`
* Create a bundle file of all branches:
`git bundle create {{path/to/file.bundle}} --all`
* Create a bundle file of the last 5 commits of the current branch:
`git bundle create {{path/to/file.bundle}} -{{5}} {{HEAD}}`
* Create a bundle file of the latest 7 days:
`git bundle create {{path/to/file.bundle}} --since={{7.days}} {{HEAD}}`
* Verify that a bundle file is valid and can be applied to the current repository:
`git bundle verify {{path/to/file.bundle}}`
* Print to `stdout` the list of references contained in a bundle:
`git bundle unbundle {{path/to/file.bundle}}`
* Unbundle a specific branch from a bundle file into the current repository:
`git pull {{path/to/file.bundle}} {{branch_name}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-remote | # git remote
> Manage set of tracked repositories ("remotes"). More information:
> https://git-scm.com/docs/git-remote.
* Show a list of existing remotes, their names and URL:
`git remote -v`
* Show information about a remote:
`git remote show {{remote_name}}`
* Add a remote:
`git remote add {{remote_name}} {{remote_url}}`
* Change the URL of a remote (use `--add` to keep the existing URL):
`git remote set-url {{remote_name}} {{new_url}}`
* Show the URL of a remote:
`git remote get-url {{remote_name}}`
* Remove a remote:
`git remote remove {{remote_name}}`
* Rename a remote:
`git remote rename {{old_name}} {{new_name}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | journalctl | # journalctl
> Query the systemd journal. More information: https://manned.org/journalctl.
* Show all messages with priority level 3 (errors) from this [b]oot:
`journalctl -b --priority={{3}}`
* Show all messages from last [b]oot:
`journalctl -b -1`
* Delete journal logs which are older than 2 days:
`journalctl --vacuum-time={{2d}}`
* [f]ollow new messages (like `tail -f` for traditional syslog):
`journalctl -f`
* Show all messages by a specific [u]nit:
`journalctl -u {{unit}}`
* Filter messages within a time range (either timestamp or placeholders like "yesterday"):
`journalctl --since {{now|today|yesterday|tomorrow}} --until {{YYYY-MM-DD
HH:MM:SS}}`
* Show all messages by a specific process:
`journalctl _PID={{pid}}`
* Show all messages by a specific executable:
`journalctl {{path/to/executable}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-cherry | # git cherry
> Find commits that have yet to be applied upstream. More information:
> https://git-scm.com/docs/git-cherry.
* Show commits (and their messages) with equivalent commits upstream:
`git cherry -v`
* Specify a different upstream and topic branch:
`git cherry {{origin}} {{topic}}`
* Limit commits to those within a given limit:
`git cherry {{origin}} {{topic}} {{base}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-daemon | # git daemon
> A really simple server for Git repositories. More information: https://git-
> scm.com/docs/git-daemon.
* Launch a Git daemon with a whitelisted set of directories:
`git daemon --export-all {{path/to/directory1}} {{path/to/directory2}}`
* Launch a Git daemon with a specific base directory and allow pulling from all sub-directories that look like Git repositories:
`git daemon --base-path={{path/to/directory}} --export-all --reuseaddr`
* Launch a Git daemon for the specified directory, verbosely printing log messages and allowing Git clients to write to it:
`git daemon {{path/to/directory}} --enable=receive-pack --informative-errors
--verbose` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-rebase | # git rebase
> Reapply commits from one branch on top of another branch. Commonly used to
> "move" an entire branch to another base, creating copies of the commits in
> the new location. More information: https://git-scm.com/docs/git-rebase.
* Rebase the current branch on top of another specified branch:
`git rebase {{new_base_branch}}`
* Start an interactive rebase, which allows the commits to be reordered, omitted, combined or modified:
`git rebase -i {{target_base_branch_or_commit_hash}}`
* Continue a rebase that was interrupted by a merge failure, after editing conflicting files:
`git rebase --continue`
* Continue a rebase that was paused due to merge conflicts, by skipping the conflicted commit:
`git rebase --skip`
* Abort a rebase in progress (e.g. if it is interrupted by a merge conflict):
`git rebase --abort`
* Move part of the current branch onto a new base, providing the old base to start from:
`git rebase --onto {{new_base}} {{old_base}}`
* Reapply the last 5 commits in-place, stopping to allow them to be reordered, omitted, combined or modified:
`git rebase -i {{HEAD~5}}`
* Auto-resolve any conflicts by favoring the working branch version (`theirs` keyword has reversed meaning in this case):
`git rebase -X theirs {{branch_name}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-commit | # git commit
> Commit files to the repository. More information: https://git-
> scm.com/docs/git-commit.
* Commit staged files to the repository with a message:
`git commit --message "{{message}}"`
* Commit staged files with a message read from a file:
`git commit --file {{path/to/commit_message_file}}`
* Auto stage all modified and deleted files and commit with a message:
`git commit --all --message "{{message}}"`
* Commit staged files and sign them with the specified GPG key (or the one defined in the config file if no argument is specified):
`git commit --gpg-sign {{key_id}} --message "{{message}}"`
* Update the last commit by adding the currently staged changes, changing the commit's hash:
`git commit --amend`
* Commit only specific (already staged) files:
`git commit {{path/to/file1}} {{path/to/file2}}`
* Create a commit, even if there are no staged files:
`git commit --message "{{message}}" --allow-empty` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-restore | # git restore
> Restore working tree files. Requires Git version 2.23+. See also `git
> checkout` and `git reset`. More information: https://git-scm.com/docs/git-
> restore.
* Restore an unstaged file to the version of the current commit (HEAD):
`git restore {{path/to/file}}`
* Restore an unstaged file to the version of a specific commit:
`git restore --source {{commit}} {{path/to/file}}`
* Discard all unstaged changes to tracked files:
`git restore :/`
* Unstage a file:
`git restore --staged {{path/to/file}}`
* Unstage all files:
`git restore --staged :/`
* Discard all changes to files, both staged and unstaged:
`git restore --worktree --staged :/`
* Interactively select sections of files to restore:
`git restore --patch` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-archive | # git archive
> Create an archive of files from a named tree. More information: https://git-
> scm.com/docs/git-archive.
* Create a tar archive from the contents of the current HEAD and print it to `stdout`:
`git archive --verbose HEAD`
* Create a zip archive from the current HEAD and print it to `stdout`:
`git archive --verbose --format=zip HEAD`
* Same as above, but write the zip archive to file:
`git archive --verbose --output={{path/to/file.zip}} HEAD`
* Create a tar archive from the contents of the latest commit on a specific branch:
`git archive --output={{path/to/file.tar}} {{branch_name}}`
* Create a tar archive from the contents of a specific directory:
`git archive --output={{path/to/file.tar}} HEAD:{{path/to/directory}}`
* Prepend a path to each file to archive it inside a specific directory:
`git archive --output={{path/to/file.tar}} --prefix={{path/to/prepend}}/ HEAD` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | ssh-keyscan | # ssh-keyscan
> Get the public ssh keys of remote hosts. More information:
> https://man.openbsd.org/ssh-keyscan.
* Retrieve all public ssh keys of a remote host:
`ssh-keyscan {{host}}`
* Retrieve all public ssh keys of a remote host listening on a specific port:
`ssh-keyscan -p {{port}} {{host}}`
* Retrieve certain types of public ssh keys of a remote host:
`ssh-keyscan -t {{rsa,dsa,ecdsa,ed25519}} {{host}}`
* Manually update the ssh known_hosts file with the fingerprint of a given host:
`ssh-keyscan -H {{host}} >> ~/.ssh/known_hosts` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-replace | # git replace
> Create, list, and delete refs to replace objects. More information:
> https://git-scm.com/docs/git-replace.
* Replace any commit with a different one, leaving other commits unchanged:
`git replace {{object}} {{replacement}}`
* Delete existing replace refs for the given objects:
`git replace --delete {{object}}`
* Edit an object’s content interactively:
`git replace --edit {{object}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-ls-tree | # git ls-tree
> List the contents of a tree object. More information: https://git-
> scm.com/docs/git-ls-tree.
* List the contents of the tree on a branch:
`git ls-tree {{branch_name}}`
* List the contents of the tree on a commit, recursing into subtrees:
`git ls-tree -r {{commit_hash}}`
* List only the filenames of the tree on a commit:
`git ls-tree --name-only {{commit_hash}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | cups-config | # cups-config
> Show technical information about your CUPS print server installation. More
> information: https://www.cups.org/doc/man-cups-config.html.
* Show the currently installed version of CUPS:
`cups-config --version`
* Show where CUPS is currently installed:
`cups-config --serverbin`
* Show the location of CUPS' configuration directory:
`cups-config --serverroot`
* Show the location of CUPS' data directory:
`cups-config --datadir`
* Display all available options:
`cups-config --help` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | systemd-run | # systemd-run
> Run programs in transient scope units, service units, or path-, socket-, or
> timer-triggered service units. More information:
> https://www.freedesktop.org/software/systemd/man/systemd-run.html.
* Start a transient service:
`sudo systemd-run {{command}} {{argument1 argument2 ...}}`
* Start a transient service under the service manager of the current user (no privileges):
`systemd-run --user {{command}} {{argument1 argument2 ...}}`
* Start a transient service with a custom unit name and description:
`sudo systemd-run --unit={{name}} --description={{string}} {{command}}
{{argument1 argument2 ...}}`
* Start a transient service that does not get cleaned up after it terminates with a custom environment variable:
`sudo systemd-run --remain-after-exit --set-env={{name}}={{value}} {{command}}
{{argument1 argument2 ...}}`
* Start a transient timer that periodically runs its transient service (see `man systemd.time` for calendar event format):
`sudo systemd-run --on-calendar={{calendar_event}} {{command}} {{argument1
argument2 ...}}`
* Share the terminal with the program (allowing interactive input/output) and make sure the execution details remain after the program exits:
`systemd-run --remain-after-exit --pty {{command}}`
* Set properties (e.g. CPUQuota, MemoryMax) of the process and wait until it exits:
`systemd-run --property MemoryMax={{memory_in_bytes}} --property
CPUQuota={{percentage_of_CPU_time}}% --wait {{command}}`
* Use the program in a shell pipeline:
`{{command1}} | systemd-run --pipe {{command2}} | {{command3}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | coredumpctl | # coredumpctl
> Retrieve and process saved core dumps and metadata. More information:
> https://www.freedesktop.org/software/systemd/man/coredumpctl.html.
* List all captured core dumps:
`coredumpctl list`
* List captured core dumps for a program:
`coredumpctl list {{program}}`
* Show information about the core dumps matching a program with `PID`:
`coredumpctl info {{PID}}`
* Invoke debugger using the last core dump of a program:
`coredumpctl debug {{program}}`
* Extract the last core dump of a program to a file:
`coredumpctl --output={{path/to/file}} dump {{program}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | systemd-cat | # systemd-cat
> Connect a pipeline or program's output streams with the systemd journal.
> More information: https://www.freedesktop.org/software/systemd/man/systemd-
> cat.html.
* Write the output of the specified command to the journal (both output streams are captured):
`systemd-cat {{command}}`
* Write the output of a pipeline to the journal (`stderr` stays connected to the terminal):
`{{command}} | systemd-cat` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | timedatectl | # timedatectl
> Control the system time and date. More information:
> https://manned.org/timedatectl.
* Check the current system clock time:
`timedatectl`
* Set the local time of the system clock directly:
`timedatectl set-time "{{yyyy-MM-dd hh:mm:ss}}"`
* List available timezones:
`timedatectl list-timezones`
* Set the system timezone:
`timedatectl set-timezone {{timezone}}`
* Enable Network Time Protocol (NTP) synchronization:
`timedatectl set-ntp on`
* Change the hardware clock time standard to localtime:
`timedatectl set-local-rtc 1` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | hostnamectl | # hostnamectl
> Get or set the hostname of the computer. More information:
> https://manned.org/hostnamectl.
* Get the hostname of the computer:
`hostnamectl`
* Set the hostname of the computer:
`sudo hostnamectl set-hostname "{{hostname}}"`
* Set a pretty hostname for the computer:
`sudo hostnamectl set-hostname --static "{{hostname.example.com}}" && sudo
hostnamectl set-hostname --pretty "{{hostname}}"`
* Reset hostname to its default value:
`sudo hostnamectl set-hostname --pretty ""` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-cat-file | # git cat-file
> Provide content or type and size information for Git repository objects.
> More information: https://git-scm.com/docs/git-cat-file.
* Get the [s]ize of the HEAD commit in bytes:
`git cat-file -s HEAD`
* Get the [t]ype (blob, tree, commit, tag) of a given Git object:
`git cat-file -t {{8c442dc3}}`
* Pretty-[p]rint the contents of a given Git object based on its type:
`git cat-file -p {{HEAD~2}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | systemd-path | # systemd-path
> List and query system and user paths. More information:
> https://www.freedesktop.org/software/systemd/man/systemd-path.html.
* Display a list of known paths and their current values:
`systemd-path`
* Query the specified path and display its value:
`systemd-path "{{path_name}}"`
* Suffix printed paths with `suffix_string`:
`systemd-path --suffix {{suffix_string}}`
* Print a short version string and then exit:
`systemd-path --version` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-mailinfo | # git mailinfo
> Extract patch and authorship information from a single email message. More
> information: https://git-scm.com/docs/git-mailinfo.
* Extract the patch and author data from an email message:
`git mailinfo {{message|patch}}`
* Extract but remove leading and trailing whitespace:
`git mailinfo -k {{message|patch}}`
* Remove everything from the body before a scissors line (e.g. "-->* --") and retrieve the message or patch:
`git mailinfo --scissors {{message|patch}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-annotate | # git annotate
> Show commit hash and last author on each line of a file. See `git blame`,
> which is preferred over `git annotate`. `git annotate` is provided for those
> familiar with other version control systems. More information: https://git-
> scm.com/docs/git-annotate.
* Print a file with the author name and commit hash prepended to each line:
`git annotate {{path/to/file}}`
* Print a file with the author email and commit hash prepended to each line:
`git annotate -e {{path/to/file}}`
* Print only rows that match a regular expression:
`git annotate -L :{{regexp}} {{path/to/file}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-worktree | # git worktree
> Manage multiple working trees attached to the same repository. More
> information: https://git-scm.com/docs/git-worktree.
* Create a new directory with the specified branch checked out into it:
`git worktree add {{path/to/directory}} {{branch}}`
* Create a new directory with a new branch checked out into it:
`git worktree add {{path/to/directory}} -b {{new_branch}}`
* List all the working directories attached to this repository:
`git worktree list`
* Remove a worktree (after deleting worktree directory):
`git worktree prune` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-show-ref | # git show-ref
> Git command for listing references. More information: https://git-
> scm.com/docs/git-show-ref.
* Show all refs in the repository:
`git show-ref`
* Show only heads references:
`git show-ref --heads`
* Show only tags references:
`git show-ref --tags`
* Verify that a given reference exists:
`git show-ref --verify {{path/to/ref}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-checkout | # git checkout
> Checkout a branch or paths to the working tree. More information:
> https://git-scm.com/docs/git-checkout.
* Create and switch to a new branch:
`git checkout -b {{branch_name}}`
* Create and switch to a new branch based on a specific reference (branch, remote/branch, tag are examples of valid references):
`git checkout -b {{branch_name}} {{reference}}`
* Switch to an existing local branch:
`git checkout {{branch_name}}`
* Switch to the previously checked out branch:
`git checkout -`
* Switch to an existing remote branch:
`git checkout --track {{remote_name}}/{{branch_name}}`
* Discard all unstaged changes in the current directory (see `git reset` for more undo-like commands):
`git checkout .`
* Discard unstaged changes to a given file:
`git checkout {{path/to/file}}`
* Replace a file in the current directory with the version of it committed in a given branch:
`git checkout {{branch_name}} -- {{path/to/file}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-instaweb | # git instaweb
> Helper to launch a GitWeb server. More information: https://git-
> scm.com/docs/git-instaweb.
* Launch a GitWeb server for the current Git repository:
`git instaweb --start`
* Listen only on localhost:
`git instaweb --start --local`
* Listen on a specific port:
`git instaweb --start --port {{1234}}`
* Use a specified HTTP daemon:
`git instaweb --start --httpd {{lighttpd|apache2|mongoose|plackup|webrick}}`
* Also auto-launch a web browser:
`git instaweb --start --browser`
* Stop the currently running GitWeb server:
`git instaweb --stop`
* Restart the currently running GitWeb server:
`git instaweb --restart` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-describe | # git describe
> Give an object a human-readable name based on an available ref. More
> information: https://git-scm.com/docs/git-describe.
* Create a unique name for the current commit (the name contains the most recent annotated tag, the number of additional commits, and the abbreviated commit hash):
`git describe`
* Create a name with 4 digits for the abbreviated commit hash:
`git describe --abbrev={{4}}`
* Generate a name with the tag reference path:
`git describe --all`
* Describe a Git tag:
`git describe {{v1.0.0}}`
* Create a name for the last commit of a given branch:
`git describe {{branch_name}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-ls-files | # git ls-files
> Show information about files in the index and the working tree. More
> information: https://git-scm.com/docs/git-ls-files.
* Show deleted files:
`git ls-files --deleted`
* Show modified and deleted files:
`git ls-files --modified`
* Show ignored and untracked files:
`git ls-files --others`
* Show untracked files, not ignored:
`git ls-files --others --exclude-standard` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-difftool | # git difftool
> Show file changes using external diff tools. Accepts the same options and
> arguments as `git diff`. See also: `git diff`. More information:
> https://git-scm.com/docs/git-difftool.
* List available diff tools:
`git difftool --tool-help`
* Set the default diff tool to meld:
`git config --global diff.tool "{{meld}}"`
* Use the default diff tool to show staged changes:
`git difftool --staged`
* Use a specific tool (opendiff) to show changes since a given commit:
`git difftool --tool={{opendiff}} {{commit}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | scriptreplay | # scriptreplay
> Replay a typescript created by the `script` command to `stdout`. More
> information: https://manned.org/scriptreplay.
* Replay a typescript at the speed it was recorded:
`scriptreplay {{path/to/timing_file}} {{path/to/typescript}}`
* Replay a typescript at double the original speed:
`scriptreplay {{path/to/timingfile}} {{path/to/typescript}} 2`
* Replay a typescript at half the original speed:
`scriptreplay {{path/to/timingfile}} {{path/to/typescript}} 0.5` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-shortlog | # git shortlog
> Summarizes the `git log` output. More information: https://git-
> scm.com/docs/git-shortlog.
* View a summary of all the commits made, grouped alphabetically by author name:
`git shortlog`
* View a summary of all the commits made, sorted by the number of commits made:
`git shortlog -n`
* View a summary of all the commits made, grouped by the committer identities (name and email):
`git shortlog -c`
* View a summary of the last 5 commits (i.e. specify a revision range):
`git shortlog HEAD~{{5}}..HEAD`
* View all users, emails and the number of commits in the current branch:
`git shortlog -sne`
* View all users, emails and the number of commits in all branches:
`git shortlog -sne --all` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-rev-list | # git rev-list
> List revisions (commits) in reverse chronological order. More information:
> https://git-scm.com/docs/git-rev-list.
* List all commits on the current branch:
`git rev-list {{HEAD}}`
* Print the latest commit that changed (add/edit/remove) a specific file on the current branch:
`git rev-list -n 1 HEAD -- {{path/to/file}}`
* List commits more recent than a specific date, on a specific branch:
`git rev-list --since={{'2019-12-01 00:00:00'}} {{branch_name}}`
* List all merge commits on a specific commit:
`git rev-list --merges {{commit}}`
* Print the number of commits since a specific tag:
`git rev-list {{tag_name}}..HEAD --count` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-submodule | # git submodule
> Inspects, updates and manages submodules. More information: https://git-
> scm.com/docs/git-submodule.
* Install a repository's specified submodules:
`git submodule update --init --recursive`
* Add a Git repository as a submodule:
`git submodule add {{repository_url}}`
* Add a Git repository as a submodule at the specified directory:
`git submodule add {{repository_url}} {{path/to/directory}}`
* Update every submodule to its latest commit:
`git submodule foreach git pull` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-bugreport | # git bugreport
> Captures debug information from the system and user, generating a text file
> to aid in the reporting of a bug in Git. More information: https://git-
> scm.com/docs/git-bugreport.
* Create a new bug report file in the current directory:
`git bugreport`
* Create a new bug report file in the specified directory, creating it if it does not exist:
`git bugreport --output-directory {{path/to/directory}}`
* Create a new bug report file with the specified filename suffix in `strftime` format:
`git bugreport --suffix {{%m%d%y}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | systemd-delta | # systemd-delta
> Find overridden systemd-related configuration files. More information:
> https://www.freedesktop.org/software/systemd/man/systemd-delta.html.
* Show all overridden configuration files:
`systemd-delta`
* Show only files of specific types (comma-separated list):
`systemd-delta --type
{{masked|equivalent|redirected|overridden|extended|unchanged}}`
* Show only files whose path starts with the specified prefix (Note: a prefix is a directory containing subdirectories with systemd configuration files):
`systemd-delta {{/etc|/run|/usr/lib|...}}`
* Further restrict the search path by adding a suffix (the prefix is optional):
`systemd-delta {{prefix}}/{{tmpfiles.d|sysctl.d|systemd/system|...}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-ls-remote | # git ls-remote
> Git command for listing references in a remote repository based on name or
> URL. If no name or URL are given, then the configured upstream branch will
> be used, or remote origin if the former is not configured. More information:
> https://git-scm.com/docs/git-ls-remote.
* Show all references in the default remote repository:
`git ls-remote`
* Show only heads references in the default remote repository:
`git ls-remote --heads`
* Show only tags references in the default remote repository:
`git ls-remote --tags`
* Show all references from a remote repository based on name or URL:
`git ls-remote {{repository_url}}`
* Show references from a remote repository filtered by a pattern:
`git ls-remote {{repository_name}} "{{pattern}}"` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-mergetool | # git mergetool
> Run merge conflict resolution tools to resolve merge conflicts. More
> information: https://git-scm.com/docs/git-mergetool.
* Launch the default merge tool to resolve conflicts:
`git mergetool`
* List valid merge tools:
`git mergetool --tool-help`
* Launch the merge tool identified by a name:
`git mergetool --tool {{tool_name}}`
* Don't prompt before each invocation of the merge tool:
`git mergetool --no-prompt`
* Explicitly use the GUI merge tool (see the `merge.guitool` config variable):
`git mergetool --gui`
* Explicitly use the regular merge tool (see the `merge.tool` config variable):
`git mergetool --no-gui` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | systemd-mount | # systemd-mount
> Establish and destroy transient mount or auto-mount points. More
> information: https://www.freedesktop.org/software/systemd/man/systemd-
> mount.html.
* Mount a file system (image or block device) at `/run/media/system/LABEL` where LABEL is the filesystem label or the device name if there is no label:
`systemd-mount {{path/to/file_or_device}}`
* Mount a file system (image or block device) at a specific location:
`systemd-mount {{path/to/file_or_device}} {{path/to/mount_point}}`
* Show a list of all local, known block devices with file systems that may be mounted:
`systemd-mount --list`
* Create an automount point that mounts the actual file system at the time of first access:
`systemd-mount --automount=yes {{path/to/file_or_device}}`
* Unmount one or more devices:
`systemd-mount --umount {{path/to/mount_point_or_device1}}
{{path/to/mount_point_or_device2}}`
* Mount a file system (image or block device) with a specific file system type:
`systemd-mount --type={{file_system_type}} {{path/to/file_or_device}}
{{path/to/mount_point}}`
* Mount a file system (image or block device) with additional mount options:
`systemd-mount --options={{mount_options}} {{path/to/file_or_device}}
{{path/to/mount_point}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-rev-parse | # git rev-parse
> Display metadata related to specific revisions. More information:
> https://git-scm.com/docs/git-rev-parse.
* Get the commit hash of a branch:
`git rev-parse {{branch_name}}`
* Get the current branch name:
`git rev-parse --abbrev-ref {{HEAD}}`
* Get the absolute path to the root directory:
`git rev-parse --show-toplevel` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-verify-tag | # git verify-tag
> Check for GPG verification of tags. If a tag wasn't signed, an error will
> occur. More information: https://git-scm.com/docs/git-verify-tag.
* Check tags for a GPG signature:
`git verify-tag {{tag1 optional_tag2 ...}}`
* Check tags for a GPG signature and show details for each tag:
`git verify-tag {{tag1 optional_tag2 ...}} --verbose`
* Check tags for a GPG signature and print the raw details:
`git verify-tag {{tag1 optional_tag2 ...}} --raw` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | systemd-notify | # systemd-notify
> Notify the service manager about start-up completion and other daemon status
> changes. This command is useless outside systemd service scripts. More
> information: https://www.freedesktop.org/software/systemd/man/systemd-
> notify.html.
* Notify systemd that the service has completed its initialization and is fully started. It should be invoked when the service is ready to accept incoming requests:
`systemd-notify --booted`
* Signal to systemd that the service is ready to handle incoming connections or perform its tasks:
`systemd-notify --ready`
* Provide a custom status message to systemd (this information is shown by `systemctl status`):
`systemd-notify --status="{{Add custom status message here...}}"` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-credential | # git credential
> Retrieve and store user credentials. More information: https://git-
> scm.com/docs/git-credential.
* Display credential information, retrieving the username and password from configuration files:
`echo "{{url=http://example.com}}" | git credential fill`
* Send credential information to all configured credential helpers to store for later use:
`echo "{{url=http://example.com}}" | git credential approve`
* Erase the specified credential information from all the configured credential helpers:
`echo "{{url=http://example.com}}" | git credential reject` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-range-diff | # git range-diff
> Compare two commit ranges (e.g. two versions of a branch). More information:
> https://git-scm.com/docs/git-range-diff.
* Diff the changes of two individual commits:
`git range-diff {{commit_1}}^! {{commit_2}}^!`
* Diff the changes of ours and theirs from their common ancestor, e.g. after an interactive rebase:
`git range-diff {{theirs}}...{{ours}}`
* Diff the changes of two commit ranges, e.g. to check whether conflicts have been resolved appropriately when rebasing commits from `base1` to `base2`:
`git range-diff {{base1}}..{{rev1}} {{base2}}..{{rev2}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-send-email | # git send-email
> Send a collection of patches as emails. Patches can be specified as files,
> directions, or a revision list. More information: https://git-
> scm.com/docs/git-send-email.
* Send the last commit in the current branch:
`git send-email -1`
* Send a given commit:
`git send-email -1 {{commit}}`
* Send multiple (e.g. 10) commits in the current branch:
`git send-email {{-10}}`
* Send an introductory email message for the patch series:
`git send-email -{{number_of_commits}} --compose`
* Review and edit the email message for each patch you're about to send:
`git send-email -{{number_of_commits}} --annotate` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-check-attr | # git check-attr
> For every pathname, list if each attribute is unspecified, set, or unset as
> a gitattribute on that pathname. More information: https://git-
> scm.com/docs/git-check-attr.
* Check the values of all attributes on a file:
`git check-attr --all {{path/to/file}}`
* Check the value of a specific attribute on a file:
`git check-attr {{attribute}} {{path/to/file}}`
* Check the value of a specific attribute on files:
`git check-attr --all {{path/to/file1}} {{path/to/file2}}`
* Check the value of a specific attribute on one or more files:
`git check-attr {{attribute}} {{path/to/file1}} {{path/to/file2}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-stripspace | # git stripspace
> Read text (e.g. commit messages, notes, tags, and branch descriptions) from
> `stdin` and clean it into the manner used by Git. More information:
> https://git-scm.com/docs/git-stripspace.
* Trim whitespace from a file:
`cat {{path/to/file}} | git stripspace`
* Trim whitespace and Git comments from a file:
`cat {{path/to/file}} | git stripspace --strip-comments`
* Convert all lines in a file into Git comments:
`git stripspace --comment-lines < {{path/to/file}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-update-ref | # git update-ref
> Git command for creating, updating, and deleting Git refs. More information:
> https://git-scm.com/docs/git-update-ref.
* Delete a ref, useful for soft resetting the first commit:
`git update-ref -d {{HEAD}}`
* Update ref with a message:
`git update-ref -m {{message}} {{HEAD}} {{4e95e05}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-merge-base | # git merge-base
> Find a common ancestor of two commits. More information: https://git-
> scm.com/docs/git-merge-base.
* Print the best common ancestor of two commits:
`git merge-base {{commit_1}} {{commit_2}}`
* Output all best common ancestors of two commits:
`git merge-base --all {{commit_1}} {{commit_2}}`
* Check if a commit is an ancestor of a specific commit:
`git merge-base --is-ancestor {{ancestor_commit}} {{commit}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-diff-files | # git diff-files
> Compare files using their sha1 hashes and modes. More information:
> https://git-scm.com/docs/git-diff-files.
* Compare all changed files:
`git diff-files`
* Compare only specified files:
`git diff-files {{path/to/file}}`
* Show only the names of changed files:
`git diff-files --name-only`
* Output a summary of extended header information:
`git diff-files --summary` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-show-index | # git show-index
> Show the packed archive index of a Git repository. More information:
> https://git-scm.com/docs/git-show-index.
* Read an IDX file for a Git packfile and dump its contents to `stdout`:
`git show-index {{path/to/file.idx}}`
* Specify the hash algorithm for the index file (experimental):
`git show-index --object-format={{sha1|sha256}} {{path/to/file}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-whatchanged | # git whatchanged
> Show what has changed with recent commits or files. See also `git log`. More
> information: https://git-scm.com/docs/git-whatchanged.
* Display logs and changes for recent commits:
`git whatchanged`
* Display logs and changes for recent commits within the specified time frame:
`git whatchanged --since="{{2 hours ago}}"`
* Display logs and changes for recent commits for specific files or directories:
`git whatchanged {{path/to/file_or_directory}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-show-branch | # git show-branch
> Show branches and their commits. More information: https://git-
> scm.com/docs/git-show-branch.
* Show a summary of the latest commit on a branch:
`git show-branch {{branch_name|ref|commit}}`
* Compare commits in the history of multiple commits or branches:
`git show-branch {{branch_name|ref|commit}}`
* Compare all remote tracking branches:
`git show-branch --remotes`
* Compare both local and remote tracking branches:
`git show-branch --all`
* List the latest commits in all branches:
`git show-branch --all --list`
* Compare a given branch with the current branch:
`git show-branch --current {{commit|branch_name|ref}}`
* Display the commit name instead of the relative name:
`git show-branch --sha1-name --current {{current|branch_name|ref}}`
* Keep going a given number of commits past the common ancestor:
`git show-branch --more {{5}} {{commit|branch_name|ref}}
{{commit|branch_name|ref}} {{...}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-cherry-pick | # git cherry-pick
> Apply the changes introduced by existing commits to the current branch. To
> apply changes to another branch, first use `git checkout` to switch to the
> desired branch. More information: https://git-scm.com/docs/git-cherry-pick.
* Apply a commit to the current branch:
`git cherry-pick {{commit}}`
* Apply a range of commits to the current branch (see also `git rebase --onto`):
`git cherry-pick {{start_commit}}~..{{end_commit}}`
* Apply multiple (non-sequential) commits to the current branch:
`git cherry-pick {{commit_1}} {{commit_2}}`
* Add the changes of a commit to the working directory, without creating a commit:
`git cherry-pick --no-commit {{commit}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | systemd-analyze | # systemd-analyze
> Analyze and debug system manager. Show timing details about the boot process
> of units (services, mount points, devices, sockets). More information:
> https://www.freedesktop.org/software/systemd/man/systemd-analyze.html.
* List all running units, ordered by the time they took to initialize:
`systemd-analyze blame`
* Print a tree of the time-critical chain of units:
`systemd-analyze critical-chain`
* Create an SVG file showing when each system service started, highlighting the time that they spent on initialization:
`systemd-analyze plot > {{path/to/file.svg}}`
* Plot a dependency graph and convert it to an SVG file:
`systemd-analyze dot | dot -T{{svg}} > {{path/to/file.svg}}`
* Show security scores of running units:
`systemd-analyze security` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-unpack-file | # git unpack-file
> Create a temporary file with a blob's contents. More information:
> https://git-scm.com/docs/git-unpack-file.
* Create a file holding the contents of the blob specified by its ID then print the name of the temporary file:
`git unpack-file {{blob_id}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-hash-object | # git hash-object
> Computes the unique hash key of content and optionally creates an object
> with specified type. More information: https://git-scm.com/docs/git-hash-
> object.
* Compute the object ID without storing it:
`git hash-object {{path/to/file}}`
* Compute the object ID and store it in the Git database:
`git hash-object -w {{path/to/file}}`
* Compute the object ID specifying the object type:
`git hash-object -t {{blob|commit|tag|tree}} {{path/to/file}}`
* Compute the object ID from `stdin`:
`cat {{path/to/file}} | git hash-object --stdin` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-commit-tree | # git commit-tree
> Low level utility to create commit objects. See also: `git commit`. More
> information: https://git-scm.com/docs/git-commit-tree.
* Create a commit object with the specified message:
`git commit-tree {{tree}} -m "{{message}}"`
* Create a commit object reading the message from a file (use `-` for `stdin`):
`git commit-tree {{tree}} -F {{path/to/file}}`
* Create a GPG-signed commit object:
`git commit-tree {{tree}} -m "{{message}}" --gpg-sign`
* Create a commit object with the specified parent commit object:
`git commit-tree {{tree}} -m "{{message}}" -p {{parent_commit_sha}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-maintenance | # git-maintenance
> Run tasks to optimize Git repository data. More information: https://git-
> scm.com/docs/git-maintenance.
* Register the current repository in the user's list of repositories to daily have maintenance run:
`git maintenance register`
* Start running maintenance on the current repository:
`git maintenance start`
* Halt the background maintenance schedule for the current repository:
`git maintenance stop`
* Remove the current repository from the user's maintenance repository list:
`git maintenance unregister`
* Run a specific maintenance task on the current repository:
`git maintenance run --task={{commit-graph|gc|incremental-repack|loose-
objects|pack-refs|prefetch}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-check-ignore | # git check-ignore
> Analyze and debug Git ignore/exclude (".gitignore") files. More information:
> https://git-scm.com/docs/git-check-ignore.
* Check whether a file or directory is ignored:
`git check-ignore {{path/to/file_or_directory}}`
* Check whether multiple files or directories are ignored:
`git check-ignore {{path/to/file}} {{path/to/directory}}`
* Use pathnames, one per line, from `stdin`:
`git check-ignore --stdin < {{path/to/file_list}}`
* Do not check the index (used to debug why paths were tracked and not ignored):
`git check-ignore --no-index {{path/to/files_or_directories}}`
* Include details about the matching pattern for each path:
`git check-ignore --verbose {{path/to/files_or_directories}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-request-pull | # git request-pull
> Generate a request asking the upstream project to pull changes into its
> tree. More information: https://git-scm.com/docs/git-request-pull.
* Produce a request summarizing the changes between the v1.1 release and a specified branch:
`git request-pull {{v1.1}} {{https://example.com/project}} {{branch_name}}`
* Produce a request summarizing the changes between the v0.1 release on the `foo` branch and the local `bar` branch:
`git request-pull {{v0.1}} {{https://example.com/project}} {{foo:bar}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-symbolic-ref | # git symbolic-ref
> Read, change, or delete files that store references. More information:
> https://git-scm.com/docs/git-symbolic-ref.
* Store a reference by a name:
`git symbolic-ref refs/{{name}} {{ref}}`
* Store a reference by name, including a message with a reason for the update:
`git symbolic-ref -m "{{message}}" refs/{{name}} refs/heads/{{branch_name}}`
* Read a reference by name:
`git symbolic-ref refs/{{name}}`
* Delete a reference by name:
`git symbolic-ref --delete refs/{{name}}`
* For scripting, hide errors with `--quiet` and use `--short` to simplify ("refs/heads/X" prints as "X"):
`git symbolic-ref --quiet --short refs/{{name}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-format-patch | # git format-patch
> Prepare .patch files. Useful when emailing commits elsewhere. See also `git
> am`, which can apply generated .patch files. More information: https://git-
> scm.com/docs/git-format-patch.
* Create an auto-named `.patch` file for all the unpushed commits:
`git format-patch {{origin}}`
* Write a `.patch` file for all the commits between 2 revisions to `stdout`:
`git format-patch {{revision_1}}..{{revision_2}}`
* Write a `.patch` file for the 3 latest commits:
`git format-patch -{{3}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | systemd-ac-power | # systemd-ac-power
> Report whether the computer is connected to an external power source. More
> information: https://www.freedesktop.org/software/systemd/man/systemd-ac-
> power.html.
* Silently check and return a 0 status code when running on AC power, and a non-zero code otherwise:
`systemd-ac-power`
* Additionally print `yes` or `no` to `stdout`:
`systemd-ac-power --verbose` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-update-index | # git update-index
> Git command for manipulating the index. More information: https://git-
> scm.com/docs/git-update-index.
* Pretend that a modified file is unchanged (`git status` will not show this as changed):
`git update-index --skip-worktree {{path/to/modified_file}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-commit-graph | # git commit-graph
> Write and verify Git commit-graph files. More information: https://git-
> scm.com/docs/git-commit-graph.
* Write a commit-graph file for the packed commits in the repository's local `.git` directory:
`git commit-graph write`
* Write a commit-graph file containing all reachable commits:
`git show-ref --hash | git commit-graph write --stdin-commits`
* Write a commit-graph file containing all commits in the current commit-graph file along with those reachable from `HEAD`:
`git rev-parse {{HEAD}} | git commit-graph write --stdin-commits --append` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-count-objects | # git count-objects
> Count the number of unpacked objects and their disk consumption. More
> information: https://git-scm.com/docs/git-count-objects.
* Count all objects and display the total disk usage:
`git count-objects`
* Display a count of all objects and their total disk usage, displaying sizes in human-readable units:
`git count-objects --human-readable`
* Display more verbose information:
`git count-objects --verbose`
* Display more verbose information, displaying sizes in human-readable units:
`git count-objects --human-readable --verbose` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-verify-commit | # git verify-commit
> Check for GPG verification of commits. If no commits are verified, nothing
> will be printed, regardless of options specified. More information:
> https://git-scm.com/docs/git-verify-commit.
* Check commits for a GPG signature:
`git verify-commit {{commit_hash1 optional_commit_hash2 ...}}`
* Check commits for a GPG signature and show details of each commit:
`git verify-commit {{commit_hash1 optional_commit_hash2 ...}} --verbose`
* Check commits for a GPG signature and print the raw details:
`git verify-commit {{commit_hash1 optional_commit_hash2 ...}} --raw` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-check-mailmap | # git check-mailmap
> Show canonical names and email addresses of contacts. More information:
> https://git-scm.com/docs/git-check-mailmap.
* Look up the canonical name associated with an email address:
`git check-mailmap "<{{email@example.com}}>"` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-for-each-repo | # git for-each-repo
> Run a Git command on a list of repositories. Note: this command is
> experimental and may change. More information: https://git-scm.com/docs/git-
> for-each-repo.
* Run maintenance on each of a list of repositories stored in the `maintenance.repo` user configuration variable:
`git for-each-repo --config={{maintenance.repo}} {{maintenance run}}`
* Run `git pull` on each repository listed in a global configuration variable:
`git for-each-repo --config={{global_configuration_variable}} {{pull}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | systemd-firstboot | # systemd-firstboot
> Initialize basic system settings on or before the first boot-up of a system.
> More information: https://www.freedesktop.org/software/systemd/man/systemd-
> firstboot.html.
* Operate on the specified directory instead of the root directory of the host system:
`sudo systemd-firstboot --root={{path/to/root_directory}}`
* Set the system keyboard layout:
`sudo systemd-firstboot --keymap={{keymap}}`
* Set the system hostname:
`sudo systemd-firstboot --hostname={{hostname}}`
* Set the root user's password:
`sudo systemd-firstboot --root-password={{password}}`
* Prompt the user interactively for a specific basic setting:
`sudo systemd-firstboot --prompt={{setting}}`
* Force writing configuration even if the relevant files already exist:
`sudo systemd-firstboot --force`
* Remove all existing files that are configured by `systemd-firstboot`:
`sudo systemd-firstboot --reset`
* Remove the password of the system's root user:
`sudo systemd-firstboot --delete-root-password` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-checkout-index | # git checkout-index
> Copy files from the index to the working tree. More information:
> https://git-scm.com/docs/git-checkout-index.
* Restore any files deleted since the last commit:
`git checkout-index --all`
* Restore any files deleted or changed since the last commit:
`git checkout-index --all --force`
* Restore any files changed since the last commit, ignoring any files that were deleted:
`git checkout-index --all --force --no-create`
* Export a copy of the entire tree at the last commit to the specified directory (the trailing slash is important):
`git checkout-index --all --force --prefix={{path/to/export_directory/}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | update-alternatives | # update-alternatives
> A convenient tool for maintaining symbolic links to determine default
> commands. More information: https://manned.org/update-alternatives.
* Add a symbolic link:
`sudo update-alternatives --install {{path/to/symlink}} {{command_name}}
{{path/to/command_binary}} {{priority}}`
* Configure a symbolic link for `java`:
`sudo update-alternatives --config {{java}}`
* Remove a symbolic link:
`sudo update-alternatives --remove {{java}}
{{/opt/java/jdk1.8.0_102/bin/java}}`
* Display information about a specified command:
`update-alternatives --display {{java}}`
* Display all commands and their current selection:
`update-alternatives --get-selections` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-cvsexportcommit | # git cvsexportcommit
> Export a single `Git` commit to a CVS checkout. More information:
> https://git-scm.com/docs/git-cvsexportcommit.
* Merge a specific patch into CVS:
`git cvsexportcommit -v -c -w {{path/to/project_cvs_checkout}}
{{commit_sha1}}` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-credential-store | # git credential-store
> `git` helper to store passwords on disk. More information: https://git-
> scm.com/docs/git-credential-store.
* Store Git credentials in a specific file:
`git config credential.helper 'store --file={{path/to/file}}'` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-credential-cache | # git credential-cache
> Git helper to temporarily store passwords in memory. More information:
> https://git-scm.com/docs/git-credential-cache.
* Store Git credentials for a specific amount of time:
`git config credential.helper 'cache --timeout={{time_in_seconds}}'` |
You are a linux expert. You understand what every Linux terminal command does and you reply with the explanation when asked. | git-check-ref-format | # git check-ref-format
> Checks if a given refname is acceptable, and exits with a non-zero status if
> it is not. More information: https://git-scm.com/docs/git-check-ref-format.
* Check the format of the specified refname:
`git check-ref-format {{refs/head/refname}}`
* Print the name of the last branch checked out:
`git check-ref-format --branch @{-1}`
* Normalize a refname:
`git check-ref-format --normalize {{refs/head/refname}}` |
Subsets and Splits