quadkit-cli 0.0.43__tar.gz → 0.0.45__tar.gz

{quadkit_cli-0.0.43 → quadkit_cli-0.0.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quadkit-cli
-Version: 0.0.43
+Version: 0.0.45
 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
@@ -94,7 +94,7 @@ Requires **Python >= 3.11**.
 There is no code to write — the product is the command line:
 
 ```bash
-# Create a new project (template defaults to web-api); the package
+# Create a new project (single `api` template); the package
 # inside is my_api/ with app.py exposing create_app()
 quadkit new project my-api
 cd my-api
@@ -167,10 +167,10 @@ review release notes on upgrade. Report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.43` in the `0.x` series, released in lockstep with the
+Version `0.0.45` 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.43`) or a tight range
-(`>=0.0.43,<0.1.0`). Full policy:
+1.0 — pin an exact version (`quadkit-cli==0.0.45`) or a tight range
+(`>=0.0.45,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit_cli-0.0.43 → quadkit_cli-0.0.45}/README.md

@@ -38,7 +38,7 @@ Requires **Python >= 3.11**.
 There is no code to write — the product is the command line:
 
 ```bash
-# Create a new project (template defaults to web-api); the package
+# Create a new project (single `api` template); the package
 # inside is my_api/ with app.py exposing create_app()
 quadkit new project my-api
 cd my-api
@@ -111,10 +111,10 @@ review release notes on upgrade. Report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.43` in the `0.x` series, released in lockstep with the
+Version `0.0.45` 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.43`) or a tight range
-(`>=0.0.43,<0.1.0`). Full policy:
+1.0 — pin an exact version (`quadkit-cli==0.0.45`) or a tight range
+(`>=0.0.45,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit_cli-0.0.43 → quadkit_cli-0.0.45}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quadkit-cli"
-version = "0.0.43"
+version = "0.0.45"
 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.43 → quadkit_cli-0.0.45}/src/quadkit/cli/commands/new.py

@@ -35,10 +35,7 @@ def main(
         "api",
         "--template",
         "-t",
-        help=(
-            "Project template "
-            f"(available in this install: {', '.join(template_names())})"
-        ),
+        help=f"Project template (the only template: {', '.join(template_names())})",
     ),
     directory: str = typer.Option(".", "--directory", "-d", help="Target directory"),
     interactive: bool = typer.Option(
@@ -53,13 +50,14 @@ def main(
     project_name = _valid_name(name, "Project")
     selected_template = template
 
-    if interactive:
+    names = template_names()
+    if interactive and len(names) > 1:
         import click
 
         selected_template = typer.prompt(
             "Select a template",
             default="api",
-            type=click.Choice(template_names()),
+            type=click.Choice(names),
         )
 
     try:

{quadkit_cli-0.0.43 → quadkit_cli-0.0.45}/src/quadkit/cli/registry/__init__.py

@@ -128,15 +128,10 @@ if TYPE_CHECKING:
         TasksInspector,
     )
     from quadkit.cli.registry.presets import (
-        FullStackPreset,
-        GraphQLPreset,
-        MicroservicePreset,
-        MinimalPreset,
+        ApiPreset,
         Preset,
         PresetDefinition,
         PresetRegistry,
-        WebAPIPreset,
-        WorkerPreset,
     )
     from quadkit.cli.registry.provider import (
         AdminProvider,
@@ -200,15 +195,11 @@ if TYPE_CHECKING:
         get_telemetry_status,
     )
     from quadkit.cli.registry.template import (
-        FullStackTemplate,
-        GraphQLTemplate,
-        MinimalTemplate,
+        ApiTemplate,
         ProjectBuilder,
         ProjectTemplate,
         TemplateConfig,
         TemplateRegistry,
-        WebAPITemplate,
-        WorkerTemplate,
     )
     from quadkit.cli.registry.version import (
         VersionInfo,

{quadkit_cli-0.0.43 → quadkit_cli-0.0.45}/src/quadkit/cli/registry/_lazy_exports.py

@@ -11,6 +11,8 @@ from __future__ import annotations
 LAZY_IMPORTS: dict[str, str] = {
     "AIProvider": "quadkit.cli.registry.provider",
     "AdminProvider": "quadkit.cli.registry.provider",
+    "ApiPreset": "quadkit.cli.registry.presets",
+    "ApiTemplate": "quadkit.cli.registry.template",
     "AuthConfigValidator": "quadkit.cli.registry.config",
     "AuthProvider": "quadkit.cli.registry.provider",
     "BashCompletionGenerator": "quadkit.cli.registry.completion",
@@ -46,16 +48,12 @@ LAZY_IMPORTS: dict[str, str] = {
     "FishCompletionGenerator": "quadkit.cli.registry.completion",
     "FormatOptions": "quadkit.cli.registry.formatter",
     "FormatterRegistry": "quadkit.cli.registry.formatter",
-    "FullStackPreset": "quadkit.cli.registry.presets",
-    "FullStackTemplate": "quadkit.cli.registry.template",
     "GeneratorAdapter": "quadkit.cli.registry.generator",
     "GeneratorRegistry": "quadkit.cli.registry.generator",
     "GeneratorResult": "quadkit.cli.registry.generator",
     "GitCheck": "quadkit.cli.registry.health",
     "GranianBackend": "quadkit.cli.registry.server",
-    "GraphQLPreset": "quadkit.cli.registry.presets",
     "GraphQLProvider": "quadkit.cli.registry.provider",
-    "GraphQLTemplate": "quadkit.cli.registry.template",
     "GunicornBackend": "quadkit.cli.registry.server",
     "HealthCheck": "quadkit.cli.registry.health",
     "HealthCheckRegistry": "quadkit.cli.registry.health",
@@ -73,10 +71,7 @@ LAZY_IMPORTS: dict[str, str] = {
     "JSONFormatter": "quadkit.cli.registry.formatter",
     "LoggingHook": "quadkit.cli.registry.hook",
     "MessagingProvider": "quadkit.cli.registry.provider",
-    "MicroservicePreset": "quadkit.cli.registry.presets",
     "MiddlewareInspector": "quadkit.cli.registry.inspect",
-    "MinimalPreset": "quadkit.cli.registry.presets",
-    "MinimalTemplate": "quadkit.cli.registry.template",
     "MonitorProvider": "quadkit.cli.registry.provider",
     "MonitoringProvider": "quadkit.cli.registry.provider",
     "MySQLBackend": "quadkit.cli.registry.database",
@@ -141,11 +136,7 @@ LAZY_IMPORTS: dict[str, str] = {
     "VersionInfo": "quadkit.cli.registry.version",
     "VersionRegistry": "quadkit.cli.registry.version",
     "VersionSource": "quadkit.cli.registry.version",
-    "WebAPIPreset": "quadkit.cli.registry.presets",
-    "WebAPITemplate": "quadkit.cli.registry.template",
     "WebProvider": "quadkit.cli.registry.provider",
-    "WorkerPreset": "quadkit.cli.registry.presets",
-    "WorkerTemplate": "quadkit.cli.registry.template",
     "YAMLFormatter": "quadkit.cli.registry.formatter",
     "ZshCompletionGenerator": "quadkit.cli.registry.completion",
     "create_database_connection": "quadkit.cli.registry.database",

quadkit_cli-0.0.45/src/quadkit/cli/registry/presets.py

@@ -0,0 +1,104 @@
+"""Presets registry for application presets.
+
+This module provides a registry pattern for application presets.
+"""
+
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass, field
+from typing import Any, ClassVar
+
+from quadkit.cli.package_names import packages_for
+
+
+@dataclass
+class Preset:
+    """A preset configuration of providers."""
+
+    name: str
+    description: str
+    packages: list[str] = field(default_factory=list)
+    config: dict[str, Any] = field(default_factory=dict)
+
+
+class PresetDefinition(abc.ABC):
+    """Abstract base class for preset definitions."""
+
+    name: ClassVar[str]
+    description: ClassVar[str]
+    packages: ClassVar[list[str]] = []
+    config: ClassVar[dict[str, Any]] = {}
+
+    @abc.abstractmethod
+    def get_preset(self) -> Preset:
+        """Get the preset configuration."""
+
+
+class ApiPreset(PresetDefinition):
+    """The single application preset: REST API with the web framework."""
+
+    name = "api"
+    description = "REST API with the web framework"
+    packages = packages_for("web")
+    config = {
+        "web": {"host": "0.0.0.0", "port": 8000},  # noqa: S104 — preset template default
+    }
+
+    def get_preset(self) -> Preset:
+        return Preset(
+            name=self.name,
+            description=self.description,
+            packages=self.packages.copy(),
+            config=self.config.copy(),
+        )
+
+
+class PresetRegistry:
+    """Registry for application presets.
+
+    Instances are always empty — use :meth:`with_defaults` for the
+    in-package built-ins or :meth:`register` for plugin presets.
+    """
+
+    def __init__(self) -> None:
+        self._presets: dict[str, Preset] = {}
+
+    def register(self, preset_class: type[PresetDefinition]) -> None:
+        """Register a preset class."""
+        instance = preset_class()
+        preset = instance.get_preset()
+        self._presets[preset.name] = preset
+
+    def get(self, name: str) -> Preset | None:
+        """Get a preset by name."""
+        return self._presets.get(name)
+
+    def get_all(self) -> dict[str, Preset]:
+        """Get all registered presets."""
+        return self._presets.copy()
+
+    def get_choices(self) -> list[str]:
+        """Get list of available preset names."""
+        return list(self._presets.keys())
+
+    @classmethod
+    def _default_entries(cls) -> tuple[type[PresetDefinition], ...]:
+        """Return the built-in presets (a single one today)."""
+        return (ApiPreset,)
+
+    @classmethod
+    def with_defaults(cls) -> PresetRegistry:
+        """Return an instance populated with the built-in presets."""
+        registry = cls()
+        for entry in cls._default_entries():
+            registry.register(entry)
+        return registry
+
+
+__all__ = [
+    "ApiPreset",
+    "Preset",
+    "PresetDefinition",
+    "PresetRegistry",
+]

{quadkit_cli-0.0.43 → quadkit_cli-0.0.45}/src/quadkit/cli/registry/template.py

@@ -9,7 +9,7 @@ import abc
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, ClassVar
 
-from quadkit.cli.package_names import packages_for, provider_available
+from quadkit.cli.package_names import packages_for
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -43,76 +43,12 @@ class ProjectTemplate(abc.ABC):
         return self.packages.copy()
 
 
-class MinimalTemplate(ProjectTemplate):
-    """Minimal template with just the core framework."""
+class ApiTemplate(ProjectTemplate):
+    """The single project template: REST API with the web framework."""
 
-    name = "minimal"
-    description = "Bare minimum Quadkit application"
-    packages = [
-        "quadkit",
-    ]
-
-    def get_config(self) -> TemplateConfig:
-        return TemplateConfig(
-            name=self.name,
-            description=self.description,
-            packages=self.packages,
-        )
-
-
-class WebAPITemplate(ProjectTemplate):
-    """REST API template."""
-
-    name = "web-api"
-    description = "REST API with web framework"
-    packages = packages_for("web", "sql")
-
-    def get_config(self) -> TemplateConfig:
-        return TemplateConfig(
-            name=self.name,
-            description=self.description,
-            packages=self.packages,
-        )
-
-
-class GraphQLTemplate(ProjectTemplate):
-    """GraphQL API template."""
-
-    name = "graphql"
-    description = "GraphQL API with web framework"
-    packages = packages_for("web", "sql", "graphql")
-
-    def get_config(self) -> TemplateConfig:
-        return TemplateConfig(
-            name=self.name,
-            description=self.description,
-            packages=self.packages,
-        )
-
-
-class WorkerTemplate(ProjectTemplate):
-    """Background worker template."""
-
-    name = "worker"
-    description = "Background job processor"
-    packages = packages_for("sql", "tasks", "queue")
-
-    def get_config(self) -> TemplateConfig:
-        return TemplateConfig(
-            name=self.name,
-            description=self.description,
-            packages=self.packages,
-        )
-
-
-class FullStackTemplate(ProjectTemplate):
-    """Full-stack application template."""
-
-    name = "fullstack"
-    description = "Full application: auth, cache, storage, events, tasks, HTTP, monitoring"
-    packages = packages_for(
-        "web", "sql", "auth", "cache", "storage", "events", "tasks", "http", "monitor"
-    )
+    name = "api"
+    description = "REST API with the web framework"
+    packages = packages_for("web")
 
     def get_config(self) -> TemplateConfig:
         return TemplateConfig(
@@ -151,17 +87,8 @@ class TemplateRegistry:
 
     @classmethod
     def _default_entries(cls) -> tuple[type[ProjectTemplate], ...]:
-        """Return templates supported by installed optional providers."""
-        entries: list[type[ProjectTemplate]] = [MinimalTemplate, WebAPITemplate]
-        optional = (
-            (GraphQLTemplate, ("sql", "graphql")),
-            (WorkerTemplate, ("sql", "tasks", "queue")),
-            (FullStackTemplate, ("web", "sql", "auth", "cache", "storage", "events", "tasks", "http", "monitor")),
-        )
-        for entry, features in optional:
-            if all(provider_available(feature) for feature in features):
-                entries.append(entry)
-        return tuple(entries)
+        """Return the built-in templates (a single one today)."""
+        return (ApiTemplate,)
 
     @classmethod
     def with_defaults(cls) -> TemplateRegistry:
@@ -214,13 +141,9 @@ class ProjectBuilder:
 
 
 __all__ = [
-    "FullStackTemplate",
-    "GraphQLTemplate",
-    "MinimalTemplate",
+    "ApiTemplate",
     "ProjectBuilder",
     "ProjectTemplate",
     "TemplateConfig",
     "TemplateRegistry",
-    "WebAPITemplate",
-    "WorkerTemplate",
 ]

{quadkit_cli-0.0.43 → quadkit_cli-0.0.45}/src/quadkit/cli/scaffold/__init__.py

@@ -4,9 +4,12 @@ Single source of truth for project bootstrapping — the catalogue lives in
 :mod:`quadkit.cli.scaffold.specs`, the rendered files in
 :mod:`quadkit.cli.scaffold.app_files`, :mod:`quadkit.cli.scaffold.module_files`
 and :mod:`quadkit.cli.scaffold.support_files`, and the writers in
-:mod:`quadkit.cli.scaffold.render`:
+:mod:`quadkit.cli.scaffold.render`. Project metadata is rendered by
+:func:`render_project_metadata` from an explicit :class:`ProjectMetadataContext`;
+downstream builders can use this side-effect-free API without depending on
+private template functions:
 
-- ``quadkit new project --template <name>`` (``commands/new.py``)
+- ``quadkit new project`` (``commands/new.py``)
 - ``ProjectBuilder.create_project`` (``registry/template.py``)
 - scaffold alignment tests (``tests/unit/test_scaffold_alignment.py``)
 
@@ -15,7 +18,7 @@ Every generated file targets the **real** quadkit APIs (``Application``,
 generator map** in :mod:`quadkit.cli.layout`, so a scaffolded project and
 its generators stay aligned:
 
-    quadkit new project myapp --template web-api
+    quadkit new project myapp
     cd myapp && pip install -e .
     quadkit gen controller users  # src/myapp/controllers/users_controller.py
     quadkit dev                   # WebModule auto-discovers it
@@ -36,10 +39,13 @@ and directly in pytest fixtures.
 
 from __future__ import annotations
 
+from quadkit.cli.scaffold.metadata import (
+    ProjectMetadataContext,
+    render_project_metadata,
+)
 from quadkit.cli.scaffold.render import render_module, render_project
 from quadkit.cli.scaffold.specs import (
     _TEMPLATE_SPECS,
-    TEMPLATE_ALIASES,
     TEMPLATES,
     ProjectTemplateSpec,
     component_packages,
@@ -50,9 +56,11 @@ from quadkit.cli.scaffold.specs import (
 
 __all__ = [
     "TEMPLATES",
+    "ProjectMetadataContext",
     "component_packages",
     "render_module",
     "render_project",
+    "render_project_metadata",
     "resolve_template",
     "root_output_dirs",
     "template_names",

quadkit_cli-0.0.45/src/quadkit/cli/scaffold/metadata.py

@@ -0,0 +1,204 @@
+"""Project-level metadata renderers shared by CLI and downstream builders.
+
+These renderers are intentionally side-effect free. Consumers provide the
+facts from the project they are creating; the renderer returns a deterministic
+map of files to add to that project. The generated-app profile is separate
+from any framework website or release metadata profile.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+import re
+
+__all__ = ["ProjectMetadataContext", "render_project_metadata"]
+
+
+@dataclass(frozen=True, slots=True)
+class ProjectMetadataContext:
+    """Facts needed to render concise, project-specific agent instructions.
+
+    Args:
+        project_name: Human-facing project name.
+        package_name: Importable Python package name.
+        summary: Short project description.
+        template_name: Scaffold/template identifier, not a release version.
+        features: Framework features actually present in the generated project.
+        dependencies: Direct requirements emitted into the project's manifest.
+        layout: Existing important paths and their purpose, relative to project
+            root. Paths must refer to this generated project, not the framework
+            checkout.
+        commands: Commands valid for the generated project and their purpose.
+        notes: Project-specific operational notes, e.g. a generated dev secret
+            must be replaced before deployment.
+    """
+
+    project_name: str
+    package_name: str
+    summary: str
+    template_name: str
+    features: tuple[str, ...]
+    dependencies: tuple[str, ...]
+    layout: tuple[tuple[str, str], ...]
+    commands: tuple[tuple[str, str], ...]
+    notes: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        """Reject unsafe or malformed values before rendering Markdown."""
+        if not re.fullmatch(r"[A-Za-z][A-Za-z0-9_-]*", self.project_name):
+            raise ValueError("project_name must be a safe project slug")
+        if not re.fullmatch(r"[A-Za-z][A-Za-z0-9_]*", self.package_name):
+            raise ValueError("package_name must be a Python package identifier")
+        _require_single_line("summary", self.summary, allow_backticks=True)
+        _require_single_line("template_name", self.template_name)
+        for item in self.features:
+            _require_single_line("feature", item)
+        for item in self.dependencies:
+            _require_single_line("dependency", item)
+        if not self.summary.strip():
+            raise ValueError("summary must not be empty")
+        if not self.template_name.strip():
+            raise ValueError("template_name must not be empty")
+        if len(set(self.features)) != len(self.features):
+            raise ValueError("features must not contain duplicates")
+        if len(set(self.dependencies)) != len(self.dependencies):
+            raise ValueError("dependencies must not contain duplicates")
+        for path, purpose in self.layout:
+            _validate_project_path(path)
+            _require_single_line("layout purpose", purpose, allow_backticks=True)
+        for command, purpose in self.commands:
+            _require_single_line("command", command)
+            _require_single_line("command purpose", purpose, allow_backticks=True)
+            if not command.strip():
+                raise ValueError("commands must not contain empty commands")
+        for note in self.notes:
+            _require_single_line("note", note, allow_backticks=True)
+        if len({path for path, _ in self.layout}) != len(self.layout):
+            raise ValueError("layout paths must be unique")
+        if len({command for command, _ in self.commands}) != len(self.commands):
+            raise ValueError("commands must be unique")
+
+
+def _require_single_line(
+    label: str, value: str, *, allow_backticks: bool = False
+) -> None:
+    if "\n" in value or "\r" in value or ("`" in value and not allow_backticks):
+        detail = "single line"
+        if not allow_backticks:
+            detail += " without backticks"
+        raise ValueError(f"{label} must be {detail}")
+
+
+def _validate_project_path(path: str) -> None:
+    """Require a normalized, relative path that remains inside the project."""
+    _require_single_line("layout path", path)
+    if not path or path.startswith(("/", "\\")) or "\\" in path:
+        raise ValueError(
+            f"layout path must be a non-empty relative POSIX path: {path!r}"
+        )
+    normalized = path[:-1] if path.endswith("/") else path
+    parts = normalized.split("/")
+    if not normalized or any(part in {"", ".", ".."} for part in parts):
+        raise ValueError(f"layout path is not normalized: {path!r}")
+
+
+def _escape_markdown(value: str) -> str:
+    """Escape inline Markdown punctuation in caller-supplied prose."""
+    return re.sub(r"([\\`*_{}\[\]()#+.!|>])", r"\\\1", value)
+
+
+def _inline_code(value: str) -> str:
+    """Render one validated single-line value as inline code."""
+    return f"`{value}`"
+
+
+def _render_agents_md(context: ProjectMetadataContext) -> str:
+    features = ", ".join(_inline_code(feature) for feature in context.features)
+    if not features:
+        features = "none declared by the selected template"
+
+    lines = [
+        f"# Agent Guide: {context.project_name}",
+        "",
+        "This file is project-specific guidance for coding agents. `README.md` is",
+        "the human quickstart; this file adds the project map, commands, and the",
+        "QuadKit conventions relevant to this scaffold. Update it when the project",
+        "layout or workflow changes.",
+        "",
+        "## Project summary",
+        "",
+        _escape_markdown(context.summary),
+        "",
+        f"- Scaffold: {_inline_code(context.template_name)}",
+        f"- Python package: {_inline_code(context.package_name)}",
+        f"- Framework features: {features}",
+        "",
+        "## Start here",
+        "",
+        "1. Read `README.md` for the project overview and quickstart.",
+        "2. Read `application.yaml` before changing runtime configuration.",
+        f"3. Treat `src/{context.package_name}/app.py` as the composition root; inspect it before changing module wiring.",
+        "4. Consult the linked QuadKit docs when a framework convention is unclear.",
+        "",
+        "## Useful commands",
+        "",
+    ]
+    if context.commands:
+        for command, purpose in context.commands:
+            lines.append(f"- {_inline_code(command)} — {_escape_markdown(purpose)}")
+    else:
+        lines.append("- No project commands were supplied by the scaffold context.")
+
+    lines += ["", "## Project map", ""]
+    for path, purpose in context.layout:
+        lines.append(f"- {_inline_code(path)} — {_escape_markdown(purpose)}")
+
+    lines += [
+        "",
+        "## QuadKit conventions",
+        "",
+        "- Preserve the existing project tree: feature code belongs in its feature",
+        "  package; cross-cutting code belongs in `shared/`; bounded contexts live",
+        "  under `modules/<name>/` when this project uses modules.",
+        "- Keep the composition root focused on assembling configuration, providers,",
+        "  and modules. Put business behavior in services/domain types rather than",
+        "  growing app wiring into a second service locator.",
+        "- Prefer the framework's typed protocols and constructor injection. Use",
+        "  `Result[T, E]` for expected domain failures and exceptions for unexpected",
+        "  infrastructure failures; follow the existing local patterns first.",
+        "- Keep I/O asynchronous where the surrounding API is asynchronous. Do not",
+        "  introduce a parallel `models/` tree; follow the generated `domains/`",
+        "  layout and the canonical QuadKit project-structure guide.",
+        "- Add or update tests with behavior changes. Keep configuration examples",
+        "  and tests aligned with the actual package set in `pyproject.toml`.",
+        "",
+        "## QuadKit references",
+        "",
+        "- [For coding agents](https://oridecon.dev/quadkit/getting-started/for-coding-agents/)",
+        "- [Project structure](https://oridecon.dev/quadkit/getting-started/project-structure/)",
+        "- [Testing guide](https://oridecon.dev/quadkit/guides/testing/)",
+        "- [Common mistakes](https://oridecon.dev/quadkit/getting-started/common-mistakes/)",
+    ]
+
+    if context.dependencies:
+        lines += ["", "## Declared dependencies", ""]
+        lines.extend(f"- {_inline_code(item)}" for item in context.dependencies)
+
+    if context.notes:
+        lines += ["", "## Important project notes", ""]
+        lines.extend(f"- {_escape_markdown(note)}" for note in context.notes)
+
+    return "\n".join(lines) + "\n"
+
+
+def render_project_metadata(
+    context: ProjectMetadataContext,
+) -> Mapping[str, str]:
+    """Return deterministic project metadata files for *context*.
+
+    The initial generated-app profile emits only ``AGENTS.md``. It deliberately
+    does not create website-only resources such as ``llms.txt``, crawler rules,
+    or an Agent Skills pack.
+    """
+    return {"AGENTS.md": _render_agents_md(context)}