@xgent-ai/skills 0.1.0 → 0.3.0

package/skills/working-with-mise/references/cli/where-html.md

@@ -0,0 +1,53 @@
+mise where
+
+where` [​](#mise-where)
+
+- **Usage:** `mise where <TOOL@VERSION>`
+- **Effect:** read-only
+- **Source code:** [`src/cli/where.rs`](https://github.com/jdx/mise/blob/main/src/cli/where.rs)
+
+Display the installation path for a tool
+
+The tool must be installed for this to work.
+
+## Arguments [​](#arguments)
+
+- **`<TOOL@VERSION>`** — Tool to look up e.g.: ruby@3 With "@\<PREFIX>", shows the latest installed version matching the prefix. Otherwise, shows the current, active installed version.
+
+## Flags [​](#flags)
+
+- **`-h --help`** — Print help
+
+## Examples [​](#examples)
+
+Show the latest installed node 20.x Errors if no matching version is installed
+
+```
+mise where node@20
+/home/jdx/.local/share/mise/installs/node/20.0.0
+```
+
+Show the install directory of the active node, or of the latest installed version if no config requests node Errors if no matching version is installed
+
+```
+mise where node
+/home/jdx/.local/share/mise/installs/node/20.0.0
+```
+
+## Related documentation [​](#related-documentation)
+
+- [Development tools](https://mise.jdx.dev/dev-tools/).
+- [All commands](https://mise.jdx.dev/cli/).
+- [Global flags and argument syntax](https://mise.jdx.dev/cli/#global-flags).
+
+[Edit this page](https://github.com/jdx/mise/edit/main/docs/cli/where.md)
+
+Last updated:
+
+Pager
+
+[Previous pagemise watch](https://mise.jdx.dev/cli/watch.html)
+
+[Next pagemise which](https://mise.jdx.dev/cli/which.html)
+
+MIT License·Copyright © 2026· [![](https://github.com/jdx.png?size=96)jdx.dev](https://jdx.dev)

package/skills/working-with-mise/references/cli/which-html.md

@@ -0,0 +1,55 @@
+mise which
+
+which` [​](#mise-which)
+
+- **Usage:** `mise which [FLAGS] [BIN_NAME]`
+- **Effect:** read-only
+- **Source code:** [`src/cli/which.rs`](https://github.com/jdx/mise/blob/main/src/cli/which.rs)
+
+Show the path a tool's executable resolves to
+
+Use this to figure out what version of a tool is currently active.
+
+## Arguments [​](#arguments)
+
+- **`[BIN_NAME]`** — The executable to look up
+
+## Flags [​](#flags)
+
+- **`-t --tool <TOOL@VERSION>`** — Use a specific tool@version e.g.: `mise which npm --tool=node@20`
+- **`--plugin`** — Show the plugin name instead of the path
+- **`--version`** — Show the version instead of the path
+- **`-h --help`** — Print help
+
+## Examples [​](#examples)
+
+```
+mise which node
+/home/username/.local/share/mise/installs/node/20.0.0/bin/node
+```
+
+```
+mise which node --plugin
+node
+```
+
+```
+mise which node --version
+20.0.0
+```
+
+## Related documentation [​](#related-documentation)
+
+- [Shims and executable lookup](https://mise.jdx.dev/dev-tools/shims.html).
+- [All commands](https://mise.jdx.dev/cli/).
+- [Global flags and argument syntax](https://mise.jdx.dev/cli/#global-flags).
+
+[Edit this page](https://github.com/jdx/mise/edit/main/docs/cli/which.md)
+
+Last updated:
+
+Pager
+
+[Previous pagemise where](https://mise.jdx.dev/cli/where.html)
+
+MIT License·Copyright © 2026· [![](https://github.com/jdx.png?size=96)jdx.dev](https://jdx.dev)

package/skills/working-with-mise/references/configuration/environments-html.md

@@ -0,0 +1,171 @@
+Config Environments
+
+Config Environments [​](#config-environments)
+
+Config environments select additional files such as `mise.development.toml` and `mise.production.toml`. The base `mise.toml` still loads, and the selected file overrides values at the same directory level.
+
+For variables passed to your application, use [`[env]`](https://mise.jdx.dev/environments/). Selecting a mise config environment does not set application variables such as `NODE_ENV` unless you define them.
+
+## Try an environment [​](#try-an-environment)
+
+mise.toml
+
+toml
+
+```
+[env]
+APP_MODE = "development"
+```
+
+mise.production.toml
+
+toml
+
+```
+[env]
+APP_MODE = "production"
+```
+
+sh
+
+```
+mise exec -- sh -c 'echo "$APP_MODE"'                # development
+mise -E production exec -- sh -c 'echo "$APP_MODE"'  # production
+mise -E production config                          # inspect loaded files
+```
+
+## Select environments [​](#select-environments)
+
+Select an environment using one of these methods:
+
+- CLI flag: `-E development` or `--env development`
+- Environment variable: `MISE_ENV=development`
+- `.miserc.toml` file: `env = ["development"]`
+
+mise looks for matching files throughout the configuration hierarchy. Project files use names such as `mise.production.toml`; the global config uses `config.production.toml` in `MISE_CONFIG_DIR`.
+
+Multiple environments can be specified, for example `mise -E ci,test run build`. Within the same directory, the last environment takes precedence. Use `mise -E ci,test config` to inspect the combined selection.
+
+## Setting MISE\_ENV in .miserc.toml [​](#setting-mise-env-in-miserc-toml)
+
+You can set `MISE_ENV` in a `.miserc.toml` file, which is loaded early, before other config files are discovered. This lets you commit your environment configuration to version control:
+
+toml
+
+```
+# .miserc.toml
+env = ["development"]
+```
+
+### Templates in .miserc.toml [​](#templates-in-miserc-toml)
+
+`.miserc.toml` supports [Tera templates](https://mise.jdx.dev/templates.html#miserc-template-support), which is useful for settings like `ceiling_paths` that reference home or XDG directories:
+
+toml
+
+```
+# .miserc.toml
+
+# Stop config search at $HOME
+ceiling_paths = ["{{ env.HOME }}"]
+
+# Or use the XDG config home variable
+ignored_config_paths = ["{{ xdg_config_home }}/mise/shared.toml"]
+```
+
+Only OS-level context is available (environment variables, `cwd`, `arch()`, `os()`, etc.); settings from `mise.toml` are not yet loaded at this stage.
+
+File locations searched (in order of precedence):
+
+1. `.miserc.toml` and `.config/miserc.toml` in the current directory and parent directories
+2. `~/.config/mise/miserc.toml` (global)
+3. `/etc/mise/miserc.toml` (system)
+
+`MISE_ENV` cannot be set in `mise.toml` because it determines which config files are loaded in the first place.
+
+## Local overrides [​](#local-overrides)
+
+mise also looks for "local" files like `mise.local.toml` and `mise.{MISE_ENV}.local.toml` in the current directory and parent directories. These are not intended to be committed to version control (add `mise.local.toml` and `mise.*.local.toml` to your `.gitignore` file).
+
+These files take priority in this order (top overrides bottom):
+
+- `mise.{MISE_ENV}.local.toml`
+- `mise.local.toml`
+- `mise.{MISE_ENV}.toml`
+- `mise.toml`
+
+If `MISE_OVERRIDE_CONFIG_FILENAMES` is set, it is used instead of all of the above.
+
+You can also use paths like `mise/config.{MISE_ENV}.toml` or `.config/mise.{MISE_ENV}.toml`. These follow the order described in [Configuration](https://mise.jdx.dev/configuration.html).
+
+## conf.d environments [​](#conf-d-environments)
+
+Migration in progress
+
+Environment-specific `conf.d` filenames are opt-in until mise 2027.8.10. By default, all non-hidden TOML fragments still load unconditionally, including names such as `node.tools.toml`.
+
+Dots in unconditional fragment names are deprecated. Rename them to use hyphens (for example, `node-tools.toml`) before mise 2027.8.10. At that point, the suffix after the first dot will select an environment.
+
+To opt into the new behavior now, set `env_conf_d = true` in any `miserc.toml` file (see the locations listed above) or set `MISE_ENV_CONF_D=true`. Files in `mise/conf.d`, `.mise/conf.d`, and `.config/mise/conf.d` then use the same environment suffixes as other config files:
+
+text
+
+```
+mise/conf.d/tools.toml                    # always loaded
+mise/conf.d/tools.local.toml              # always loaded, usually gitignored
+mise/conf.d/tools.development.toml        # MISE_ENV=development
+mise/conf.d/tools.development.local.toml  # MISE_ENV=development, usually gitignored
+.mise/conf.d/tools.toml                   # always loaded
+.mise/conf.d/tools.local.toml             # always loaded, usually gitignored
+.mise/conf.d/tools.development.toml       # MISE_ENV=development
+.mise/conf.d/tools.development.local.toml # MISE_ENV=development, usually gitignored
+```
+
+Because this setting controls config discovery, it must be set in a `miserc.toml` file or the environment; setting it in `mise.toml` is too late. To keep the old behavior without the deprecation warning during the migration window, set `env_conf_d = false` explicitly.
+
+Use `mise config` to see which files are being used.
+
+The rules for which file is written to are different, because one file ultimately has to be chosen. See the docs for [`mise use`](https://mise.jdx.dev/cli/use.html) for more information.
+
+## Platform environments [​](#platform-environments)
+
+With the [`auto_env` setting](https://mise.jdx.dev/configuration/settings.html#auto_env) enabled, mise automatically treats the following as active config environments, based on the current platform:
+
+| Environment | Values |
+| --- | --- |
+| `{os_family}` | `unix` (not defined on Windows—use `windows`) |
+| `{os}` | `linux`, `macos`, `windows` |
+| `{os}-{arch}` | e.g. `linux-x64`, `macos-arm64`, `windows-x64` |
+
+Architectures use mise's remapped names: `x86_64` → `x64` and `aarch64` → `arm64`.
+
+This makes config files like `mise.windows.toml`, `mise.macos-arm64.toml`, or `mise.unix.toml` load automatically and selects matching lockfiles like `mise.windows.lock`. All of the usual config file locations and `.local.toml` variants work.
+
+Platform environments have lower precedence than explicit `MISE_ENV` entries. The full order is (later overrides earlier): `unix` < `{os}` < `{os}-{arch}` < explicit `MISE_ENV` entries.
+
+Platform environments only affect config file discovery and lockfile selection. They are not added to `MISE_ENV` itself: the  template variable and the `MISE_ENV` variable passed to subprocesses and tasks only reflect explicit environments.
+
+### Rollout [​](#rollout)
+
+`auto_env` is currently **disabled by default**. Starting with mise `2027.6.0`, it will be enabled by default; from `2026.12.0` until then, mise warns when it finds a platform-specific config file that would be newly loaded. To control the behavior explicitly:
+
+toml
+
+```
+# .miserc.toml
+auto_env = false # keep the old behavior and silence the warning
+```
+
+Set `auto_env = true` instead to adopt the new behavior now. Alternatively, set `MISE_AUTO_ENV=true` / `MISE_AUTO_ENV=false`. Like `MISE_ENV`, this is an early-init setting: it must be set in `.miserc.toml` or via the environment variable — setting it in `mise.toml` has no effect because config file discovery has already happened by the time `mise.toml` is read.
+
+[Edit this page](https://github.com/jdx/mise/edit/main/docs/configuration/environments.md)
+
+Last updated:
+
+Pager
+
+[Previous pageSettings](https://mise.jdx.dev/configuration/settings.html)
+
+[Next pageDev Tools Overview](https://mise.jdx.dev/dev-tools/)
+
+MIT License·Copyright © 2026· [![](https://github.com/jdx.png?size=96)jdx.dev](https://jdx.dev)

package/skills/working-with-mise/references/configuration/project-diagnostics-html.md

@@ -0,0 +1,93 @@
+Project diagnostics
+
+Project diagnostics [​](#project-diagnostics)
+
+`mise doctor project` runs named checks from your project's configuration and reports every result. Use it to check requirements that tool versions alone cannot establish, such as whether a compiler can discover a native library or whether a database accepts connections.
+
+toml
+
+```
+[doctor.checks.openssl]
+description = "OpenSSL development files are discoverable"
+run = "pkg-config --exists openssl"
+hint = "Run `mise bootstrap packages apply` to install the declared build dependencies."
+timeout = "5s"
+os = ["linux", "macos"]
+
+[doctor.checks.database]
+description = "PostgreSQL accepts connections"
+run = "pg_isready --quiet"
+hint = "Start the project's services with pitchfork."
+timeout = "5s"
+```
+
+sh
+
+```
+mise doctor project
+mise doctor project --json
+```
+
+Example output:
+
+text
+
+```
+PASS database: PostgreSQL accepts connections
+FAIL openssl: OpenSSL development files are discoverable
+  Command exited with exit status: 1
+  Run `mise bootstrap packages apply` to install the declared build dependencies.
+```
+
+Ordinary `mise doctor` continues to diagnose mise itself; it does not run these checks. Checks do not run automatically when entering a directory or running a task. There are no implicit project checks: declare the requirements you need.
+
+## Check configuration [​](#check-configuration)
+
+Each `[doctor.checks.<name>]` table supports:
+
+| Field | Meaning |
+| --- | --- |
+| `run` | Required shell command; exit zero to pass. |
+| `description` | Human-readable requirement. Defaults to the check name in text output. |
+| `hint` | Guidance shown after a failure or execution error. Never executed. |
+| `timeout` | Positive duration such as `500ms` or `5s`; defaults to `10s`. |
+| `dir` | Working directory. Relative paths resolve from the declaring configuration's root; `~/` and absolute paths are used as given. Defaults to that root. |
+| `shell` | Executable and arguments, including the command flag, such as `"bash -c"` or `"pwsh -Command"`. Defaults to mise's inline task shell. |
+| `os` | OS or OS/arch selector, or a nonempty list, such as `"linux/arm64"` or `["linux", "darwin"]`. Omit to run everywhere. |
+
+Checks use the active configuration hierarchy, including environment-specific configuration. A higher-precedence definition replaces the entire check of the same name, including its hint and working directory. Checks run concurrently, bounded by the `jobs` setting (`MISE_JOBS`), so slow probes can share their waiting time. Results remain in name order and a failed check does not stop other checks. Set `jobs = 1` for sequential execution.
+
+Commands receive the project's environment and installed tool paths, including environment removals. Diagnostics do not install tools or run task dependencies or task hooks. Environment directives still evaluate normally, so author checks as inspection commands and use normal mise configuration trust. Project checks that apply to the current platform report errors in safe mode. Empty or entirely platform-excluded check lists still succeed. Checks are not sandboxed.
+
+Each command has a deadline and a combined 64 KiB stdout/stderr limit. Timeouts and output-limit failures terminate the owned process tree. Command output is captured and discarded rather than included in reports, so a probe cannot accidentally print a credential into the report. Use `description` and `hint` to explain the requirement and remedy; run the command directly for its detailed output.
+
+Absolute paths, a leading `~/`, and `..` components in `dir` are allowed, as with task working directories; templates are not rendered. The configuration root anchors relative paths; it is not a filesystem boundary. Checks can intentionally inspect a sibling checkout or shared local service directory. Checks declared in global or system configuration use the invocation directory as their root, like tasks; a `mise.toml` directly in the home directory is project configuration and anchors at the home directory. Shell overrides use task quoting conventions and honor `windows_powershell_no_profile`. The OS selector accepts the same aliases (`darwin`, `win`, `amd64`, and others) as tool filters; `os = []` is rejected. Unknown `[doctor]` container options are ignored for forward compatibility (the JSON schema allows them too), while unknown check fields are rejected to catch typos.
+
+On Unix, Ctrl-C, SIGTERM, and SIGHUP cancel running checks and close their owned process groups, including when doctor runs inside a mise task. A signal the parent ignored, such as SIGHUP under `nohup`, stays ignored. As with any cleanup that requires the supervisor to run, SIGKILL prevents cleanup; stop doctor with SIGTERM before escalating to SIGKILL.
+
+## Results and automation [​](#results-and-automation)
+
+The JSON report contains `checks` and `errors` arrays. Top-level `errors` contains configuration loading errors; in that case `checks` is empty. Otherwise `errors` is empty and each declared check has a result in `checks`. Each entry contains `name`, `description`, `source` (the declaring configuration file), `status`, `message`, and `hint`. Optional fields are `null` when absent.
+
+- `pass`: the command exited successfully.
+- `fail`: the command exited unsuccessfully.
+- `error`: mise could not execute or finish the check, including a timeout, invalid check options, or an unavailable project environment.
+- `skipped`: the check's `os` selection excludes the current system.
+
+A shell can report a missing command as a nonzero exit; that is a `fail`, while failure to launch the shell itself is an `error`.
+
+The command exits with status 1 if any check fails or cannot be completed. An empty check list or only skipped checks exits successfully. Configuration loading failures, including required environment values that prevent loading, are reported in the top-level `errors` array. If configuration loads but preparing the tool environment fails, affected checks each report an error and platform-excluded checks remain skipped.
+
+This is a compatibility check of the current machine. Passing does not establish whole-environment reproducibility. Keep tool and application lockfiles for the parts of your environment they cover.
+
+[Edit this page](https://github.com/jdx/mise/edit/main/docs/configuration/project-diagnostics.md)
+
+Last updated:
+
+Pager
+
+[Previous pageVariables](https://mise.jdx.dev/configuration/vars.html)
+
+[Next pageSettings](https://mise.jdx.dev/configuration/settings.html)
+
+MIT License·Copyright © 2026· [![](https://github.com/jdx.png?size=96)jdx.dev](https://jdx.dev)