conda-features 0.1.0__tar.gz

conda_features-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+.DS_Store
+.pixi/
+.pytest_cache/
+.ruff_cache/
+__pycache__/
+*.py[cod]
+dist/
+conda-dist/
+docs/_build/
+*.egg-info/

conda_features-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, conda-features contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

conda_features-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.5
+Name: conda-features
+Version: 0.1.0
+Summary: Discover and configure optional features from installed conda plugins
+Project-URL: Homepage, https://github.com/jezdez/conda-features
+Project-URL: Documentation, https://jezdez.github.io/conda-features/
+Project-URL: Issues, https://github.com/jezdez/conda-features/issues
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: filelock>=3.16
+Requires-Dist: pluggy>=1.5
+Description-Content-Type: text/markdown
+
+# conda-features
+
+A conda plugin for discovering and managing optional features supplied by installed providers. Inspect saved choices and readiness, preview changes, deploy prerequisites, and recover interrupted setup without claiming to observe provider execution.
+
+The core package ships no feature catalog. The separate `conda-features-examples` distribution provides real PyPI and shell-completion deployments. These can install packages and change configuration or shell files after confirmation.
+
+## Install and use
+
+Use Python 3.12 or newer with conda 26.9.4 or newer. Install into the Python environment running conda, not just an environment you want to configure. These packages are not published on PyPI yet. The current installation method is from Git, which requires Git and pip:
+
+```sh
+python -m conda --version
+python -m pip install "conda-features @ git+https://github.com/jezdez/conda-features.git@main"
+python -m pip install "conda-features-examples @ git+https://github.com/jezdez/conda-features.git@main#subdirectory=packages/conda-features-examples"
+```
+
+Use that installation's conda command:
+
+```sh
+conda feature list
+conda feature explain conda-pypi
+conda feature enable conda-pypi --user --dry-run
+```
+
+The first distribution supplies the command. The second supplies real deployment declarations. Enabling a feature can then install missing upstream prerequisites after confirmation. See [Installation](docs/how-to/install.md) for choosing the correct host interpreter and [the tutorial](docs/tutorials/first-deployment.md) for a complete preview, enable, and disable sequence.
+
+## Documentation
+
+The documentation is published to [GitHub Pages](https://jezdez.github.io/conda-features/) from `main`. Pull requests build the site without deploying it.
+
+Start with the [documentation index](docs/index.md) or the [first deployment tutorial](docs/tutorials/first-deployment.md), which uses your installed plugin and a temporary configuration file.
+
+The Sphinx documentation follows Diátaxis: tutorials, how-to guides, reference, and explanation. Contributor setup and documentation build commands are in [Development](docs/how-to/develop.md).
+
+- [Manage features and scopes](docs/how-to/manage-features.md)
+- [Deploy real PyPI support and shell completion](docs/how-to/deploy-providers.md)
+- [Diagnose and recover setup](docs/how-to/recover.md)
+- [Migrate and transfer choices](docs/how-to/transfer.md)
+- [Build your first provider](docs/tutorials/create-provider.md)
+- [Command reference](docs/reference/cli.md)
+- [Provider and step API](docs/reference/providers.md)
+- [Portable intent format](docs/reference/intent.md)
+- [Configuration, ownership, and recovery explained](docs/explanation/deployment.md)
+- [Development and verification](docs/how-to/develop.md)
+
+The [design document](DESIGN.md) includes goals beyond the current implementation.
+
+## Commands at a glance
+
+```text
+conda feature list
+conda feature explain FEATURE
+conda feature enable FEATURE --dry-run
+conda feature configure FEATURE KEY=VALUE --dry-run
+conda feature disable FEATURE --dry-run
+conda feature diagnose --json
+conda feature repair FEATURE --dry-run
+conda feature migrate FEATURE --dry-run
+conda feature cleanup FEATURE --dry-run
+conda feature export --file source.yaml
+conda feature apply intent.json --file destination.yaml --dry-run
+```
+
+Use an installed feature ID in place of `FEATURE`. Mutations require confirmation or `--yes`. Deployment dry-runs may solve packages and refresh caches without installing packages or writing managed resources. `--file` isolates conda configuration, not package installation or shell files.
+
+## Current limits
+
+Authentication, telemetry, remote catalogs, and automatic migration are not implemented. Environment checks cover explicit targets and the current user's registry, not a complete machine inventory. Runtime activity remains unknown. Generic package and shell migrations need provider-specific handling, and deployment intent is applied one feature at a time.
+
+CI is configured for Linux x64, Windows x64, and ARM macOS core tests, with real-provider integration on Linux. See the relevant workflow results for the revision you use rather than assuming every newer conda version or shell has been verified.

conda_features-0.1.0/README.md

@@ -0,0 +1,70 @@
+# conda-features
+
+A conda plugin for discovering and managing optional features supplied by installed providers. Inspect saved choices and readiness, preview changes, deploy prerequisites, and recover interrupted setup without claiming to observe provider execution.
+
+The core package ships no feature catalog. The separate `conda-features-examples` distribution provides real PyPI and shell-completion deployments. These can install packages and change configuration or shell files after confirmation.
+
+## Install and use
+
+Use Python 3.12 or newer with conda 26.9.4 or newer. Install into the Python environment running conda, not just an environment you want to configure. These packages are not published on PyPI yet. The current installation method is from Git, which requires Git and pip:
+
+```sh
+python -m conda --version
+python -m pip install "conda-features @ git+https://github.com/jezdez/conda-features.git@main"
+python -m pip install "conda-features-examples @ git+https://github.com/jezdez/conda-features.git@main#subdirectory=packages/conda-features-examples"
+```
+
+Use that installation's conda command:
+
+```sh
+conda feature list
+conda feature explain conda-pypi
+conda feature enable conda-pypi --user --dry-run
+```
+
+The first distribution supplies the command. The second supplies real deployment declarations. Enabling a feature can then install missing upstream prerequisites after confirmation. See [Installation](docs/how-to/install.md) for choosing the correct host interpreter and [the tutorial](docs/tutorials/first-deployment.md) for a complete preview, enable, and disable sequence.
+
+## Documentation
+
+The documentation is published to [GitHub Pages](https://jezdez.github.io/conda-features/) from `main`. Pull requests build the site without deploying it.
+
+Start with the [documentation index](docs/index.md) or the [first deployment tutorial](docs/tutorials/first-deployment.md), which uses your installed plugin and a temporary configuration file.
+
+The Sphinx documentation follows Diátaxis: tutorials, how-to guides, reference, and explanation. Contributor setup and documentation build commands are in [Development](docs/how-to/develop.md).
+
+- [Manage features and scopes](docs/how-to/manage-features.md)
+- [Deploy real PyPI support and shell completion](docs/how-to/deploy-providers.md)
+- [Diagnose and recover setup](docs/how-to/recover.md)
+- [Migrate and transfer choices](docs/how-to/transfer.md)
+- [Build your first provider](docs/tutorials/create-provider.md)
+- [Command reference](docs/reference/cli.md)
+- [Provider and step API](docs/reference/providers.md)
+- [Portable intent format](docs/reference/intent.md)
+- [Configuration, ownership, and recovery explained](docs/explanation/deployment.md)
+- [Development and verification](docs/how-to/develop.md)
+
+The [design document](DESIGN.md) includes goals beyond the current implementation.
+
+## Commands at a glance
+
+```text
+conda feature list
+conda feature explain FEATURE
+conda feature enable FEATURE --dry-run
+conda feature configure FEATURE KEY=VALUE --dry-run
+conda feature disable FEATURE --dry-run
+conda feature diagnose --json
+conda feature repair FEATURE --dry-run
+conda feature migrate FEATURE --dry-run
+conda feature cleanup FEATURE --dry-run
+conda feature export --file source.yaml
+conda feature apply intent.json --file destination.yaml --dry-run
+```
+
+Use an installed feature ID in place of `FEATURE`. Mutations require confirmation or `--yes`. Deployment dry-runs may solve packages and refresh caches without installing packages or writing managed resources. `--file` isolates conda configuration, not package installation or shell files.
+
+## Current limits
+
+Authentication, telemetry, remote catalogs, and automatic migration are not implemented. Environment checks cover explicit targets and the current user's registry, not a complete machine inventory. Runtime activity remains unknown. Generic package and shell migrations need provider-specific handling, and deployment intent is applied one feature at a time.
+
+CI is configured for Linux x64, Windows x64, and ARM macOS core tests, with real-provider integration on Linux. See the relevant workflow results for the revision you use rather than assuming every newer conda version or shell has been verified.

conda_features-0.1.0/pyproject.toml

@@ -0,0 +1,94 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "conda-features"
+version = "0.1.0"
+description = "Discover and configure optional features from installed conda plugins"
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = ["filelock>=3.16", "pluggy>=1.5"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/src", "/README.md", "/LICENSE", "/pyproject.toml"]
+
+[project.urls]
+Homepage = "https://github.com/jezdez/conda-features"
+Documentation = "https://jezdez.github.io/conda-features/"
+Issues = "https://github.com/jezdez/conda-features/issues"
+
+[project.entry-points.conda]
+conda-features = "conda_features.plugin"
+
+[tool.pixi.workspace]
+channels = ["conda-forge"]
+platforms = ["osx-arm64", "linux-64", "win-64"]
+
+[tool.pixi.dependencies]
+python = "3.12.*"
+conda = "26.9.4.*"
+filelock = ">=3.16"
+pluggy = ">=1.5"
+pytest = ">=8"
+ruff = ">=0.14"
+ty = "*"
+pip = "*"
+hatchling = "*"
+
+[tool.pixi.pypi-dependencies]
+conda-features = { path = ".", editable = true }
+
+[tool.pixi.tasks]
+test = "pytest"
+lint = "ruff check ."
+format-check = "ruff format --check ."
+type-check = "ty check src"
+
+[tool.pixi.feature.examples.pypi-dependencies]
+conda-features-examples = { path = "packages/conda-features-examples", editable = true }
+
+[tool.pixi.feature.examples.tasks]
+test-examples = "pytest tests/test_examples.py"
+
+[tool.pixi.feature.integration.dependencies]
+conda-pypi = "0.13.*"
+conda-rattler-solver = "26.10.*"
+conda-completion = "0.3.2.*"
+
+[tool.pixi.feature.integration.tasks]
+test-integration = "pytest tests/test_examples.py"
+
+[tool.pixi.feature.docs.dependencies]
+sphinx = ">=8"
+myst-parser = ">=4"
+conda-sphinx-theme = ">=0.3"
+sphinx-design = ">=0.6"
+
+[tool.pixi.feature.docs.tasks]
+docs = "sphinx-build -W --keep-going -n -b dirhtml docs docs/_build/dirhtml"
+
+[tool.pixi.feature.release.dependencies]
+python = "3.12.*"
+python-build = ">=1.2"
+hatchling = ">=1.27"
+twine = ">=6.2"
+rattler-build = ">=0.74"
+
+[tool.pixi.environments]
+default = { features = [], solve-group = "default" }
+examples = { features = ["examples"], solve-group = "default" }
+integration = { features = ["examples", "integration"] }
+docs = { features = ["docs"], solve-group = "default" }
+release = { features = ["release"], no-default-feature = true }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I", "UP"]

conda_features-0.1.0/src/conda_features/__init__.py

@@ -0,0 +1,75 @@
+"""Feature management for conda.
+
+Install this distribution in the Python environment running conda. During
+development, ``pixi run python -m conda feature --help`` uses that environment.
+
+User commands::
+
+    conda feature list
+    conda feature explain sample
+    conda feature enable sample --dry-run
+    conda feature enable sample --yes
+    conda feature configure sample plugins.sample_limit=4 --yes
+    conda feature disable sample --yes
+    conda feature disable --all --yes
+
+Use ``--prefix PATH`` for an existing environment, ``--system`` for the conda
+installation, or ``--user`` (the default). Providers declare supported scopes.
+``--file PATH`` selects a standalone user-scope file, with environment-variable
+overrides still applied. Use a conda-recognized name (``.condarc``, ``condarc``,
+or a YAML extension). Its parent directory must exist. Other scopes use
+conda's normal configuration search path. ``--json`` produces one JSON result.
+Exit codes are 0 for success or preview, 1 for an operation error, and 2 for
+argument parsing errors. Noninteractive mutations require ``--yes``.
+
+Providers register their settings with conda's ``conda_settings`` hook and
+yield ``conda_features.models.Feature`` objects from a Pluggy hook. Register
+the provider module in their pyproject.toml::
+
+    [project.entry-points.conda_features]
+    my-provider = "my_provider.features"
+
+An example declaration::
+
+    from conda_features.models import Feature
+    from conda_features.hooks import hookimpl
+
+    @hookimpl
+    def conda_features():
+        yield Feature(
+            name="sample",
+            description="Enable the provider's optional behavior",
+            enabled_setting="plugins.sample_enabled",
+            settings=("plugins.sample_limit",),
+        )
+
+The provider reads its boolean setting to control behavior. This plugin does
+not intercept provider execution. Declarations must be cheap to import and
+must not access the network, credentials, or files. Installed providers are
+trusted Python code, not sandboxed data. Only expose non-secret settings.
+Required settings check for missing values, not login or service availability.
+Status reports the selected file's saved choice separately from the effective
+boolean setting and readiness. Runtime activity is unknown, even when a setting
+is enabled and a prerequisite is blocked. Providers enforce their own checks.
+
+Enable refuses unmet dependencies instead of implicitly opting into them.
+Disable preserves other settings and installed packages. Changes take effect
+on the next invocation. Repeating a persisted operation requires no write.
+An explicit disable is saved even if a temporary override already disables it.
+Writes preserve comments and unrelated settings, use atomic file replacement,
+and reject previews whose destination changed. A sidecar lock coordinates this
+plugin's writers, but external editors do not honor it.
+
+Deployment providers can omit enabled_setting and declare steps such as
+InstallPackages, SetSetting, and EnsureChannel. Feature coordinates their
+planning, application, reverse-order disable, and recovery receipts.
+Provider-specific steps implement Step or ManagedBlock. Plans carry public
+changes and private apply data. The CLI confirms before applying. The separate
+conda-features-examples package deploys real PyPI support and shell completion,
+including installation of missing prerequisites. Bulk disable handles boolean
+features and identifies deployments that need individual disable commands.
+
+Without an installed provider, list reports an empty catalog. Authentication,
+cross-environment dependency scanning, telemetry, migrations, export, and
+doctor integration are not implemented.
+"""

conda_features-0.1.0/src/conda_features/cli/__init__.py

@@ -0,0 +1 @@
+"""Command-line parsing, dispatch, and rendering."""

conda_features-0.1.0/src/conda_features/cli/apply.py

@@ -0,0 +1,26 @@
+"""Apply a portable intent document to an explicitly selected destination."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def configure_parser(parser):
+    parser.add_argument("manifest", type=Path)
+
+
+def execute(args, catalog, ctx, path, scope):
+    from ..operations.intent import IntentError, plan_intent
+    from .common import confirm_and_apply
+
+    if not (args.user or args.system or args.prefix or args.file):
+        raise IntentError(
+            "Applying intent requires an explicit --user, --system, --prefix, or --file destination."
+        )
+    try:
+        document = json.loads(args.manifest.read_text())
+    except (OSError, ValueError) as exc:
+        raise IntentError("Cannot read feature intent JSON.") from exc
+    plan = plan_intent(document, catalog, ctx, path, scope)
+    return confirm_and_apply(args, catalog, ctx, plan)

conda_features-0.1.0/src/conda_features/cli/cleanup.py

@@ -0,0 +1,16 @@
+"""Remove obsolete opt-ins for unconditional graduated features."""
+
+from __future__ import annotations
+
+
+def configure_parser(parser):
+    parser.add_argument("feature")
+
+
+def execute(args, catalog, ctx, path, scope):
+    from .common import confirm_and_apply, select_feature
+
+    feature = select_feature(catalog, args.feature)
+    return confirm_and_apply(
+        args, catalog, ctx, feature.cleanup(catalog, ctx, path, scope)
+    )

conda_features-0.1.0/src/conda_features/cli/commands.py

@@ -0,0 +1,35 @@
+"""Load the selected subcommand and render its result."""
+
+import json
+import sys
+from argparse import Namespace
+from importlib import import_module
+
+from conda import CondaError
+from conda.base.context import context
+
+from ..operations.discovery import discover
+from ..operations.intent import IntentError
+from ..operations.validation import validate_catalog
+from .output import render
+from .targets import target
+
+
+def execute(args: Namespace) -> int:
+    try:
+        catalog = discover()
+        path, scope, ctx = target(args)
+        validate_catalog(catalog, ctx)
+        command = import_module(f".{args.operation}", package=__package__)
+        result = command.execute(args, catalog, ctx, path, scope)
+    except (CondaError, OSError, ValueError, TypeError, OverflowError) as exc:
+        message = str(exc)
+        if args.operation in ("export", "apply") and not isinstance(exc, IntentError):
+            message = "Intent operation failed. Inspect the local configuration and providers. Review with --dry-run and pass --yes only after approving the changes. Configuration values are omitted from this error."
+        if context.json:
+            print(json.dumps({"error": message}))
+        else:
+            print(message, file=sys.stderr)
+        return 1
+    render(result)
+    return 0

conda_features-0.1.0/src/conda_features/cli/common.py

@@ -0,0 +1,90 @@
+"""Shared feature selection and confirmed configuration writes."""
+
+import sys
+from pathlib import Path
+
+from conda import CondaError
+from conda.base.context import context
+from conda.common.configuration import YamlRawParameter
+
+from ..models import Catalog, Feature
+from ..operations.configuration import apply_change
+from ..operations.dependencies import guard_plan, projected_context, verify_guard
+from ..operations.settings import fingerprint
+from .targets import target
+
+
+def select_feature(catalog: Catalog, name: str) -> Feature:
+    if name not in catalog:
+        raise CondaError(f"Unknown feature: {name}")
+    return catalog[name][1]
+
+
+def confirm_and_apply(args, catalog, ctx, plan):
+    guard_plan(args, catalog, plan)
+    result = {
+        key: plan[key]
+        for key in (
+            "operation",
+            "features",
+            "scope",
+            "path",
+            "changes",
+            "checked_environments",
+            "discovery",
+            "remove",
+        )
+        if key in plan
+    }
+    if args.dry_run:
+        result["message"] = "Preview only. No changes made."
+    elif not plan["changes"]:
+        result["message"] = "No changes needed."
+    else:
+        if not context.always_yes:
+            if context.json or not sys.stdin.isatty():
+                raise CondaError(
+                    "Review with --dry-run, then pass --yes to apply noninteractively."
+                )
+            print(f"Configuration: {plan['path']} ({plan['scope']})", file=sys.stderr)
+            if plan["checked_environments"]:
+                print(
+                    "Checked environments: " + ", ".join(plan["checked_environments"]),
+                    file=sys.stderr,
+                )
+            print(plan["discovery"], file=sys.stderr)
+            for key, new_value in plan["changes"].items():
+                print(f"  {key} = {new_value}", file=sys.stderr)
+            print("Proceed? [y/N] ", end="", file=sys.stderr, flush=True)
+            if sys.stdin.readline().strip().lower() not in ("y", "yes"):
+                raise CondaError("Cancelled. No changes made.")
+        verify_guard(plan)
+        if "plans" in plan:
+            current = ctx
+            expected = plan["fingerprint"]
+            for child in plan["plans"]:
+                if fingerprint(Path(child["path"])) != expected:
+                    raise CondaError(
+                        "Configuration changed after preview. Review the plan again."
+                    )
+                child["fingerprint"] = expected
+                next_context = projected_context(child, current)
+                catalog[child["features"][-1]][1].apply(child, current)
+                expected = fingerprint(Path(child["path"]))
+                current = next_context
+        elif len(plan["features"]) == 1:
+            catalog[plan["features"][0]][1].apply(plan, ctx)
+        else:
+            apply_change(plan, ctx)
+        YamlRawParameter.cache_clear()
+        _, _, updated = target(args)
+        result["status"] = [
+            catalog[name][1].status(
+                catalog, updated, plan["scope"], path=Path(plan["path"])
+            )
+            for name in plan["features"]
+        ]
+        result["message"] = (
+            "Configuration updated. Takes effect in the next conda invocation."
+        )
+    return result

conda_features-0.1.0/src/conda_features/cli/configure.py

@@ -0,0 +1,22 @@
+"""Validate and change a feature's declared settings."""
+
+from conda import CondaError
+
+
+def configure_parser(parser):
+    parser.add_argument("feature")
+    parser.add_argument("settings", nargs="+", metavar="KEY=VALUE")
+
+
+def execute(args, catalog, ctx, path, scope):
+    from .common import confirm_and_apply, select_feature
+
+    feature = select_feature(catalog, args.feature)
+    settings = {}
+    for item in args.settings:
+        key, separator, new_value = item.partition("=")
+        if not separator or not key or key in settings:
+            raise CondaError("Provide distinct declared settings as KEY=VALUE.")
+        settings[key] = new_value
+    plan = feature.configure(catalog, ctx, path, scope, settings)
+    return confirm_and_apply(args, catalog, ctx, plan)

conda_features-0.1.0/src/conda_features/cli/diagnose.py

@@ -0,0 +1,13 @@
+"""Inspect local feature readiness and retained deployment receipts."""
+
+from __future__ import annotations
+
+
+def configure_parser(parser):
+    pass
+
+
+def execute(args, catalog, ctx, path, scope):
+    from ..operations.diagnostics import diagnose
+
+    return diagnose(catalog, ctx, path, scope)

conda_features-0.1.0/src/conda_features/cli/disable.py

@@ -0,0 +1,44 @@
+"""Preview and disable one feature or all features at a scope."""
+
+
+def configure_parser(parser):
+    parser.add_argument("feature", nargs="?")
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Disable all declared features at this scope.",
+    )
+
+
+def execute(args, catalog, ctx, path, scope):
+    from ..operations.configuration import plan_change
+    from .common import confirm_and_apply, select_feature
+
+    if args.all:
+        deployments = [
+            name
+            for name, (_, feature) in catalog.items()
+            if feature.enabled_setting is None and scope in feature.scopes
+        ]
+        boolean_catalog = {
+            name: item
+            for name, item in catalog.items()
+            if item[1].enabled_setting is not None
+        }
+        plan = plan_change(
+            boolean_catalog,
+            ctx,
+            path,
+            scope,
+            "disable",
+            args.feature,
+            all_features=True,
+        )
+    else:
+        plan = select_feature(catalog, args.feature).disable(catalog, ctx, path, scope)
+    result = confirm_and_apply(args, catalog, ctx, plan)
+    if args.all and deployments:
+        result["message"] += (
+            " Disable deployment features individually: " + ", ".join(deployments) + "."
+        )
+    return result

conda_features-0.1.0/src/conda_features/cli/enable.py

@@ -0,0 +1,22 @@
+"""Preview and enable an installed feature."""
+
+
+def configure_parser(parser):
+    parser.add_argument("feature")
+    parser.add_argument(
+        "--with-dependencies",
+        action="store_true",
+        help="Preview prerequisite opt-ins at the selected scope.",
+    )
+
+
+def execute(args, catalog, ctx, path, scope):
+    from .common import confirm_and_apply, select_feature
+
+    feature = select_feature(catalog, args.feature)
+    plan = (
+        feature.enable(catalog, ctx, path, scope, with_dependencies=True)
+        if args.with_dependencies
+        else feature.enable(catalog, ctx, path, scope)
+    )
+    return confirm_and_apply(args, catalog, ctx, plan)

conda_features-0.1.0/src/conda_features/cli/explain.py

@@ -0,0 +1,11 @@
+"""Explain a feature's configured state and prerequisites."""
+
+
+def configure_parser(parser):
+    parser.add_argument("feature")
+
+
+def execute(args, catalog, ctx, path, scope):
+    from .common import select_feature
+
+    return select_feature(catalog, args.feature).status(catalog, ctx, scope, path=path)