quadkit-cli 0.0.2__tar.gz → 0.0.3__tar.gz

quadkit_cli-0.0.3/.gitignore

@@ -0,0 +1,24 @@
+# Generated public-repository ignore rules.
+# Private monorepo paths are intentionally not referenced here.
+
+__pycache__/
+*.py[cod]
+*.so
+*.egg-info/
+.venv/
+venv/
+.env
+.env.*
+!.env.example
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+coverage.xml
+htmlcov/
+build/
+dist/
+*.log
+.DS_Store
+.idea/
+.vscode/

quadkit_cli-0.0.3/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.5
+Name: quadkit-cli
+Version: 0.0.3
+Summary: Command-line interface for Quadkit Framework - Project scaffolding, code generation, and development tools
+Project-URL: Homepage, https://quadkit.dev
+Project-URL: Repository, https://github.com/dbtinoy-/quadkit
+Project-URL: Documentation, https://quadkit.dev
+Project-URL: Issues, https://github.com/dbtinoy-/quadkit/issues
+Project-URL: Changelog, https://github.com/dbtinoy-/quadkit/blob/main/CHANGELOG.md
+Author-email: Quadkit Framework Team <team@quadkit.dev>
+Maintainer-email: Quadkit Framework Team <team@quadkit.dev>
+License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: cli,codegen,command-line,devtools,framework,scaffolding
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: quadkit-contracts>=0.0.2
+Requires-Dist: quadkit>=0.0.2
+Requires-Dist: rich>=13.0.0
+Requires-Dist: shellingham>=1.5.0
+Requires-Dist: tomli>=2.0.0
+Requires-Dist: typer[all]>=0.9.0
+Requires-Dist: watchfiles>=0.21.0
+Provides-Extra: all
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'all'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'all'
+Requires-Dist: pytest>=8.0.0; extra == 'all'
+Requires-Dist: quadkit-testing>=0.0.2; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'test'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
+Requires-Dist: pytest>=8.0.0; extra == 'test'
+Requires-Dist: quadkit-testing>=0.0.2; extra == 'test'
+Description-Content-Type: text/markdown
+
+# quadkit-cli
+
+The `quadkit` command line: project scaffolding, generators, a smart
+runner, and administrative commands for every stage of the application
+lifecycle. Contributor-based — other packages can register their own
+commands.
+
+For day-to-day Quadkit developers: scaffold, generate, run, inspect.
+
+## Installation
+
+```bash
+uv add quadkit-cli
+# or as a standalone tool:
+uv tool install quadkit-cli
+```
+
+Requires **Python >= 3.11**.
+
+## Minimal working example
+
+There is no code to write — the product is the command line:
+
+```bash
+# Create a new project (template defaults to web-api)
+quadkit new project my-api
+
+# Generate application code (list all generators: quadkit gen list)
+quadkit gen provider MyProvider
+quadkit gen controller Orders
+
+# Serve the application; reload is on by default, pass --no-reload in prod
+quadkit run my_app.app:create_app --host 0.0.0.0 --port 8000 --workers 4
+```
+
+Global options: `--json` for machine-readable output, `--quiet`,
+`--debug`, `--no-color`, and `--config <path>` to point at a specific
+`application.yaml`.
+
+## Command index
+
+| Command | Purpose |
+| --- | --- |
+| `quadkit new project / module / package` | scaffold projects, bounded contexts, and `quadkit-*` extensions |
+| `quadkit init` | initialize Quadkit in an existing project |
+| `quadkit add <provider>` | add a provider to a project (e.g. `database`, `auth`) |
+| `quadkit run [target]` | smart runner — auto-detects `create_app`, sets profile |
+| `quadkit dev start` | production-server startup |
+| `quadkit gen <what>` | code generation (controllers, providers, middleware, tests, more — see `quadkit gen list`) |
+| `quadkit test` / `quadkit lint` | project-level checks |
+| `quadkit db` / `quadkit events` | database / event-schema management |
+| `quadkit config` / `quadkit inspect` / `quadkit shell` | configuration, runtime introspection, REPL |
+| `quadkit project` / `quadkit contrib` / `quadkit system` | project tasks, contributors, system info |
+| `quadkit version` | framework and package versions |
+
+Per-distribution guide:
+[quadkit-cli reference](../../docs/reference/quadkit-cli.md).
+
+## Optional extras
+
+Verified against the package's `pyproject.toml`: `[dev]`, `[test]`,
+`[all]`.
+
+## Configuration
+
+The CLI reads `application.yaml` like any Quadkit application; its own
+section is `cli` (fields include `default_template`, `default_database`,
+`color`, `verbose`), overridable via `QK_CLI__*`, e.g.
+`QK_CLI__COLOR=false`.
+
+## Error handling
+
+Commands report structured failures (use `--json` for machine-readable
+envelopes) and non-zero exit codes; `--debug` surfaces full tracebacks.
+
+## Testing
+
+`quadkit test` runs the project suite; the CLI's own behavior is
+covered by the public test set the release pipeline executes from the
+exported tree.
+
+## Security
+
+The CLI reads configuration and scaffolds code — it does not serve
+traffic. As with every distribution, keep the `0.x` line pinned and
+review release notes on upgrade. Report vulnerabilities privately per
+[SECURITY.md](../../SECURITY.md).
+
+## Stability
+
+Version `0.0.3` in the `0.x` series, released in lockstep with the
+other four distributions; APIs may change between minor versions until
+1.0 — pin an exact version (`quadkit-cli==0.0.3`) or a tight range
+(`>=0.0.3,<0.1.0`). Full policy:
+[stability and compatibility](../../docs/reference/stability.md).
+
+Issues: <https://github.com/dbtinoy-/quadkit/issues>

quadkit_cli-0.0.3/README.md

@@ -0,0 +1,97 @@
+# quadkit-cli
+
+The `quadkit` command line: project scaffolding, generators, a smart
+runner, and administrative commands for every stage of the application
+lifecycle. Contributor-based — other packages can register their own
+commands.
+
+For day-to-day Quadkit developers: scaffold, generate, run, inspect.
+
+## Installation
+
+```bash
+uv add quadkit-cli
+# or as a standalone tool:
+uv tool install quadkit-cli
+```
+
+Requires **Python >= 3.11**.
+
+## Minimal working example
+
+There is no code to write — the product is the command line:
+
+```bash
+# Create a new project (template defaults to web-api)
+quadkit new project my-api
+
+# Generate application code (list all generators: quadkit gen list)
+quadkit gen provider MyProvider
+quadkit gen controller Orders
+
+# Serve the application; reload is on by default, pass --no-reload in prod
+quadkit run my_app.app:create_app --host 0.0.0.0 --port 8000 --workers 4
+```
+
+Global options: `--json` for machine-readable output, `--quiet`,
+`--debug`, `--no-color`, and `--config <path>` to point at a specific
+`application.yaml`.
+
+## Command index
+
+| Command | Purpose |
+| --- | --- |
+| `quadkit new project / module / package` | scaffold projects, bounded contexts, and `quadkit-*` extensions |
+| `quadkit init` | initialize Quadkit in an existing project |
+| `quadkit add <provider>` | add a provider to a project (e.g. `database`, `auth`) |
+| `quadkit run [target]` | smart runner — auto-detects `create_app`, sets profile |
+| `quadkit dev start` | production-server startup |
+| `quadkit gen <what>` | code generation (controllers, providers, middleware, tests, more — see `quadkit gen list`) |
+| `quadkit test` / `quadkit lint` | project-level checks |
+| `quadkit db` / `quadkit events` | database / event-schema management |
+| `quadkit config` / `quadkit inspect` / `quadkit shell` | configuration, runtime introspection, REPL |
+| `quadkit project` / `quadkit contrib` / `quadkit system` | project tasks, contributors, system info |
+| `quadkit version` | framework and package versions |
+
+Per-distribution guide:
+[quadkit-cli reference](../../docs/reference/quadkit-cli.md).
+
+## Optional extras
+
+Verified against the package's `pyproject.toml`: `[dev]`, `[test]`,
+`[all]`.
+
+## Configuration
+
+The CLI reads `application.yaml` like any Quadkit application; its own
+section is `cli` (fields include `default_template`, `default_database`,
+`color`, `verbose`), overridable via `QK_CLI__*`, e.g.
+`QK_CLI__COLOR=false`.
+
+## Error handling
+
+Commands report structured failures (use `--json` for machine-readable
+envelopes) and non-zero exit codes; `--debug` surfaces full tracebacks.
+
+## Testing
+
+`quadkit test` runs the project suite; the CLI's own behavior is
+covered by the public test set the release pipeline executes from the
+exported tree.
+
+## Security
+
+The CLI reads configuration and scaffolds code — it does not serve
+traffic. As with every distribution, keep the `0.x` line pinned and
+review release notes on upgrade. Report vulnerabilities privately per
+[SECURITY.md](../../SECURITY.md).
+
+## Stability
+
+Version `0.0.3` in the `0.x` series, released in lockstep with the
+other four distributions; APIs may change between minor versions until
+1.0 — pin an exact version (`quadkit-cli==0.0.3`) or a tight range
+(`>=0.0.3,<0.1.0`). Full policy:
+[stability and compatibility](../../docs/reference/stability.md).
+
+Issues: <https://github.com/dbtinoy-/quadkit/issues>

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/example.yaml

@@ -5,7 +5,7 @@
 
 cli:
   # Scaffolding Defaults
-  default_template: "web-api"   # Template used by `lex new` (QK_CLI__DEFAULT_TEMPLATE)
+  default_template: "web-api"   # Template used by `qk new` (QK_CLI__DEFAULT_TEMPLATE)
   default_database: "postgres"  # Database driver scaffold uses (QK_CLI__DEFAULT_DATABASE)
 
   # Output

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quadkit-cli"
-version = "0.0.2"
+version = "0.0.3"
 description = "Command-line interface for Quadkit Framework - Project scaffolding, code generation, and development tools"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -104,7 +104,7 @@ test = [
 ]
 
 [tool.ruff]
-extend = "../../../pyproject.toml"
+extend = "../../pyproject.toml"
 line-length = 88
 target-version = "py311"
 
@@ -169,3 +169,4 @@ addopts = ["--cov=quadkit.cli", "--cov-report=term", "--cov-fail-under=84"]
 packages = [
     "src/quadkit",
 ]
+

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/src/quadkit/cli/commands/db_bootstrap.py

@@ -8,12 +8,13 @@ from typing import Any
 import typer
 
 from quadkit.cli.output import OutputManager
+from quadkit.cli.package_names import module_for
 
 
 async def _bootstrap_migration_runner() -> tuple[Any, Any, Any]:
     """Used for direct migration execution (run/rollback/status) via the DI container.
 
-    Prefers the DI-managed runner when quadkit-sql is available so that
+    Prefers the DI-managed runner when the database provider is available so that
     connection pooling and observability hooks are active.  Falls back to the
     legacy factory when the package is not installed.
 
@@ -30,7 +31,7 @@ async def _bootstrap_migration_runner() -> tuple[Any, Any, Any]:
         from quadkit.di.container import Container
         from quadkit.di.orchestrator import ProviderOrchestrator
 
-        sql_provider_mod = importlib.import_module("quadkit.sql.di.provider")
+        sql_provider_mod = importlib.import_module(module_for('sql', 'di.provider'))
         DBDIProvider = sql_provider_mod.DatabaseProvider
 
         container = Container()
@@ -45,15 +46,15 @@ async def _bootstrap_migration_runner() -> tuple[Any, Any, Any]:
         return runner, orchestrator, container
 
     except ImportError:
-        # quadkit-sql not installed — fall back to legacy direct factory.
+        # Database provider not installed — fall back to legacy direct factory.
         try:
-            db_cli = importlib.import_module("quadkit.sql.cli")
+            db_cli = importlib.import_module(module_for('sql', 'cli'))
             manager = db_cli.create_cli_migration_manager(db_url)
             return manager, None, None
         except ImportError as e:
             out = OutputManager()
             out.error(
-                f"quadkit-sql is required for database commands — install it with: uv add quadkit-sql ({e})"
+                f"The optional database provider is required for database commands ({e})"
             )
             raise typer.Exit(1) from None
 
@@ -77,9 +78,9 @@ async def _bootstrap_db_provider() -> tuple[Any, Any]:
         from quadkit.di.container import Container
         from quadkit.di.orchestrator import ProviderOrchestrator
 
-        sql_provider_mod = importlib.import_module("quadkit.sql.di.provider")
+        sql_provider_mod = importlib.import_module(module_for('sql', 'di.provider'))
         DatabaseProvider = sql_provider_mod.DatabaseProvider
-        sql_config_mod = importlib.import_module("quadkit.sql.config")
+        sql_config_mod = importlib.import_module(module_for('sql', 'config'))
         DatabaseConfig = sql_config_mod.DatabaseConfig
 
         container = Container()
@@ -99,7 +100,7 @@ async def _bootstrap_db_provider() -> tuple[Any, Any]:
     except ImportError as e:
         out = OutputManager()
         out.error(
-            f"quadkit-sql is required for database commands — install it with: uv add quadkit-sql ({e})"
+            f"The optional database provider is required for database commands ({e})"
         )
         raise typer.Exit(1) from None
 
@@ -114,12 +115,12 @@ async def get_migration_manager() -> Any:
     try:
         import os
 
-        db_cli = importlib.import_module("quadkit.sql.cli")
+        db_cli = importlib.import_module(module_for('sql', 'cli'))
         db_url = os.environ.get("DATABASE_URL", "sqlite:///./dev.db")
         return db_cli.create_cli_migration_manager(db_url)
     except ImportError as e:
         out = OutputManager()
-        out.error(f"Failed to import quadkit-sql: {e}")
+        out.error(f"Failed to import the optional database provider: {e}")
         raise typer.Exit(1) from None
 
 

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/src/quadkit/cli/commands/db_commands_ops.py

@@ -89,8 +89,8 @@ def inspect_(
                         out.table(["Column", "Type", "Nullable"], rows)
 
         except ImportError as e:
-            out.error(f"quadkit-sql not installed: {e}")
-            out.info("Install with: pip install quadkit-sql")
+            out.error(f"The optional database provider is not installed: {e}")
+            out.info("Install the provider before retrying")
             raise typer.Exit(1) from None
         except Exception as e:  # noqa: BLE001 — any inspect failure is a CLI error
             out.error(f"Failed to inspect database: {e}")

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/src/quadkit/cli/commands/events.py

@@ -2,7 +2,7 @@
 
 Provides ``quadkit events migrate`` and ``quadkit events status`` to
 inspect and apply event-schema migrations managed by
-:class:`~quadkit.events.schema.evolution.SchemaEvolution`.
+:class:`SchemaEvolution` from the optional event provider.
 """
 
 from __future__ import annotations
@@ -13,6 +13,7 @@ from typing import Annotated, Any
 import typer
 
 from quadkit.cli.output import OutputManager
+from quadkit.cli.package_names import module_for
 from quadkit.cli.runtime import handle_errors
 
 app = typer.Typer(name="events")
@@ -21,7 +22,7 @@ app = typer.Typer(name="events")
 def _make_evolution() -> Any:
     """Bootstrap an in-memory SchemaRegistry and SchemaEvolution.
 
-    When ``quadkit-events`` is installed and discoverable, this returns a
+    When the optional event provider is installed and discoverable, this returns a
     properly wired instance.  Raises :exc:`typer.Exit` with a readable error
     message when the package is not available.
     """
@@ -29,15 +30,16 @@ def _make_evolution() -> Any:
     try:
         import importlib as _importlib
 
-        _evo_mod = _importlib.import_module("quadkit.events.schema.evolution")
-        _reg_mod = _importlib.import_module("quadkit.events.schema.registry")
-        _store_mod = _importlib.import_module("quadkit.events.schema.store")
+        _evo_mod = _importlib.import_module(module_for('events', 'schema.evolution'))
+        _reg_mod = _importlib.import_module(module_for('events', 'schema.registry'))
+        _store_mod = _importlib.import_module(module_for('events', 'schema.store'))
         SchemaEvolution = _evo_mod.SchemaEvolution
         SchemaRegistry = _reg_mod.SchemaRegistry
         InMemorySchemaStore = _store_mod.InMemorySchemaStore
     except ImportError:
         out.error(
-            "quadkit-events is not installed.  Run `uv add quadkit-events` to add it."
+            "The optional event provider is not installed. "
+            "Install the provider before retrying."
         )
         raise typer.Exit(1) from None
 
@@ -88,8 +90,8 @@ def migrate(
             # hard cross-extension import at module level.
             import importlib as _importlib
 
-            _reg_mod = _importlib.import_module("quadkit.events.schema.registry")
-            _store_mod = _importlib.import_module("quadkit.events.schema.store")
+            _reg_mod = _importlib.import_module(module_for('events', 'schema.registry'))
+            _store_mod = _importlib.import_module(module_for('events', 'schema.store'))
             registry = _reg_mod.SchemaRegistry(store=_store_mod.InMemorySchemaStore())
             latest = await registry.get_latest_version(event_type)
             target = latest if latest is not None else from_version
@@ -192,7 +194,7 @@ def replay(
     out.print()
     out.print("Use the programmatic approach instead:")
     out.print()
-    out.print("  [cyan]from quadkit.events import EventBus[/cyan]")
+    out.print(f"  [cyan]from {module_for('events')} import EventBus[/cyan]")
     out.print("  [cyan]bus = container.resolve(EventBus)[/cyan]")
     out.print(
         "  [cyan]await bus.replay(event_type='UserCreated', since=start_time)[/cyan]"

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/src/quadkit/cli/commands/meta.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+import importlib.metadata
 from typing import Annotated
 
 import typer
 
 from quadkit.cli.constants import __version__
+from quadkit.cli.package_names import installed_quadkit_distributions
 from quadkit.cli.output import OutputManager
 from quadkit.cli.registry.command import CommandEntry, CommandRegistry
 
@@ -84,30 +86,7 @@ def version(
     out = OutputManager()
     out.print(f"quadkit {__version__}")
     if all_packages:
-        import importlib.metadata
-
-        packages = [
-            "quadkit",
-            "quadkit-cli",
-            "quadkit-web",
-            "quadkit-sql",
-            "quadkit-auth",
-            "quadkit-cache",
-            "quadkit-events",
-            "quadkit-notification",
-            "quadkit-queue",
-            "quadkit-monitor",
-            "quadkit-tasks",
-            "quadkit-graphql",
-            "quadkit-ai",
-            "quadkit-resilience",
-            "quadkit-http",
-            "quadkit-features",
-            "quadkit-search",
-            "quadkit-storage",
-            "quadkit-admin",
-            "quadkit-testing",
-        ]
+        packages = installed_quadkit_distributions()
         rows = []
         for pkg in packages:
             try:

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/src/quadkit/cli/commands/system.py

@@ -8,6 +8,7 @@ import typer
 import yaml
 
 from quadkit.cli.lib.console import console
+from quadkit.cli.package_names import installed_quadkit_distributions
 from quadkit.cli.registry.health import (
     CheckResult,
     CheckStatus,
@@ -46,7 +47,7 @@ def info() -> None:
         console.print("Project Config: [warning]Not found[/warning]")
 
     console.print("\n[bold]Core Packages:[/bold]")
-    for pkg in ["quadkit-common", "quadkit-auth", "quadkit-sql", "quadkit-web"]:
+    for pkg in installed_quadkit_distributions():
         console.print(f"- {pkg}")
 
 

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/src/quadkit/cli/contributors/runtime.py

@@ -15,6 +15,7 @@ from quadkit.contracts.cli.contributions import (
 )
 from quadkit.contracts.cli.protocols import CliContributorProtocol
 from quadkit.contracts.cli.types import GeneratorDefinition
+from quadkit.cli.package_names import PUBLIC_DISTRIBUTIONS
 
 ENTRY_POINT_GROUP = "quadkit.cli.contributors"
 
@@ -23,36 +24,7 @@ _BUILTIN_DIST = "quadkit-cli"
 _RESERVED_COMMANDS: dict[str, str] = {
     "search": "search",
 }
-_SCOPE_DISTS: frozenset[str] = frozenset(
-    {
-        "quadkit",
-        "quadkit-contracts",
-        "quadkit-ai",
-        "quadkit-ai-mcp",
-        "quadkit-vector",
-        "quadkit-web",
-        "quadkit-sql",
-        "quadkit-cache",
-        "quadkit-auth",
-        "quadkit-events",
-        "quadkit-queue",
-        "quadkit-tasks",
-        "quadkit-http",
-        "quadkit-resilience",
-        "quadkit-storage",
-        "quadkit-search",
-        "quadkit-notification",
-        "quadkit-monitor",
-        "quadkit-webhook",
-        "quadkit-tenancy",
-        "quadkit-features",
-        "quadkit-audit",
-        "quadkit-graphql",
-        "quadkit-nosql",
-        "quadkit-workflow",
-        "quadkit-testing",
-    }
-)
+_SCOPE_DISTS = PUBLIC_DISTRIBUTIONS
 
 
 @dataclass(frozen=True)

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/src/quadkit/cli/exceptions.py

@@ -58,7 +58,9 @@ class ProviderNotInstalledError(CliError):
         """
         super().__init__(
             message=f"Provider '{provider}' is not installed",
-            suggestions=[f"Install with: pip install quadkit-{provider}"],
+            suggestions=[
+                f"Install the provider distribution that supplies '{provider}'"
+            ],
         )
 
 

{quadkit_cli-0.0.2 → quadkit_cli-0.0.3}/src/quadkit/cli/lib/config_gen.py

@@ -15,6 +15,7 @@ import importlib
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, get_args, get_origin
 
+from quadkit.cli.package_names import module_for, provider_available
 from quadkit.logging import get_logger
 
 if TYPE_CHECKING:
@@ -24,29 +25,34 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)
 
-# Registry: maps YAML section key → (import_path, config_class_name)
-# This defines the canonical set of Quadkit subpackage configs.
+# Registry: maps YAML section key → (provider feature, config class name).
+# Optional entries are materialized only when their provider is installed.
+_CONFIG_SPECS: dict[str, tuple[str, str]] = {
+    "database": ("sql", "DatabaseConfig"),
+    "web": ("web", "WebConfig"),
+    "auth": ("auth", "AuthConfig"),
+    "cache": ("cache", "CacheConfig"),
+    "storage": ("storage", "StorageConfig"),
+    "tasks": ("tasks", "TaskConfig"),
+    "events": ("events", "EventsConfig"),
+    "search": ("search", "SearchConfig"),
+    "ai": ("ai", "AIConfig"),
+    "monitor": ("monitor", "MonitorConfig"),
+    "messaging": ("messaging", "MessagingConfig"),
+    "feature_flags": ("features", "FeatureFlagsConfig"),
+    "graphql": ("graphql", "GraphQLConfig"),
+}
 PACKAGE_CONFIGS: dict[str, str] = {
-    "database": "quadkit.sql.config:DatabaseConfig",
-    "web": "quadkit.web.config:WebConfig",
-    "auth": "quadkit.auth.config:AuthConfig",
-    "cache": "quadkit.cache.config:CacheConfig",
-    "storage": "quadkit.storage.config:StorageConfig",
-    "tasks": "quadkit.tasks.config:TaskConfig",
-    "events": "quadkit.events.config:EventsConfig",
-    "search": "quadkit.search.config:SearchConfig",
-    "ai": "quadkit.ai.config:AIConfig",
-    "monitor": "quadkit.monitor.config:MonitorConfig",
-    "messaging": "quadkit.messaging.config:MessagingConfig",
-    "feature_flags": "quadkit.features.config:FeatureFlagsConfig",
-    "graphql": "quadkit.graphql.config:GraphQLConfig",
+    key: f"{module_for(feature, 'config')}:{class_name}"
+    for key, (feature, class_name) in _CONFIG_SPECS.items()
+    if feature == "web" or provider_available(feature)
 }
 
 
 def _import_config_class(import_path: str) -> type[Any]:
-    """Import a config class from a dotted path like 'quadkit.sql.config:DatabaseConfig'.
+    """Import a config class from a dotted path like 'quadkit.<provider>.config:ConfigClass'.
 
-    Raises ImportError if quadkit-domain is not installed.
+    Raises ImportError if the optional domain-model provider is not installed.
     """
     module_path, class_name = import_path.rsplit(":", 1)
 
@@ -235,7 +241,7 @@ def generate_package_config(
 
     Args:
         package_key: The YAML section key (e.g. 'database').
-        import_path: Import path like 'quadkit.sql.config:DatabaseConfig'.
+        import_path: Import path like 'quadkit.<provider>.config:ConfigClass'.
         with_comments: Include field descriptions as comments.
 
     Returns:
@@ -244,10 +250,10 @@ def generate_package_config(
     try:
         config_cls = _import_config_class(import_path)
     except ImportError as e:
-        if "quadkit.domain" in str(e) or "DomainModel" in str(e):
+        if module_for("domain") in str(e) or "DomainModel" in str(e):
             error_msg = (
-                "quadkit-domain is required for config generation — "
-                "install it with: uv add quadkit-domain"
+                "The optional domain-model provider is required for config "
+                "generation; install the provider before retrying."
             )
             return f"# Error: {error_msg}\n# Original error: {e}\n{package_key}: {{}}\n"
         return f"# Failed to import {import_path}: {e}\n{package_key}: {{}}\n"