feat: Added missing documentation

Author: kevinwang5658

docs/resources/(resources)/apt.mdx

@@ -3,24 +3,23 @@ title: apt
 description: A reference page for the apt resource
 ---
 
-The apt resource reference. This resource manages packages on Debian-based Linux systems using the APT (Advanced Package Tool) package manager. APT is the standard package manager for Ubuntu, Debian, Linux Mint, and other Debian-based distributions.
+The apt resource manages packages on Debian-based Linux systems using the APT (Advanced Package Tool) package manager. APT is the standard package manager for Ubuntu, Debian, Linux Mint, and other Debian-based distributions.
 
 ## Parameters:
 
-- **install**: *(array[string | object])* A list of packages to install using apt. Each package can be specified as:
-  - A simple string with the package name (e.g., `"curl"`)
-  - An object with `name` and optional `version` fields for version-specific installations
+- **install**: *(array[string])* A list of packages to install using apt. Each entry is a string with the package name, optionally including a version constraint using the `name=version` syntax (e.g. `"nodejs=20.*"`). Codify adds packages that are missing and removes packages that are no longer listed.
 
-- **update**: *(boolean)* Whether to run `apt-get update` before installing packages to refresh the package index. Defaults to `true`. Set to `false` to skip the update step if you've recently updated your package lists.
+- **update**: *(boolean)* Whether to run `apt-get update` before installing packages to refresh the package index. Defaults to `true`. Set to `false` to skip the update step if you have recently refreshed your package lists.
 
 ## Example usage:
 
-### Installing packages with simple names
+### Install packages by name
 
 ```json title="codify.jsonc"
 [
   {
     "type": "apt",
+    "os": ["linux"],
     "install": [
       "curl",
       "git",
@@ -31,33 +30,31 @@ The apt resource reference. This resource manages packages on Debian-based Linux
 ]
 ```
 
-### Installing specific package versions
+### Pin specific package versions
+
+Use the `name=version` syntax to install a particular version. Wildcards (`*`) are supported.
 
 ```json title="codify.jsonc"
 [
   {
     "type": "apt",
+    "os": ["linux"],
     "install": [
       "curl",
-      {
-        "name": "nginx",
-        "version": "1.18.0-0ubuntu1"
-      },
-      {
-        "name": "postgresql",
-        "version": "12+214ubuntu0.1"
-      }
+      "nodejs=20.*",
+      "python3=3.12.*"
     ]
   }
 ]
 ```
 
-### Skipping the update step
+### Skip the update step
 
 ```json title="codify.jsonc"
 [
   {
     "type": "apt",
+    "os": ["linux"],
     "install": [
       "jq",
       "htop"
@@ -69,7 +66,8 @@ The apt resource reference. This resource manages packages on Debian-based Linux
 
 ## Notes:
 
-- The apt resource requires sudo privileges to install packages. Codify will prompt for your password when needed.
+- The apt resource requires `sudo` privileges to install and remove packages. Codify handles privilege escalation automatically.
 - APT is only available on Debian-based Linux distributions. For Red Hat-based systems, use the [yum](/docs/resources/yum) or [dnf](/docs/resources/dnf) resources instead.
-- Package names must match those available in your configured APT repositories. Use `apt search <package>` to find available packages.
-- When specifying versions, use the exact version string as shown by `apt-cache policy <package>`.
+- The `install` list is stateful — Codify tracks which packages it installed and removes them when they are taken off the list. Packages installed outside of Codify are not affected.
+- Package names must match those available in your configured APT repositories. Use `apt-cache search <package>` to find available packages and `apt-cache policy <package>` to see available versions.
+- The `os` field should be set to `["linux"]` when combining this resource with macOS-only resources in the same configuration file, so Codify only applies it on Linux systems.

docs/resources/(resources)/asdf/asdf.mdx

@@ -3,76 +3,62 @@ title: asdf
 description: A reference page for the asdf resource
 ---
 
-Asdf is an all-in-one tool manager designed to replace individual language specific version managers
-such as pyenv, nvm, rbenv, etc. Asdf operates on a plugin based system
-to support the different tools. A full list of the supported plugins can be found here
-https://github.com/asdf-community. Asdf uses shims similar to pyenv, nvm, etc. and has the
-ability to install a tool globally, within a specific directory, or within a shell.
+Asdf is an all-in-one tool version manager designed to replace individual language-specific version managers such as pyenv, nvm, rbenv, and others. It operates on a plugin-based system to support different tools. A full list of supported plugins can be found at https://github.com/asdf-community.
 
 Installing a tool with asdf is a multistep process:
 1. Install asdf
-2. Install the plugin corresponding to the desired language/tool (ex: nodejs, golang, python, etc...)
-`asdf plugin add <name>`
-3. Install the desired version of the language/tool `asdf install <name> <version>`
-4. Load the language/tool to the global or local .tool-versions before it can used
-`asdf local <name> <version>` or `asdf global <name> <version>`. Installing the language/tool
-to locally means it can be used in the current directory or any subdirectories. Installing to global
-means that it can be used anywhere on the system. Tools that are not loaded cannot be used.
-
-Additionally, asdf supports using a `.tool-versions` file to install multiple tools.
-Running `asdf install` in a directory with a `.tool-versions` will install the tools listed
-in the file. The installed tools are only be available in that directory or any subdirectories.
+2. Install the plugin for the desired language/tool: `asdf plugin add <name>`
+3. Install the desired version of the tool: `asdf install <name> <version>`
+4. Set the version globally or locally before it can be used: `asdf global <name> <version>` or `asdf local <name> <version>`
 
-#### Codify Resources
+Asdf also supports `.tool-versions` files. Running `asdf install` in a directory containing a `.tool-versions` file installs all the tools listed in it. The installed tools are then available in that directory and its subdirectories.
+
+#### Platform-specific installation
 
-The Codify asdf resources are designed to replicate the same design model as the original tool.
+- **macOS**: Installed via Homebrew (`brew install asdf`). Homebrew must be present.
+- **Linux**: The latest release binary is downloaded directly from GitHub and placed in `~/.local/bin`. Codify also adds the asdf shims directory to `PATH` in your shell RC file.
 
-- **asdf:** Installs asdf itself and optionally this resource can install plugins
-(as an added feature to help improve usability)
-- **asdf-plugin:** Installs an asdf plugin and optionally and install specific versions of the
-tool using the plugin (added feature).
-- **asdf-local:** Loads the asdf tool version locally to a directory or multiple directories.
-- **asdf-global:** Loads the asdf tool version globally.
-- **asdf-install:** Installs the `.tool-versions` file in a directory or installs
-a version of a tool. asdf-install will add missing plugins automatically (added feature)
+#### Codify Resources
+
+- **asdf** — Installs asdf itself and optionally installs plugins.
+- **[asdf-plugin](/docs/resources/asdf/asdf-plugin)** — Installs an asdf plugin and optionally installs specific versions of the tool.
+- **[asdf-install](/docs/resources/asdf/asdf-install)** — Installs a `.tool-versions` file in a directory, or installs specific versions of a tool. Automatically installs missing plugins.
 
 ## Parameters:
 
-- **plugins**: *(array[string])* An optional array of plugins to install. The plugin names must match
-the names found in https://github.com/asdf-community.
+- **plugins**: *(array[string])* An optional list of asdf plugins to install. The plugin names must match those found at https://github.com/asdf-community. This list is managed statefully — plugins are added when they appear in the list and removed when they are taken off.
 
 ## Example usage:
 
-#### Install asdf:
+### Install asdf
+
 ```json title="codify.jsonc"
 [
   {
-    "type":  "asdf"
+    "type": "asdf"
   }
 ]
 ```
 
-#### Install asdf and the `nodejs` and `golang` plugins:
+### Install asdf with plugins
+
 ```json title="codify.jsonc"
 [
   {
-    "type":  "asdf",
-    "plugins": ["nodejs", "golang"]
+    "type": "asdf",
+    "plugins": ["nodejs", "python"]
   }
 ]
 ```
 
-#### A full config for installing a .tool-versions file
+### Install a `.tool-versions` file
 
-The `asdf-install` resource will automatically install missing plugins if they exist in a
-`.tool-versions` file. This is additional functionality added by Codify. The config below
-installs asdf, installs the necessary plugins and then installs the tool versions specified
-in `~/path/to/dir/.tool-versions`.
+The `asdf-install` resource automatically installs missing plugins when using the `directory` parameter. The config below installs asdf and then installs all tool versions specified in `~/path/to/dir/.tool-versions`.
 
 ```json title="codify.jsonc"
 [
   {
-    "type":  "asdf"
+    "type": "asdf"
   },
   {
     "type": "asdf-install",
@@ -81,27 +67,20 @@ in `~/path/to/dir/.tool-versions`.
 ]
 ```
 
-#### Installing nodejs globally
+### Install and version-pin a tool
 
-Asdf provides the `latest` keyword shortcut. Other-wise fully
-qualified version (down to the patch level) must be used. This config will install asdf,
-the nodejs plugin, install node versions `latest` and `20.18.0`, and then load
-`20.18.0` as the globally available version.
+Asdf provides the `latest` keyword as a shortcut. Otherwise a fully qualified version (down to the patch level) must be used. The config below installs asdf, the Node.js plugin, and two Node.js versions.
 
 ```json title="codify.jsonc"
 [
   {
-    "type":  "asdf"
+    "type": "asdf",
+    "plugins": ["nodejs"]
   },
   {
-    "type": "asdf-plugin",
+    "type": "asdf-install",
     "plugin": "nodejs",
     "versions": ["latest", "20.18.0"]
-  },
-  {
-    "type": "asdf-global",
-    "plugin": "nodejs",
-    "version": "20.18.0"
   }
 ]
 ```

docs/resources/(resources)/asdf/meta.json

@@ -1,4 +1,4 @@
 {
   "title": "asdf",
-  "pages": ["asdf", "asdf-global", "asdf-install", "asdf-local", "asdf-plugin"]
+  "pages": ["asdf", "asdf-install", "asdf-plugin"]
 }

docs/resources/(resources)/ollama.mdx

@@ -0,0 +1,52 @@
+---
+title: ollama
+description: A reference page for the ollama resource
+---
+
+The ollama resource installs [Ollama](https://ollama.com/), a runtime for running large language models locally. On macOS it is installed via Homebrew and started as a background service; on Linux the official install script is used, which registers a systemd service automatically.
+
+## Parameters:
+
+- **models**: *(array[string])* AI models to pull and keep installed. Model names match those listed in the [Ollama library](https://ollama.com/library) (e.g. `"llama3.2"`, `"mistral"`, `"qwen2.5-coder:7b"`). Codify adds models that are missing and removes models that are no longer listed.
+
+## Example usage:
+
+### Install Ollama with a single model
+
+```json title="codify.jsonc"
+[
+  {
+    "type": "ollama",
+    "models": ["llama3.2"]
+  }
+]
+```
+
+### Install Ollama with multiple models
+
+```json title="codify.jsonc"
+[
+  {
+    "type": "ollama",
+    "models": ["llama3.2", "mistral", "qwen2.5-coder"]
+  }
+]
+```
+
+### Install Ollama without pulling any models
+
+```json title="codify.jsonc"
+[
+  {
+    "type": "ollama"
+  }
+]
+```
+
+## Notes:
+
+- On macOS, Homebrew must be installed before applying the ollama resource. The [homebrew](/docs/resources/homebrew) resource can install it.
+- On Linux, the official install script (`https://ollama.com/install.sh`) requires `curl` and `sudo` privileges. The script creates an `ollama` system user and registers a systemd service.
+- Models can be large (several gigabytes each). Make sure you have sufficient disk space before adding them to your configuration.
+- To see available model names and tags, visit [ollama.com/library](https://ollama.com/library) or run `ollama list` after installation.
+- Removing the ollama resource stops and uninstalls the Ollama binary but does **not** automatically remove downloaded model data (stored in `~/.ollama` on macOS or `/usr/share/ollama` on Linux for system-level data).

docs/resources/(resources)/python/meta.json

@@ -1,4 +1,4 @@
 {
   "title": "python",
-  "pages": ["pip", "pip-sync", "pyenv", "venv-project", "virtualenv", "virtualenv-project"]
+  "pages": ["pip", "pip-sync", "pyenv", "uv", "venv-project", "virtualenv", "virtualenv-project"]
 }

docs/resources/(resources)/python/uv.mdx

@@ -0,0 +1,59 @@
+---
+title: uv
+description: A reference page for the uv resource
+---
+
+The uv resource installs [uv](https://github.com/astral-sh/uv), an extremely fast Python package and project manager from [Astral](https://astral.sh/). uv can replace pip, pip-tools, pyenv, virtualenv, and Poetry in a single tool. On macOS it is installed via Homebrew; on Linux the official install script is used.
+
+## Parameters:
+
+- **pythonVersions**: *(array[string])* Python versions to install via `uv python install` (e.g. `["3.12", "3.11"]`). Codify adds missing versions and removes versions that are no longer listed.
+
+- **global**: *(string)* The Python version to set as the global default. This runs `uv python pin --global <version>` with the `--default` flag, which exposes `python` and `python3` on PATH as shims pointing to the selected version.
+
+- **tools**: *(array[string])* Global CLI tools to install via `uv tool install` (e.g. `["ruff", "black", "httpie"]`). Each tool is installed into its own isolated environment and exposed on PATH. Codify adds missing tools and removes tools that are no longer listed.
+
+## Example usage:
+
+### Install uv with Python versions and set a global default
+
+```json title="codify.jsonc"
+[
+  {
+    "type": "uv",
+    "pythonVersions": ["3.12", "3.11"],
+    "global": "3.12"
+  }
+]
+```
+
+### Install uv with Python and global CLI tools
+
+```json title="codify.jsonc"
+[
+  {
+    "type": "uv",
+    "pythonVersions": ["3.12"],
+    "global": "3.12",
+    "tools": ["ruff", "black", "httpie"]
+  }
+]
+```
+
+### Install uv only (no Python versions)
+
+```json title="codify.jsonc"
+[
+  {
+    "type": "uv"
+  }
+]
+```
+
+## Notes:
+
+- On macOS, Homebrew must be installed before applying the uv resource. The [homebrew](/docs/resources/homebrew) resource can install it.
+- On Linux, the official install script places the `uv` and `uvx` binaries in `~/.local/bin`. Codify adds this directory to `PATH` in your shell RC file automatically.
+- The `global` parameter requires the version to be installed (either via `pythonVersions` or already present on the system).
+- Tools installed via `tools` are managed as a stateful list — tools present in your configuration are added; tools removed from the list are uninstalled.
+- uv is compatible with existing `pyproject.toml`, `requirements.txt`, and `pip` workflows. It does not conflict with pip or virtualenv.

docs/resources/(resources)/ruby/meta.json

@@ -0,0 +1,4 @@
+{
+  "title": "ruby",
+  "pages": ["rbenv"]
+}