quadkit-cli 0.0.4__tar.gz → 0.0.42__tar.gz

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/.gitignore

@@ -149,6 +149,27 @@ apps/**/*.pyc
 apps/**/*.db
 apps/**/*.db-wal
 apps/**/*.db-shm
+apps/**/.env
+apps/**/.env.*
+!apps/**/.env.example
+!apps/**/.env.full.example
+
+# Piccolina — nested app tracked in this monorepo (standalone .git removed).
+# Keep marketing packages and deployment secrets out of the tree.
+apps/piccolina/piccolina-marketing/
+apps/piccolina/piccolina-marketing-plans/
+apps/piccolina/secrets/
+apps/piccolina/**/secrets/
+apps/piccolina/**/*.pem
+apps/piccolina/**/*.key
+apps/piccolina/**/.venv/
+apps/piccolina/**/node_modules/
+apps/piccolina/**/__pycache__/
+apps/piccolina/**/*.pyc
+apps/piccolina/**/*.pbf
+apps/piccolina/**/.open-next/
+apps/piccolina/**/storage/
+apps/piccolina/**/.deploy-host
 
 # Re-exclude private content under the tiered paths.
 # MUST come after the !...docs/** negations above — last match wins.
@@ -180,4 +201,14 @@ test.db
 !packages/*/quadkit*/docs/gifs/
 !packages/*/quadkit*/docs/gifs/**
 examples/*/screenshot.png
-!banner*
+!banner*
+apps/quadkit-playground/**/node_modules/
+apps/quadkit-playground/**/dist/
+apps/quadkit-playground/**/__pycache__/
+apps/quadkit-playground/**/*.pyc
+apps/quadkit-playground/**/*.db
+apps/quadkit-playground/**/*.db-wal
+apps/quadkit-playground/**/*.db-shm
+apps/quadkit-playground/projects/
+apps/quadkit-playground/quadkit/
+docs/superpowers/

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quadkit-cli
-Version: 0.0.4
+Version: 0.0.42
 Summary: Command-line interface for Quadkit Framework - Project scaffolding, code generation, and development tools
 Project-URL: Homepage, https://dbtinoy-.github.io/quadkit/
 Project-URL: Repository, https://github.com/dbtinoy-/quadkit
@@ -167,10 +167,10 @@ review release notes on upgrade. Report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.3` in the `0.x` series, released in lockstep with the
+Version `0.0.42` 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:
+1.0 — pin an exact version (`quadkit-cli==0.0.42`) or a tight range
+(`>=0.0.42,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/README.md

@@ -111,10 +111,10 @@ review release notes on upgrade. Report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.3` in the `0.x` series, released in lockstep with the
+Version `0.0.42` 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:
+1.0 — pin an exact version (`quadkit-cli==0.0.42`) or a tight range
+(`>=0.0.42,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/docs/ARCHITECTURE.md

@@ -155,7 +155,7 @@ sequenceDiagram
     FS-->>Impl: File written
     Impl-->>GA: GenerationResult
     GA-->>CA: GeneratorResult
-    CA-->>Gen: Print "Created: src/providers/user_service_provider.py"
+    CA-->>Gen: Print "Created: src/di/user_service_provider.py"
     Gen-->>User: Success output
 ```
 
@@ -205,7 +205,7 @@ generators = [
         description="Generate a provider class",
         contributor="my_package",
         generator_path="my_package.generators:MyGenerator",
-        default_output_dir="src/providers",
+        default_output_dir="src/di",
     ),
 ]
 ```

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/docs/COMMANDS.md

@@ -82,7 +82,7 @@ Database management commands.
 ```
 quadkit db init [--reset] [--seed]
 quadkit db migrate [--name <migration>] [--auto]
-quadkit db seed [--file seeds.py]
+quadkit db seed [--file seeds.py]     # src/<app>/shared/seeders, else ./seeds
 quadkit db shell
 ```
 
@@ -91,7 +91,7 @@ quadkit db shell
 Code generation commands.
 
 ```
-quadkit gen provider <name> [--output src/providers/]
+quadkit gen provider <name> [--output src/di/]
 quadkit gen module <name> [--output src/modules/]
 quadkit gen migration [--auto-detect]
 ```

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/docs/PROJECT_LAYOUT.md

@@ -52,7 +52,9 @@ my-platform/
 ├── README.md
 ├── .env.example
 ├── migrations/versions/               # quadkit gen migration
-├── seeds/                             # quadkit gen seeder
+├── seeds/                             # hand-written seeders; `quadkit db seed`
+│                                      #   falls back to this when `shared/seeders`
+│                                      #   is absent
 ├── src/
 │   └── my_platform/
 │       ├── __init__.py
@@ -65,6 +67,8 @@ my-platform/
 │       ├── infrastructure/            # framework wiring: db, cache, events, monitoring
 │       │   └── __init__.py            # infrastructure_modules()
 │       ├── shared/                    # cross-cutting components (see §3)
+│       │   ├── di/                    # quadkit gen provider
+│       │   ├── seeders/               # quadkit gen seeder
 │       │   ├── errors/
 │       │   ├── filters/
 │       │   ├── middleware/
@@ -76,7 +80,6 @@ my-platform/
 │       │   ├── features/
 │       │   ├── search/
 │       │   ├── storage/backends/
-│       │   ├── providers/
 │       │   ├── schema/dataloaders/
 │       │   ├── vector/collections/
 │       │   └── mcp/
@@ -108,18 +111,28 @@ empty `MODULES`, and `quadkit new module <name>` fills it in.
 
 **Cross-cutting** (`src/<app>/shared/<component>/`, module ignored):
 
-`audit`, `errors`, `features`, `filters`, `health`, `interceptors`, `mcp`,
-`metrics`, `middleware`, `providers`, `schema`, `schema/dataloaders`,
-`search`, `storage/backends`, `tenancy`, `vector/collections`
+`audit`, `auth`, `contracts`, `di`, `errors`, `features`, `filters`, `health`,
+`interceptors`, `mcp`, `metrics`, `middleware`, `providers`, `schema`,
+`schema/dataloaders`, `search`, `seeders`, `storage/backends`, `tenancy`,
+`vector/collections`
+
+`providers` is retained as a *resolution* row only: no generator writes there
+(it was superseded by `di`, which is where `quadkit gen provider` now defaults),
+and the scaffold does not pre-create it — a project generated into
+`shared/providers/` before that change still resolves. `auth` and `contracts`
+likewise carry no generator yet; the rows are the map's answer for where those
+packages live.
 
 **Module-local** (`src/<app>/<component>/` → `src/<app>/modules/<slug>/<component>/`):
 
 `admin/actions`, `admin/resources`, `clients`, `commands`, `consumers`,
 `controllers`, `domains`, `events`, `handlers`, `notifications`, `pipelines`,
 `policies`, `projections`, `queries`, `repositories`, `sagas`, `services`,
-`tasks`, `webhooks`, `websocket`, `workflows`
+`tasks`, `validators`, `webhooks`, `websocket`, `workflows`
 
-**Project root, never moved**: `migrations/versions`, `seeds`.
+**Project root, never moved**: `migrations/versions`, `seeds` (a hand-written
+collection — generated seeders go to the shared `seeders` package so they are
+importable, and `quadkit db seed` runs whichever exists).
 `tests/unit` is the exception that follows its node: with `--module auth` a
 generated test lands in `src/<app>/modules/auth/tests/`.
 
@@ -138,7 +151,7 @@ scoped, while `src/errors` always means `src/<app>/shared/errors`.
 | domain | `src/domains` |
 | service | `src/services` |
 | repository, cache_repo, document_repo | `src/repositories` |
-| provider | `src/providers` |
+| provider | `src/di` |
 | query | `src/queries` |
 | error | `src/errors` |
 | event / event_handler | `src/events` / `src/handlers` |
@@ -170,7 +183,8 @@ scoped, while `src/errors` always means `src/<app>/shared/errors`.
 | graphql / dataloader | `src/schema` / `src/schema/dataloaders` |
 | vector_collection | `src/vector/collections` |
 | (special) resource | `src` — writes `src/<app>/<name>_resource.py`, or into the module |
-| migration / seeder | `migrations/versions` / `seeds` |
+| migration | `migrations/versions` |
+| seeder | `src/seeders` (shared; `--output seeds` still resolves) |
 | test | `tests/unit` |
 
 Two default dirs were renamed because they shadowed real modules on

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quadkit-cli"
-version = "0.0.4"
+version = "0.0.42"
 description = "Command-line interface for Quadkit Framework - Project scaffolding, code generation, and development tools"
 readme = "README.md"
 requires-python = ">=3.11"

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/src/quadkit/cli/commands/config.py

@@ -78,6 +78,9 @@ def show(
             config_path = find_config()
             config_data = await load_config_yaml_async(config_path)
         except (ConfigNotFoundError, FileNotFoundError):
+            # Both are reachable here: find_config() raises the former, and
+            # the try also wraps the read, which can lose the file to a
+            # race after the walk.
             out.error(
                 "No application.yaml found in current directory or any parent.",
                 hint="Run `quadkit init` to create one.",
@@ -342,7 +345,10 @@ def env_cmd(
     async def _run() -> None:
         try:
             config_path = find_config()
-        except (ConfigNotFoundError, FileNotFoundError):
+        except ConfigNotFoundError:
+            # find_config() raises ConfigNotFoundError (a CliError), never
+            # FileNotFoundError: it walks candidates with ``.is_file()``. The
+            # old arm therefore never ran, and this message never printed.
             out.error("No application.yaml found")
             raise typer.Exit(1) from None
 
@@ -458,7 +464,10 @@ def env_example(
     async def _run() -> None:
         try:
             config_path = find_config()
-        except (ConfigNotFoundError, FileNotFoundError):
+        except ConfigNotFoundError:
+            # find_config() raises ConfigNotFoundError (a CliError), never
+            # FileNotFoundError: it walks candidates with ``.is_file()``. The
+            # old arm therefore never ran, and this message never printed.
             out.error("No application.yaml found")
             raise typer.Exit(1) from None
 

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/src/quadkit/cli/commands/db_commands_data.py

@@ -6,11 +6,13 @@ import asyncio
 import importlib
 import importlib.util
 from pathlib import Path
+import sys
 from typing import Annotated
 
 import typer
 
 from quadkit.cli.commands import db_bootstrap
+from quadkit.cli.layout import read_project_layout, resolve_output_dir
 from quadkit.cli.output import OutputManager
 from quadkit.cli.runtime import handle_errors
 from quadkit.contracts.cli.contributions import (
@@ -21,6 +23,106 @@ from quadkit.contracts.cli.contributions import (
 from quadkit.contracts.data.sql.database import DatabaseProviderProtocol
 
 
+def _seeder_source() -> tuple[Path, str | None]:
+    """Where this project's seeders are, and how to import them.
+
+    Resolution order:
+
+    1. the canonical ``seeders`` component — ``src/<app>/shared/seeders``,
+       where ``quadkit gen seeder`` writes and where a generated application
+       keeps the seeders its persistence provider boots;
+    2. the project-root ``seeds/`` directory — what a project generated before
+       the ``seeders`` row landed has, and what a hand-written collection of
+       seeders looks like. Those files sit outside any package, so they stay
+       path-loaded, exactly as this command always loaded them.
+
+    Returns:
+        ``(directory, module_prefix)``: the directory to read, and the dotted
+        package its modules belong to (``my_app.shared.seeders``) when the
+        directory lives inside ``src/`` — ``None`` when it does not, which is
+        the signal to load files by path instead.
+    """
+    layout = read_project_layout()
+    canonical = Path(resolve_output_dir("src/seeders", app_package=layout.app_package))
+    if canonical.is_dir():
+        return canonical, _module_prefix(canonical)
+    return Path("seeds"), None
+
+
+def _module_prefix(directory: Path) -> str | None:
+    """Dotted package name for *directory*, when it is inside ``src/``."""
+    parts = directory.parts
+    if "src" not in parts:
+        return None
+    after_src = parts[parts.index("src") + 1 :]
+    return ".".join(after_src) if after_src else None
+
+
+def _make_importable(directory: Path) -> None:
+    """Put the package root of *directory* on ``sys.path``.
+
+    Seeders import the application's own packages (``from my_app.shared...``),
+    and the CLI is not run with the project's ``src`` on the path the way the
+    project's own entry point is.
+    """
+    parts = directory.parts
+    if "src" not in parts:
+        return
+    root = Path(*parts[: parts.index("src") + 1])
+    resolved = str(root.resolve())
+    if resolved not in sys.path:
+        sys.path.insert(0, resolved)
+
+
+def _seed_files(directory: Path) -> list[Path]:
+    """Seeders to run, in filename order.
+
+    ``__init__.py`` is skipped: seeders below ``src/`` live in a package, and
+    the package marker is not a seeder -- running it would report "No 'run'
+    function found" for a file the user never wrote.
+    """
+    return [
+        path for path in sorted(directory.glob("*.py")) if path.name != "__init__.py"
+    ]
+
+
+async def _run_seeder(
+    out: OutputManager,
+    provider: DatabaseProviderProtocol,
+    seed_file: Path,
+    module_prefix: str | None,
+) -> None:
+    """Execute one seeder file.
+
+    A seeder inside the application package is *imported*: it is an ordinary
+    module there, and importing is what the generated application itself does
+    when it boots its seeders. Anything else is loaded from its path, which is
+    the only thing that works for a file outside ``src/``.
+    """
+    out.info(f"Running seeder: {seed_file}")
+
+    if module_prefix is not None:
+        _make_importable(seed_file)
+        module = importlib.import_module(f"{module_prefix}.{seed_file.stem}")
+    else:
+        spec = importlib.util.spec_from_file_location("seed_module", seed_file)
+        if spec is None or spec.loader is None:
+            out.warning(f"Could not load seeder: {seed_file}")
+            return
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+    if not hasattr(module, "run"):
+        out.warning(f"No 'run' function found in {seed_file}")
+        return
+
+    if asyncio.iscoroutinefunction(module.run):
+        await module.run(provider)
+    else:
+        module.run(provider)
+    out.success(f"Seeder {seed_file} completed.")
+
+
 @handle_errors
 def seed(
     file: str | None = typer.Argument(None, help="Specific seed file to run"),
@@ -33,33 +135,26 @@ def seed(
         manager = await db_bootstrap.get_migration_manager()
         await manager.provider.boot()
         try:
-            seeds_dir = Path("seeds")
+            seeds_dir, module_prefix = _seeder_source()
             if not seeds_dir.exists() and not file:
                 out.warning("No seeds directory found.")
                 return
 
-            files_to_run = []
+            # Annotated: the first branch appends ``(path, None)`` and the
+            # second rebuilds with a module prefix, so inference from the
+            # empty list would pin the tuple's second element to ``None``.
+            files_to_run: list[tuple[Path, str | None]] = []
             if file:
-                files_to_run.append(Path(file))
+                # An explicit file is run as given, by path: the user named a
+                # file, not a module.
+                files_to_run.append((Path(file), None))
             else:
-                files_to_run = sorted(seeds_dir.glob("*.py"))
+                files_to_run = [
+                    (seed_file, module_prefix) for seed_file in _seed_files(seeds_dir)
+                ]
 
-            for seed_file in files_to_run:
-                out.info(f"Running seeder: {seed_file}")
-
-                spec = importlib.util.spec_from_file_location("seed_module", seed_file)
-                if spec and spec.loader:
-                    module = importlib.util.module_from_spec(spec)
-                    spec.loader.exec_module(module)
-
-                    if hasattr(module, "run"):
-                        if asyncio.iscoroutinefunction(module.run):
-                            await module.run(manager.provider)
-                        else:
-                            module.run(manager.provider)
-                        out.success(f"Seeder {seed_file} completed.")
-                    else:
-                        out.warning(f"No 'run' function found in {seed_file}")
+            for seed_file, prefix in files_to_run:
+                await _run_seeder(out, manager.provider, seed_file, prefix)
 
         except Exception as e:  # noqa: BLE001 — any seeder failure is a CLI error
             out.error(f"Seeder failed: {e}")
@@ -121,25 +216,12 @@ def reset(
                 out.info("No pending migrations.")
 
             if seed:
-                seeds_dir = Path("seeds")
+                seeds_dir, module_prefix = _seeder_source()
                 if seeds_dir.exists():
-                    files_to_run = sorted(seeds_dir.glob("*.py"))
-                    for seed_file in files_to_run:
-                        out.info(f"Running seeder: {seed_file}")
-
-                        spec = importlib.util.spec_from_file_location(
-                            "seed_module",
-                            seed_file,
+                    for seed_file in _seed_files(seeds_dir):
+                        await _run_seeder(
+                            out, manager.provider, seed_file, module_prefix
                         )
-                        if spec and spec.loader:
-                            module = importlib.util.module_from_spec(spec)
-                            spec.loader.exec_module(module)
-                            if hasattr(module, "run"):
-                                if asyncio.iscoroutinefunction(module.run):
-                                    await module.run(manager.provider)
-                                else:
-                                    module.run(manager.provider)
-                                out.success(f"Seeder {seed_file} completed.")
                 else:
                     out.warning("No seeds directory found, skipping seed step.")
 

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/src/quadkit/cli/commands/new.py

@@ -32,7 +32,7 @@ def _valid_name(value: str, kind: str) -> str:
 def main(
     name: str = typer.Argument(..., help="Name of the project"),
     template: str = typer.Option(
-        "web-api",
+        "api",
         "--template",
         "-t",
         help=(
@@ -58,7 +58,7 @@ def main(
 
         selected_template = typer.prompt(
             "Select a template",
-            default="web-api",
+            default="api",
             type=click.Choice(template_names()),
         )
 

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/src/quadkit/cli/contributors/core.py

@@ -13,7 +13,7 @@ _GENERATOR_SPECS: tuple[tuple[str, str, str, str], ...] = (
         "provider",
         "Generate provider",
         "quadkit.cli.generators.provider:ProviderGenerator",
-        "src/providers",
+        "src/di",
     ),
     (
         "test",

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/src/quadkit/cli/generators/provider.py

@@ -20,9 +20,9 @@ class ProviderGenerator(GeneratorBase):
 
     name = "provider"
     description = "Generate provider"
-    default_output_dir = "src/providers"
+    default_output_dir = "src/di"
 
-    def __init__(self, output_dir: str | Path = "src/providers") -> None:
+    def __init__(self, output_dir: str | Path = "src/di") -> None:
         super().__init__(output_dir=output_dir)
 
     def generate(

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/src/quadkit/cli/layout.py

@@ -65,16 +65,43 @@ COMPONENTS: tuple[ComponentDir, ...] = (
     ComponentDir("admin/actions", "admin/actions", False, ("admin_action",)),
     ComponentDir("admin/resources", "admin/resources", False, ("admin_resource",)),
     ComponentDir("audit", "audit", True, ("audited",)),
+    # ``auth``, ``contracts`` and ``validators`` carry no generators on
+    # purpose: no registered generator writes there yet (the CLI ships
+    # ``provider`` and ``test``; subsystems contribute the rest), and a
+    # ``generators`` entry is the map's authorisation for a generator's
+    # declared output directory, so it should name a generator that exists.
+    # The rows are the map's answer for *placement and scope*, which is what
+    # the builder needed to delete its own copy of them
+    # (docs/upstream/2026-09-02-component-rows.md).
+    # API-key issuance and verification. Cross-cutting by definition: one
+    # key store, checked by every bounded context.
+    ComponentDir("auth", "auth", True, ()),
     ComponentDir("clients", "clients", False, ("api_client",)),
     ComponentDir("commands", "commands", False, ("command",)),
     ComponentDir("consumers", "consumers", False, ("message_consumer",)),
+    # Request/response schemas shared across controllers. They are the
+    # interface between a context and its callers, so they cannot be
+    # module-local without every consumer reaching across a boundary.
+    ComponentDir("contracts", "contracts", True, ()),
     ComponentDir("controllers", "controllers", False, ("controller",)),
+    # Cross-cutting DI providers. Every quadkit subsystem keeps its own
+    # provider at ``<subsystem>/di/provider.py`` (30 of them, no
+    # exceptions), so a generated provider reads like the framework it
+    # is built on. The ``providers`` row below is kept for projects
+    # that already generated into it.
+    ComponentDir("di", "di", True, ("provider",)),
     ComponentDir("domains", "domains", False, ("domain",)),
     ComponentDir("errors", "errors", True, ("error",)),
     ComponentDir("events", "events", False, ("event",)),
     ComponentDir("features", "features", True, ("feature_flag",)),
     ComponentDir("filters", "filters", True, ("exception_filter", "filter")),
-    ComponentDir("guards", "guards", False, ("auth_guard", "guard")),
+    # Cross-cutting, like ``filters`` above: ``@require_auth()`` decorates
+    # controllers in every bounded context, and the palette already scopes
+    # ``auth``/``role`` as shared kinds. While this row said module-local,
+    # the two answers met at generation time and a modular app containing
+    # an Auth Guard could not be generated at all (playground TASK-6 /
+    # MODULAR-3).
+    ComponentDir("guards", "guards", True, ("auth_guard", "guard")),
     ComponentDir("handlers", "handlers", False, ("event_handler",)),
     ComponentDir("health", "health", True, ("health",)),
     ComponentDir("interceptors", "interceptors", True, ("interceptor",)),
@@ -85,7 +112,9 @@ COMPONENTS: tuple[ComponentDir, ...] = (
     ComponentDir("pipelines", "pipelines", False, ("pipeline",)),
     ComponentDir("policies", "policies", False, ("auth_policy",)),
     ComponentDir("projections", "projections", False, ("projection",)),
-    ComponentDir("providers", "providers", True, ("provider",)),
+    # Superseded by the ``di`` row above; kept (with no generators) so a
+    # project that already has ``shared/providers/`` keeps resolving.
+    ComponentDir("providers", "providers", True, ()),
     ComponentDir("queries", "queries", False, ("query",)),
     ComponentDir(
         "repositories",
@@ -97,10 +126,20 @@ COMPONENTS: tuple[ComponentDir, ...] = (
     ComponentDir("schema", "schema", True, ("graphql",)),
     ComponentDir("schema/dataloaders", "schema/dataloaders", True, ("dataloader",)),
     ComponentDir("search", "search", True, ("search_index",)),
+    # Generated seeders live inside the application package so they are
+    # importable: a project boots them from its persistence provider, and
+    # `quadkit db seed` imports the same modules. ``seeds`` (project root)
+    # stays resolvable in ROOT_DIRS below, because that is where every
+    # project generated before 2026-09-23 kept them and where the command
+    # still looks second.
+    ComponentDir("seeders", "seeders", True, ("seeder",)),
     ComponentDir("services", "services", False, ("service",)),
     ComponentDir("storage/backends", "storage/backends", True, ("storage_driver",)),
     ComponentDir("tasks", "tasks", False, ("task",)),
     ComponentDir("tenancy", "tenancy", True, ("tenant_resolver",)),
+    # Per-entity rules. They know an entity's fields, so they belong
+    # wherever that entity belongs: module-local.
+    ComponentDir("validators", "validators", False, ()),
     ComponentDir(
         "vector/collections", "vector/collections", True, ("vector_collection",)
     ),
@@ -112,6 +151,10 @@ COMPONENTS: tuple[ComponentDir, ...] = (
 # Root-level output directories of the generator SDK (no ``src/`` prefix).
 ROOT_DIRS: tuple[tuple[str, tuple[str, ...]], ...] = (
     ("migrations/versions", ("migration",)),
+    # ``seeds`` is legacy-but-supported: the ``seeders`` component above is
+    # where the generator writes now, while this row keeps ``quadkit gen
+    # seeder --output seeds`` and projects generated before 2026-09-23
+    # resolvable. ``quadkit db seed`` looks here second.
     ("seeds", ("seeder",)),
     ("tests/unit", ("test",)),
 )

{quadkit_cli-0.0.4 → quadkit_cli-0.0.42}/src/quadkit/cli/registry/environment.py

@@ -13,7 +13,16 @@ from typing import ClassVar
 
 @dataclass
 class EnvironmentConfig:
-    """Configuration for an environment."""
+    """Configuration for an environment.
+
+    Attributes:
+        name: Environment name.
+        description: Human-readable description.
+        variables: Additional environment variables to apply when switching.
+        database_url: Database URL for this environment.
+        debug: Whether debug mode is enabled.
+        log_level: Logging level for this environment.
+    """
 
     name: str
     description: str = ""
@@ -22,6 +31,39 @@ class EnvironmentConfig:
     debug: bool = False
     log_level: str = "INFO"
 
+    def apply(self) -> None:
+        """Apply this configuration to the process environment.
+
+        Writes ``variables`` into ``os.environ``, and ensures
+        ``DATABASE_URL`` and ``LOG_LEVEL`` reflect the typed fields
+        when they are set. This is the consumption site for
+        ``variables``, ``database_url`` and ``log_level`` — without it
+        the fields would be dead configuration.
+        """
+        if self.variables:
+            for key, value in self.variables.items():
+                if key:
+                    os.environ[key] = value
+        if self.database_url:
+            os.environ["DATABASE_URL"] = self.database_url
+        if self.log_level:
+            os.environ["LOG_LEVEL"] = self.log_level
+            os.environ["QK_LOG_LEVEL"] = self.log_level
+
+    def to_env_dict(self) -> dict[str, str]:
+        """Return the environment variables this config would set.
+
+        Returns:
+            Dictionary of environment variables including ``variables``,
+            ``DATABASE_URL`` and ``LOG_LEVEL`` when present.
+        """
+        result: dict[str, str] = dict(self.variables)
+        if self.database_url:
+            result["DATABASE_URL"] = self.database_url
+        if self.log_level:
+            result["LOG_LEVEL"] = self.log_level
+        return result
+
 
 class Environment(abc.ABC):
     """Abstract base class for environments."""
@@ -202,7 +244,13 @@ class EnvironmentManager:
         self.registry = EnvironmentRegistry.with_defaults()
 
     def switch(self, name: str) -> bool:
-        """Switch to a different environment."""
+        """Switch to a different environment and apply its variables.
+
+        Validation is performed before the switch. When valid, the
+        environment is marked as current and its ``EnvironmentConfig``
+        is applied to ``os.environ`` so ``variables``, ``database_url``
+        and ``log_level`` take effect.
+        """
         env = self.registry.get(name)
         if not env:
             return False
@@ -212,6 +260,8 @@ class EnvironmentManager:
             return False
 
         self.registry.set_current(name)
+        config = env.get_config()
+        config.apply()
         return True
 
     def validate_current(self) -> tuple[bool, str]: