docs/mcp/doc-forge/modules/docforge.json

{
  "module": "docforge",
  "content": {
    "path": "docforge",
    "docstring": "# Summary\n\nRenderer-agnostic Python documentation compiler that converts Python docstrings\ninto structured documentation for both humans (MkDocs) and machines (MCP / AI agents).\n\n`doc-forge` statically analyzes source code, builds a semantic model of modules,\nclasses, functions, and attributes, and renders that model into documentation\noutputs without executing user code.\n\n---\n\n# Installation\n\nInstall using pip:\n\n```bash\npip install doc-forge\n```\n\n---\n\n# CLI usage\n\nEach site kind (`lib`, `api`, `wiki`) is built independently into `site/{kind}`.\n\n## Build the library reference from a Python package:\n\n```bash\ndoc-forge build --mkdocs --module my_package\n```\n\n## Build the API reference from an OpenAPI spec:\n\n```bash\ndoc-forge build --api --openapi-spec spec.json\n```\n\n## Build the hand-written wiki:\n\n```bash\ndoc-forge build --wiki --site-name my_package\n```\n\n## Generate MCP JSON documentation:\n\n```bash\ndoc-forge build --mcp --module my_package\n```\n\n## Build several kinds in one pass:\n\n```bash\ndoc-forge build --mcp --mkdocs --wiki --module my_package\n```\n\nEach enabled kind gets its own MkDocs config (`docs/mkdocs.{lib,api,wiki}.yml`)\nand its own site under `site/`.\n\n## Serve a site locally:\n\n```bash\ndoc-forge serve --wiki        # preview from docs/mkdocs.wiki.yml\ndoc-forge serve --lib\ndoc-forge serve --api\n# or any config directly:\ndoc-forge serve --mkdocs --mkdocs-yml docs/mkdocs.wiki.yml\n```\n\n## Serve MCP locally:\n\n```bash\ndoc-forge serve --mcp --module my_package\n```\n\n---\n\n# Core concepts\n\n## Loader\nExtracts symbols, signatures, and docstrings using static analysis.\n\n## Semantic model\nStructured, renderer-agnostic representation of the API.\n\n## Renderer\nConverts the semantic model into output formats such as MkDocs or MCP JSON.\n\n## Symbol\nAny documentable object\n\n- module\n- class\n- function\n- method\n- property\n- attribute\n\n---\n\n# Architecture\n\n`doc-forge` follows a compiler architecture:\n\n## Front-end:\n\nStatic analysis of modules, classes, functions, type hints, and docstrings.\n\n## Middle-end:\n\nBuilds a semantic model describing symbols and relationships.\n\n## Back-end:\n\nRenders documentation using interchangeable renderers.\n\nThis architecture ensures deterministic documentation generation.\n\n---\n\n# Rendering pipeline\n\nTypical flow:\n\n    Python package\n        |\n    Loader (static analysis)\n        |\n    Semantic model\n        |\n    Renderer\n        |\n    MkDocs site or MCP JSON\n\n---\n\n# Google-Styled Doc-Forge Convention (GSDFC)\n\nGSDFC defines how docstrings must be written so they render correctly in MkDocs and remain machine-parsable by doc-forge and AI tooling.\n\n- Docstrings are the single source of truth.\n- `doc-forge` compiles docstrings but does not generate documentation content.\n- Documentation follows the Python import hierarchy.\n- Every public symbol should have a complete and accurate docstring.\n\n---\n\n## General rules\n\n- Use **Markdown headings** at package and module level.\n- Use **Google-style structured sections** at class, function, and method level.\n- Use type hints in signatures.\n- Use parenthesized types in prose entries (`name (Type):`) that match the\n  signature types. This keeps docstrings self-contained and machine-parseable.\n- Write summaries in imperative form.\n- Sections are separated by `---`\n\n---\n\n# Notes subsection grouping\n\nGroup related information using labeled subsections.\n\nExample:\n\n    Notes:\n        **Guarantees:**\n\n            - deterministic behavior\n\n        **Lifecycle:**\n\n            - created during initialization\n            - reused across executions\n\n        **Thread safety:**\n\n            - safe for concurrent reads\n\n---\n\n# Example formatting\n\n- Use indentation for examples.\n- Indent section contents using four spaces.\n- Use code blocks for example code.\n\nExample:\n    Single example:\n\n        Example:\n\n            ```python\n            foo = Foo(\"example\")\n            process(foo, multiplier=2)\n            ```\n\n    Multiple examples:\n\n        Example:\n            Create foo:\n\n                ```python\n                foo = Foo(\"example\")\n                ```\n\n            Run engine:\n\n                ```python\n                engine = BarEngine([foo])\n                engine.run()\n                ```\n\nAvoid fenced code blocks inside argument descriptions and other prose lines.\n\nInside `Example:` sections, fenced `python` code blocks are allowed and must be\nindented four spaces, matching the examples below.\n\n---\n\n# Separator rules\n\nUse horizontal separators only at docstring root level to separate sections:\n\n```markdown\n---\n```\n\nAllowed locations:\n\n- package docstrings\n- module docstrings\n- major documentation sections\n\nDo not use separators inside code sections.\n\n---\n\n# Package docstrings\n\nPackage docstrings act as the documentation home page.\n\nRecommended sections:\n\n    # Summary\n    # Installation\n    # Quick start\n    # CLI usage\n    # Core concepts\n    # Architecture\n    # Rendering pipeline\n    # Examples\n    # Notes\n\nExample:\n    Package Doc String:\n\n        '''\n        # Summary\n\n        Foo-bar processing framework.\n\n        Provides tools for defining Foo objects and executing Bar pipelines.\n\n        ---\n\n        # Installation\n\n        ```bash\n        pip install foo-bar\n        ```\n\n        ---\n\n        # Quick start\n\n        ```python\n        from foobar import Foo, BarEngine\n\n        foo = Foo(\"example\")\n        engine = BarEngine([foo])\n\n        result = engine.run()\n        ```\n\n        ---\n        '''\n\n---\n\n# Module docstrings\n\nModule docstrings describe a subsystem.\n\nRecommended sections:\n\n    # Summary\n    # Examples\n    # Notes\n\nExample:\n    Module Doc String:\n\n        '''\n        # Summary\n\n        Foo execution subsystem.\n\n        Provides utilities for executing Foo objects through Bar stages.\n\n        ---\n\n        Example:\n\n            ```python\n            from foobar.engine import BarEngine\n            from foobar.foo import Foo\n\n            foo = Foo(\"example\")\n\n            engine = BarEngine([foo])\n            engine.run()\n            ```\n\n        ---\n        '''\n\n---\n\n# Class docstrings\n\nClass docstrings define object responsibility, lifecycle, and attributes.\n\nRecommended sections:\n\n    Attributes:\n    Notes:\n    Example:\n    Raises:\n\nExample:\n    Simple Foo:\n\n    ```python\n    class Foo:\n        '''\n        Represents a unit of work.\n\n        Attributes:\n            name (str):\n                Identifier of the foo instance.\n\n            value (int):\n                Numeric value associated with foo.\n\n        Notes:\n            Guarantees:\n\n                - instances are immutable after creation\n\n            Lifecycle:\n\n                - create instance\n                - pass to processing engine\n\n        Example:\n            Create and inspect a Foo:\n\n                ```python\n                foo = Foo(\"example\", value=42)\n                print(foo.name)\n                ```\n        '''\n    ```\n\n    Complex Bar:\n\n    ```python\n    class BarEngine:\n        '''\n        Executes Foo objects through Bar stages.\n\n        Attributes:\n            foos (tuple[Foo, ...]):\n                Foo instances managed by the engine.\n\n        Notes:\n            Guarantees:\n\n                - deterministic execution order\n\n        Example:\n            Run engine:\n\n                ```python\n                foo1 = Foo(\"a\")\n                foo2 = Foo(\"b\")\n\n                engine = BarEngine([foo1, foo2])\n                engine.run()\n                ```\n        '''\n    ```\n\n---\n\n# Function and method docstrings\n\nFunction docstrings define API contracts.\n\nRecommended sections:\n\n    Args:\n    Returns:\n    Raises:\n    Yields:\n    Notes:\n    Example:\n\nExample:\n    Simple process method:\n\n    ```python\n    def process(foo: Foo, multiplier: int) -> int:\n        '''\n        Process a Foo instance.\n\n        Args:\n            foo (Foo):\n                Foo instance to process.\n\n            multiplier (int):\n                Value used to scale foo.\n\n        Returns:\n            int:\n                Processed result.\n\n        Raises:\n            ValueError:\n                If multiplier is negative.\n\n        Notes:\n            Guarantees:\n\n                - foo is not modified\n\n        Example:\n            Process foo:\n\n                ```python\n                foo = Foo(\"example\", value=10)\n\n                result = process(foo, multiplier=2)\n                print(result)\n                ```\n        '''\n    ```\n\n    Multiple Examples:\n\n    ```python\n    def combine(foo_a: Foo, foo_b: Foo) -> Foo:\n        '''\n        Combine two Foo instances.\n\n        Args:\n            foo_a (Foo):\n                First foo.\n\n            foo_b (Foo):\n                Second foo.\n\n        Returns:\n            Foo:\n                Combined foo.\n\n        Example:\n            Basic usage:\n\n                ```python\n                foo1 = Foo(\"a\")\n                foo2 = Foo(\"b\")\n\n                combined = combine(foo1, foo2)\n                ```\n\n            Pipeline usage:\n\n                ```python\n                engine = BarEngine([foo1, foo2])\n                engine.run()\n                ```\n        '''\n    ```\n\n---\n\n# Property docstrings\n\nProperties must document return values.\n\nExample:\n    Property Doc String:\n\n        ```python\n        @property\n        def foos(self) -> tuple[Foo, ...]:\n            '''\n            Return contained Foo instances.\n\n            Returns:\n                tuple[Foo, ...]:\n                    Stored foo objects.\n\n            Example:\n                ```python\n                container = FooContainer()\n\n                foos = container.foos\n                ```\n            '''\n        ```\n\n---\n\n# Attribute documentation\n\nDocument attributes in class docstrings using `Attributes:`.\n\nExample:\n    Attribute Doc String:\n\n        ```python\n        '''\n        Represents a processing stage.\n\n        Attributes:\n            id (str):\n                Unique identifier.\n\n            enabled (bool):\n                Whether the stage is active.\n        '''\n        ```\n\n---\n\n# Type parity (`.pyi` stubs and `py.typed`)\n\nDocumented APIs ship matching type information:\n\n- Each `.py` module has a synchronized `.pyi` stub in the same package.\n- Packages expose a `py.typed` marker so type checkers (and consumers)\n  use the authored signatures instead of `Any`.\n- When signatures change, update the `.py` implementation and its `.pyi`\n  stub together.\n- Doc-forge documents the docstrings in `.py`; the `.pyi` stub is the\n  machine-consumable signature surface.\n\n---\n\n# Parsing guarantees\n\nGSDFC ensures doc-forge can deterministically extract:\n\n- symbol kind (module, class, function, property, attribute)\n- symbol name\n- parameters\n- return values\n- attributes\n- examples\n- structured Notes subsections\n\nThis enables:\n\n- reliable MkDocs rendering\n- deterministic MCP export\n- accurate AI semantic interpretation\n\n---\n\nNotes:\n    - doc-forge never executes analyzed modules.\n    - Documentation is generated entirely through static analysis.",
    "objects": {
      "GriffeLoader": {
        "name": "GriffeLoader",
        "kind": "class",
        "path": "docforge.GriffeLoader",
        "signature": "GriffeLoader()",
        "docstring": "Load Python modules using Griffe and convert them into doc-forge models.\n\nThis loader uses the Griffe introspection engine to analyze Python source\ncode and transform the extracted information into `Project`, `Module`,\nand `DocObject` instances used by doc-forge.\n\nAttributes:\n    _loader (_GriffeLoader):\n        Internal Griffe loader with dedicated module and line collections.",
        "members": {
          "load_project": {
            "name": "load_project",
            "kind": "function",
            "path": "docforge.GriffeLoader.load_project",
            "signature": "load_project(module_paths: list[str], project_name: str | None = None, skip_import_errors: bool | None = None)",
            "docstring": "Load multiple modules and assemble them into a Project model.\n\nEach module path is introspected and converted into a `Module`\ninstance. All modules are then aggregated into a single `Project`\nobject.\n\nArgs:\n    module_paths (list[str]):\n        List of dotted module import paths to load.\n\n    project_name (str | None):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool | None):\n        If True, modules that fail to load will be skipped instead of raising an error.\n\nReturns:\n    Project:\n        A populated `Project` instance containing the loaded modules.\n\nRaises:\n    ValueError:\n        If no module paths are provided.\n\n    ImportError:\n        If a module fails to load and `skip_import_errors` is False."
          },
          "load_module": {
            "name": "load_module",
            "kind": "function",
            "path": "docforge.GriffeLoader.load_module",
            "signature": "load_module(path: str)",
            "docstring": "Load and convert a single Python module.\n\nThe module is introspected using Griffe and then transformed into\na doc-forge `Module` model.\n\nArgs:\n    path (str):\n        Dotted import path of the module.\n\nReturns:\n    Module:\n        A populated `Module` instance.\n\nRaises:\n    ImportError:\n        If the module cannot be loaded by Griffe.\n\n    KeyError:\n        If the loaded module is missing from the module collection.\n\nExample:\n    Load a single module:\n\n        ```python\n        loader = GriffeLoader()\n        module = loader.load_module(\"mypackage.submodule\")\n        ```"
          }
        }
      },
      "discover_module_paths": {
        "name": "discover_module_paths",
        "kind": "function",
        "path": "docforge.discover_module_paths",
        "signature": "discover_module_paths(module_name: str, project_root: Path | None = None)",
        "docstring": "Discover Python modules within a package directory.\n\nThe function scans the filesystem for `.py` files inside the specified\npackage and converts them into dotted module import paths.\n\nDiscovery rules:\n\n- Directories containing `__init__.py` are treated as packages.\n- Each `.py` file is treated as a module.\n- Results are returned as dotted import paths.\n\nArgs:\n    module_name (str):\n        Top-level package name to discover modules from.\n\n    project_root (Path | None):\n        Root directory used to resolve module paths. If not provided, the\n        current working directory is used.\n\nReturns:\n    list[str]:\n        A sorted list of unique dotted module import paths.\n\nRaises:\n    FileNotFoundError:\n        If the specified package directory does not exist."
      },
      "MkDocsRenderer": {
        "name": "MkDocsRenderer",
        "kind": "class",
        "path": "docforge.MkDocsRenderer",
        "signature": null,
        "docstring": "Renderer that produces Markdown documentation for MkDocs.\n\nGenerated pages use mkdocstrings directives to reference Python modules,\nallowing MkDocs to render API documentation dynamically.",
        "members": {
          "name": {
            "name": "name",
            "kind": "attribute",
            "path": "docforge.MkDocsRenderer.name",
            "signature": null,
            "docstring": null
          },
          "generate_sources": {
            "name": "generate_sources",
            "kind": "function",
            "path": "docforge.MkDocsRenderer.generate_sources",
            "signature": "generate_sources(project: Project, out_dir: Path, module_is_source: bool | None = None)",
            "docstring": "Generate Markdown documentation files for a project.\n\nThis method renders a documentation structure from the provided\nproject model and writes the resulting Markdown files to the\nspecified output directory.\n\nArgs:\n    project (Project):\n        Project model containing modules to document.\n\n    out_dir (Path):\n        Directory where generated Markdown files will be written.\n\n    module_is_source (bool | None):\n        If True, treat the specified module as the documentation root\n        rather than nesting it inside a folder."
          },
          "generate_readme": {
            "name": "generate_readme",
            "kind": "function",
            "path": "docforge.MkDocsRenderer.generate_readme",
            "signature": "generate_readme(project: Project, docs_dir: Path, module_is_source: bool | None = None, readme_dir: Path | None = None)",
            "docstring": "Generate a `README.md` file from the root module docstring.\n\nNotes:\n    - If `module_is_source` is True, `README.md` is written to the\n      project root directory.\n    - If False, README generation is currently not implemented.\n\nArgs:\n    project (Project):\n        Project model containing documentation metadata.\n\n    docs_dir (Path):\n        Directory containing generated documentation sources.\n\n    module_is_source (bool | None):\n        Whether the module is treated as the project source root.\n\n    readme_dir (Path | None):\n        Directory where the generated README.md should be written.\n        Defaults to the parent of `docs_dir`."
          }
        }
      },
      "MCPRenderer": {
        "name": "MCPRenderer",
        "kind": "class",
        "path": "docforge.MCPRenderer",
        "signature": null,
        "docstring": "Renderer that generates MCP-compatible documentation resources.\n\nThis renderer converts doc-forge project models into structured JSON\nresources suitable for consumption by systems implementing the Model\nContext Protocol (MCP).",
        "members": {
          "name": {
            "name": "name",
            "kind": "attribute",
            "path": "docforge.MCPRenderer.name",
            "signature": null,
            "docstring": null
          },
          "generate_sources": {
            "name": "generate_sources",
            "kind": "function",
            "path": "docforge.MCPRenderer.generate_sources",
            "signature": "generate_sources(project: Project, out_dir: Path)",
            "docstring": "Generate MCP documentation resources for a project.\n\nThe renderer serializes each module into a JSON resource and produces\nsupporting metadata files such as `nav.json` and `index.json`.\n\nArgs:\n    project (Project):\n        Documentation project model to render.\n\n    out_dir (Path):\n        Directory where MCP resources will be written."
          }
        }
      },
      "main": {
        "name": "main",
        "kind": "module",
        "path": "docforge.main",
        "signature": null,
        "docstring": "# Summary\n\nCommand-line entry point for the doc-forge CLI.\n\nThis module exposes the executable entry point that initializes the\nClick command group defined in `docforge.cli.commands`.",
        "members": {
          "cli": {
            "name": "cli",
            "kind": "attribute",
            "path": "docforge.main.cli",
            "signature": null,
            "docstring": null
          },
          "main": {
            "name": "main",
            "kind": "function",
            "path": "docforge.main.main",
            "signature": "main()",
            "docstring": "Run the doc-forge command-line interface.\n\nThis function initializes and executes the Click CLI application.\nIt is used as the console entry point when invoking `doc-forge`\nfrom the command line."
          }
        }
      },
      "cli": {
        "name": "cli",
        "kind": "module",
        "path": "docforge.cli",
        "signature": null,
        "docstring": "# Summary\n\nCommand line interface entry point for doc-forge.\n\nThis module exposes the primary CLI entry function used by the\n`doc-forge` command. The actual command implementation resides in\n`docforge.cli.main`, while this module provides a stable import path\nfor external tools and the package entry point configuration.\n\nThe CLI is responsible for orchestrating documentation workflows such as\ngenerating renderer sources, building documentation sites, exporting\nmachine-readable documentation bundles, and starting development or MCP\nservers.\n\n---\n\n# Typical usage\n\nThe CLI is normally invoked through the installed command:\n\n```bash\ndoc-forge <command> [options]\n```\n\nProgrammatic invocation is also possible:\n\nExample:\n\n    ```python\n    from docforge.cli import main\n    main()\n    ```\n\n---",
        "members": {
          "main": {
            "name": "main",
            "kind": "module",
            "path": "docforge.cli.main",
            "signature": null,
            "docstring": "# Summary\n\nCommand-line entry point for the doc-forge CLI.\n\nThis module exposes the executable entry point that initializes the\nClick command group defined in `docforge.cli.commands`.",
            "members": {
              "cli": {
                "name": "cli",
                "kind": "attribute",
                "path": "docforge.cli.main.cli",
                "signature": null,
                "docstring": null
              },
              "main": {
                "name": "main",
                "kind": "function",
                "path": "docforge.cli.main.main",
                "signature": "main() -> None",
                "docstring": "Run the doc-forge command-line interface.\n\nThis function initializes and executes the Click CLI application.\nIt is used as the console entry point when invoking `doc-forge`\nfrom the command line."
              }
            }
          },
          "api_utils": {
            "name": "api_utils",
            "kind": "module",
            "path": "docforge.cli.api_utils",
            "signature": null,
            "docstring": "# Summary\n\nUtilities for building API documentation from an OpenAPI specification.",
            "members": {
              "SWAGGER_SPEC_FILENAME": {
                "name": "SWAGGER_SPEC_FILENAME",
                "kind": "attribute",
                "path": "docforge.cli.api_utils.SWAGGER_SPEC_FILENAME",
                "signature": null,
                "docstring": null
              },
              "OpenAPIMetadata": {
                "name": "OpenAPIMetadata",
                "kind": "class",
                "path": "docforge.cli.api_utils.OpenAPIMetadata",
                "signature": "OpenAPIMetadata(site_name: str, site_description: str | None, site_author: str | None)",
                "docstring": "Metadata derived from the ``info`` block of an OpenAPI specification.\n\nAttributes:\n    site_name: Spec title, used as the MkDocs site name.\n    site_description: Spec description, used as the site description.\n    site_author: Contact name (fallback: contact email), used as the\n        site author.",
                "members": {
                  "site_name": {
                    "name": "site_name",
                    "kind": "attribute",
                    "path": "docforge.cli.api_utils.OpenAPIMetadata.site_name",
                    "signature": null,
                    "docstring": null
                  },
                  "site_description": {
                    "name": "site_description",
                    "kind": "attribute",
                    "path": "docforge.cli.api_utils.OpenAPIMetadata.site_description",
                    "signature": null,
                    "docstring": null
                  },
                  "site_author": {
                    "name": "site_author",
                    "kind": "attribute",
                    "path": "docforge.cli.api_utils.OpenAPIMetadata.site_author",
                    "signature": null,
                    "docstring": null
                  }
                }
              },
              "load_openapi_spec": {
                "name": "load_openapi_spec",
                "kind": "function",
                "path": "docforge.cli.api_utils.load_openapi_spec",
                "signature": "load_openapi_spec(spec_path: Path) -> dict[Any, Any]",
                "docstring": "Load and validate an OpenAPI specification from a JSON file.\n\nArgs:\n    spec_path (Path):\n        Path to the OpenAPI JSON specification file.\n\nReturns:\n    dict:\n        The parsed OpenAPI specification.\n\nRaises:\n    click.ClickException:\n        If the file cannot be read or the ``info`` block is invalid."
              },
              "derive_metadata": {
                "name": "derive_metadata",
                "kind": "function",
                "path": "docforge.cli.api_utils.derive_metadata",
                "signature": "derive_metadata(spec: dict[Any, Any]) -> OpenAPIMetadata",
                "docstring": "Derive MkDocs site metadata from an OpenAPI spec ``info`` block.\n\nArgs:\n    spec (dict):\n        Parsed OpenAPI specification.\n\nReturns:\n    OpenAPIMetadata:\n        Site name, description, and author derived from the spec."
              },
              "generate_api_sources": {
                "name": "generate_api_sources",
                "kind": "function",
                "path": "docforge.cli.api_utils.generate_api_sources",
                "signature": "generate_api_sources(spec: dict[Any, Any], docs_dir: Path) -> None",
                "docstring": "Generate swagger-enabled Markdown sources and the spec copy.\n\nThe specification is written as ``openapi.json`` inside ``docs_dir`` and\nan ``index.md`` embedding the swagger UI is generated alongside it.\n\nArgs:\n    spec (dict):\n        Parsed OpenAPI specification.\n    docs_dir (Path):\n        Directory (for example ``docs/api``) where the swagger\n        sources are written."
              }
            }
          },
          "commands": {
            "name": "commands",
            "kind": "module",
            "path": "docforge.cli.commands",
            "signature": null,
            "docstring": "# Summary\n\nCommand definitions for the doc-forge CLI.\n\nProvides the CLI structure using Click, including build, serve, and tree commands.\n\n---\n\nNotes:\n    - The `build` command validates requested modes before generating anything.\n    - `--mkdocs`, `--api`, and `--wiki` each emit their own MkDocs config and\n      build (`docs/mkdocs.{kind}.yml` into `site/{kind}`); `--mcp` generates a\n      machine-readable bundle independently.\n\n---",
            "members": {
              "api_utils": {
                "name": "api_utils",
                "kind": "module",
                "path": "docforge.cli.commands.api_utils",
                "signature": null,
                "docstring": "# Summary\n\nUtilities for building API documentation from an OpenAPI specification.",
                "members": {
                  "SWAGGER_SPEC_FILENAME": {
                    "name": "SWAGGER_SPEC_FILENAME",
                    "kind": "attribute",
                    "path": "docforge.cli.commands.api_utils.SWAGGER_SPEC_FILENAME",
                    "signature": null,
                    "docstring": null
                  },
                  "OpenAPIMetadata": {
                    "name": "OpenAPIMetadata",
                    "kind": "class",
                    "path": "docforge.cli.commands.api_utils.OpenAPIMetadata",
                    "signature": "OpenAPIMetadata(site_name: str, site_description: str | None, site_author: str | None)",
                    "docstring": "Metadata derived from the ``info`` block of an OpenAPI specification.\n\nAttributes:\n    site_name: Spec title, used as the MkDocs site name.\n    site_description: Spec description, used as the site description.\n    site_author: Contact name (fallback: contact email), used as the\n        site author.",
                    "members": {
                      "site_name": {
                        "name": "site_name",
                        "kind": "attribute",
                        "path": "docforge.cli.commands.api_utils.OpenAPIMetadata.site_name",
                        "signature": null,
                        "docstring": null
                      },
                      "site_description": {
                        "name": "site_description",
                        "kind": "attribute",
                        "path": "docforge.cli.commands.api_utils.OpenAPIMetadata.site_description",
                        "signature": null,
                        "docstring": null
                      },
                      "site_author": {
                        "name": "site_author",
                        "kind": "attribute",
                        "path": "docforge.cli.commands.api_utils.OpenAPIMetadata.site_author",
                        "signature": null,
                        "docstring": null
                      }
                    }
                  },
                  "load_openapi_spec": {
                    "name": "load_openapi_spec",
                    "kind": "function",
                    "path": "docforge.cli.commands.api_utils.load_openapi_spec",
                    "signature": "load_openapi_spec(spec_path: Path)",
                    "docstring": "Load and validate an OpenAPI specification from a JSON file.\n\nArgs:\n    spec_path (Path):\n        Path to the OpenAPI JSON specification file.\n\nReturns:\n    dict:\n        The parsed OpenAPI specification.\n\nRaises:\n    click.ClickException:\n        If the file cannot be read or the ``info`` block is invalid."
                  },
                  "derive_metadata": {
                    "name": "derive_metadata",
                    "kind": "function",
                    "path": "docforge.cli.commands.api_utils.derive_metadata",
                    "signature": "derive_metadata(spec: dict[Any, Any])",
                    "docstring": "Derive MkDocs site metadata from an OpenAPI spec ``info`` block.\n\nArgs:\n    spec (dict):\n        Parsed OpenAPI specification.\n\nReturns:\n    OpenAPIMetadata:\n        Site name, description, and author derived from the spec."
                  },
                  "generate_api_sources": {
                    "name": "generate_api_sources",
                    "kind": "function",
                    "path": "docforge.cli.commands.api_utils.generate_api_sources",
                    "signature": "generate_api_sources(spec: dict[Any, Any], docs_dir: Path)",
                    "docstring": "Generate swagger-enabled Markdown sources and the spec copy.\n\nThe specification is written as ``openapi.json`` inside ``docs_dir`` and\nan ``index.md`` embedding the swagger UI is generated alongside it.\n\nArgs:\n    spec (dict):\n        Parsed OpenAPI specification.\n    docs_dir (Path):\n        Directory (for example ``docs/api``) where the swagger\n        sources are written."
                  }
                }
              },
              "mcp_utils": {
                "name": "mcp_utils",
                "kind": "module",
                "path": "docforge.cli.commands.mcp_utils",
                "signature": null,
                "docstring": "# Summary\n\nUtilities for working with MCP in the doc-forge CLI.\n\n---\n\nNotes:\n    - `generate_resources` produces the bundle consumed by `MCPServer`:\n      `index.json`, `nav.json`, and per-module resources under `modules/`.\n    - Resource URIs use the `docs://` scheme: `docs://index`, `docs://nav`,\n      and `docs://modules/{module}`.\n\n---",
                "members": {
                  "GriffeLoader": {
                    "name": "GriffeLoader",
                    "kind": "class",
                    "path": "docforge.cli.commands.mcp_utils.GriffeLoader",
                    "signature": "GriffeLoader()",
                    "docstring": "Load Python modules using Griffe and convert them into doc-forge models.\n\nThis loader uses the Griffe introspection engine to analyze Python source\ncode and transform the extracted information into `Project`, `Module`,\nand `DocObject` instances used by doc-forge.\n\nAttributes:\n    _loader (_GriffeLoader):\n        Internal Griffe loader with dedicated module and line collections.",
                    "members": {
                      "load_project": {
                        "name": "load_project",
                        "kind": "function",
                        "path": "docforge.cli.commands.mcp_utils.GriffeLoader.load_project",
                        "signature": "load_project(module_paths: list[str], project_name: str | None = None, skip_import_errors: bool | None = None)",
                        "docstring": "Load multiple modules and assemble them into a Project model.\n\nEach module path is introspected and converted into a `Module`\ninstance. All modules are then aggregated into a single `Project`\nobject.\n\nArgs:\n    module_paths (list[str]):\n        List of dotted module import paths to load.\n\n    project_name (str | None):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool | None):\n        If True, modules that fail to load will be skipped instead of raising an error.\n\nReturns:\n    Project:\n        A populated `Project` instance containing the loaded modules.\n\nRaises:\n    ValueError:\n        If no module paths are provided.\n\n    ImportError:\n        If a module fails to load and `skip_import_errors` is False."
                      },
                      "load_module": {
                        "name": "load_module",
                        "kind": "function",
                        "path": "docforge.cli.commands.mcp_utils.GriffeLoader.load_module",
                        "signature": "load_module(path: str)",
                        "docstring": "Load and convert a single Python module.\n\nThe module is introspected using Griffe and then transformed into\na doc-forge `Module` model.\n\nArgs:\n    path (str):\n        Dotted import path of the module.\n\nReturns:\n    Module:\n        A populated `Module` instance.\n\nRaises:\n    ImportError:\n        If the module cannot be loaded by Griffe.\n\n    KeyError:\n        If the loaded module is missing from the module collection.\n\nExample:\n    Load a single module:\n\n        ```python\n        loader = GriffeLoader()\n        module = loader.load_module(\"mypackage.submodule\")\n        ```"
                      }
                    }
                  },
                  "discover_module_paths": {
                    "name": "discover_module_paths",
                    "kind": "function",
                    "path": "docforge.cli.commands.mcp_utils.discover_module_paths",
                    "signature": "discover_module_paths(module_name: str, project_root: Path | None = None)",
                    "docstring": "Discover Python modules within a package directory.\n\nThe function scans the filesystem for `.py` files inside the specified\npackage and converts them into dotted module import paths.\n\nDiscovery rules:\n\n- Directories containing `__init__.py` are treated as packages.\n- Each `.py` file is treated as a module.\n- Results are returned as dotted import paths.\n\nArgs:\n    module_name (str):\n        Top-level package name to discover modules from.\n\n    project_root (Path | None):\n        Root directory used to resolve module paths. If not provided, the\n        current working directory is used.\n\nReturns:\n    list[str]:\n        A sorted list of unique dotted module import paths.\n\nRaises:\n    FileNotFoundError:\n        If the specified package directory does not exist."
                  },
                  "MCPRenderer": {
                    "name": "MCPRenderer",
                    "kind": "class",
                    "path": "docforge.cli.commands.mcp_utils.MCPRenderer",
                    "signature": null,
                    "docstring": "Renderer that generates MCP-compatible documentation resources.\n\nThis renderer converts doc-forge project models into structured JSON\nresources suitable for consumption by systems implementing the Model\nContext Protocol (MCP).",
                    "members": {
                      "name": {
                        "name": "name",
                        "kind": "attribute",
                        "path": "docforge.cli.commands.mcp_utils.MCPRenderer.name",
                        "signature": null,
                        "docstring": null
                      },
                      "generate_sources": {
                        "name": "generate_sources",
                        "kind": "function",
                        "path": "docforge.cli.commands.mcp_utils.MCPRenderer.generate_sources",
                        "signature": "generate_sources(project: Project, out_dir: Path)",
                        "docstring": "Generate MCP documentation resources for a project.\n\nThe renderer serializes each module into a JSON resource and produces\nsupporting metadata files such as `nav.json` and `index.json`.\n\nArgs:\n    project (Project):\n        Documentation project model to render.\n\n    out_dir (Path):\n        Directory where MCP resources will be written."
                      }
                    }
                  },
                  "MCPServer": {
                    "name": "MCPServer",
                    "kind": "class",
                    "path": "docforge.cli.commands.mcp_utils.MCPServer",
                    "signature": "MCPServer(mcp_root: Path, name: str)",
                    "docstring": "MCP server for serving a pre-generated documentation bundle.\n\nThe server exposes documentation resources and diagnostic tools through\nMCP endpoints backed by JSON files generated by the MCP renderer.\n\nAttributes:\n    mcp_root (Path):\n        Directory containing the generated MCP documentation bundle.\n\n    app (FastMCP):\n        Underlying FastMCP application instance that registers resources\n        and tools.",
                    "members": {
                      "mcp_root": {
                        "name": "mcp_root",
                        "kind": "attribute",
                        "path": "docforge.cli.commands.mcp_utils.MCPServer.mcp_root",
                        "signature": null,
                        "docstring": null
                      },
                      "app": {
                        "name": "app",
                        "kind": "attribute",
                        "path": "docforge.cli.commands.mcp_utils.MCPServer.app",
                        "signature": null,
                        "docstring": null
                      },
                      "run": {
                        "name": "run",
                        "kind": "function",
                        "path": "docforge.cli.commands.mcp_utils.MCPServer.run",
                        "signature": "run(transport: Literal['stdio', 'sse', 'streamable-http'] = 'streamable-http')",
                        "docstring": "Start the MCP server.\n\nArgs:\n    transport (Literal[\"stdio\", \"sse\", \"streamable-http\"]):\n        Transport mechanism used by the MCP server. Supported options\n        include `stdio`, `sse`, and `streamable-http`."
                      }
                    }
                  },
                  "generate_resources": {
                    "name": "generate_resources",
                    "kind": "function",
                    "path": "docforge.cli.commands.mcp_utils.generate_resources",
                    "signature": "generate_resources(module: str, project_name: str | None, out_dir: Path)",
                    "docstring": "Generate MCP documentation resources from a Python module.\n\nThe function performs project introspection, builds the internal\ndocumentation model, and renders MCP-compatible JSON resources\nto the specified output directory.\n\nArgs:\n    module (str):\n        Python module import path used as the entry point for\n        documentation generation.\n\n    project_name (str | None):\n        Optional override for the project name used in generated\n        documentation metadata.\n\n    out_dir (Path):\n        Directory where MCP resources (index.json, nav.json, and module data)\n        will be written."
                  },
                  "serve": {
                    "name": "serve",
                    "kind": "function",
                    "path": "docforge.cli.commands.mcp_utils.serve",
                    "signature": "serve(module: str, mcp_root: Path)",
                    "docstring": "Start an MCP server for a pre-generated documentation bundle.\n\nThe server exposes documentation resources such as project metadata,\nnavigation structure, and module documentation through MCP endpoints.\n\nArgs:\n    module (str):\n        Python module import path used to identify the served\n        documentation instance.\n\n    mcp_root (Path):\n        Path to the directory containing the MCP documentation\n        bundle (index.json, nav.json, and modules/).\n\nRaises:\n    click.ClickException:\n        If the MCP documentation bundle is missing required files or directories."
                  }
                }
              },
              "mkdocs_utils": {
                "name": "mkdocs_utils",
                "kind": "module",
                "path": "docforge.cli.commands.mkdocs_utils",
                "signature": null,
                "docstring": "# Summary\n\nUtilities for working with MkDocs in the doc-forge CLI.\n\n---\n\nNotes:\n    - A separate `mkdocs.{kind}.yml` configuration and build is emitted per\n      enabled kind (lib, api, wiki), each scoped to its own `docs_dir` and\n      written into its own `site_dir` (`site/lib`, `site/api`, `site/wiki`).\n    - Navigation blocks are re-rooted per kind: the wiki navigation drops its\n      leading `wiki/` scope and the resolved nav spec drops its `lib/` scope.\n\n---",
                "members": {
                  "GriffeLoader": {
                    "name": "GriffeLoader",
                    "kind": "class",
                    "path": "docforge.cli.commands.mkdocs_utils.GriffeLoader",
                    "signature": "GriffeLoader()",
                    "docstring": "Load Python modules using Griffe and convert them into doc-forge models.\n\nThis loader uses the Griffe introspection engine to analyze Python source\ncode and transform the extracted information into `Project`, `Module`,\nand `DocObject` instances used by doc-forge.\n\nAttributes:\n    _loader (_GriffeLoader):\n        Internal Griffe loader with dedicated module and line collections.",
                    "members": {
                      "load_project": {
                        "name": "load_project",
                        "kind": "function",
                        "path": "docforge.cli.commands.mkdocs_utils.GriffeLoader.load_project",
                        "signature": "load_project(module_paths: list[str], project_name: str | None = None, skip_import_errors: bool | None = None)",
                        "docstring": "Load multiple modules and assemble them into a Project model.\n\nEach module path is introspected and converted into a `Module`\ninstance. All modules are then aggregated into a single `Project`\nobject.\n\nArgs:\n    module_paths (list[str]):\n        List of dotted module import paths to load.\n\n    project_name (str | None):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool | None):\n        If True, modules that fail to load will be skipped instead of raising an error.\n\nReturns:\n    Project:\n        A populated `Project` instance containing the loaded modules.\n\nRaises:\n    ValueError:\n        If no module paths are provided.\n\n    ImportError:\n        If a module fails to load and `skip_import_errors` is False."
                      },
                      "load_module": {
                        "name": "load_module",
                        "kind": "function",
                        "path": "docforge.cli.commands.mkdocs_utils.GriffeLoader.load_module",
                        "signature": "load_module(path: str)",
                        "docstring": "Load and convert a single Python module.\n\nThe module is introspected using Griffe and then transformed into\na doc-forge `Module` model.\n\nArgs:\n    path (str):\n        Dotted import path of the module.\n\nReturns:\n    Module:\n        A populated `Module` instance.\n\nRaises:\n    ImportError:\n        If the module cannot be loaded by Griffe.\n\n    KeyError:\n        If the loaded module is missing from the module collection.\n\nExample:\n    Load a single module:\n\n        ```python\n        loader = GriffeLoader()\n        module = loader.load_module(\"mypackage.submodule\")\n        ```"
                      }
                    }
                  },
                  "discover_module_paths": {
                    "name": "discover_module_paths",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.discover_module_paths",
                    "signature": "discover_module_paths(module_name: str, project_root: Path | None = None)",
                    "docstring": "Discover Python modules within a package directory.\n\nThe function scans the filesystem for `.py` files inside the specified\npackage and converts them into dotted module import paths.\n\nDiscovery rules:\n\n- Directories containing `__init__.py` are treated as packages.\n- Each `.py` file is treated as a module.\n- Results are returned as dotted import paths.\n\nArgs:\n    module_name (str):\n        Top-level package name to discover modules from.\n\n    project_root (Path | None):\n        Root directory used to resolve module paths. If not provided, the\n        current working directory is used.\n\nReturns:\n    list[str]:\n        A sorted list of unique dotted module import paths.\n\nRaises:\n    FileNotFoundError:\n        If the specified package directory does not exist."
                  },
                  "MkDocsNavEmitter": {
                    "name": "MkDocsNavEmitter",
                    "kind": "class",
                    "path": "docforge.cli.commands.mkdocs_utils.MkDocsNavEmitter",
                    "signature": null,
                    "docstring": "Emit MkDocs navigation structures from resolved navigation data.\n\nThe emitter transforms a ``ResolvedNav`` object into the YAML-compatible\nlist structure expected by the MkDocs ``nav`` configuration field.",
                    "members": {
                      "emit": {
                        "name": "emit",
                        "kind": "function",
                        "path": "docforge.cli.commands.mkdocs_utils.MkDocsNavEmitter.emit",
                        "signature": "emit(nav: ResolvedNav)",
                        "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav (ResolvedNav):\n        Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\n    list[dict[str, Any]]:\n        A list of dictionaries representing the MkDocs navigation layout.\n        Each dictionary maps a navigation label to a page or a list of\n        pages."
                      }
                    }
                  },
                  "build_wiki_nav": {
                    "name": "build_wiki_nav",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.build_wiki_nav",
                    "signature": "build_wiki_nav(wiki_dir: Path)",
                    "docstring": "Derive an MkDocs navigation block from a wiki directory.\n\nReturned paths are relative to the parent of ``wiki_dir`` and carry the\nwiki directory name as their leading component (for example\n``wiki/01_overview.md`` when the wiki lives at ``docs/wiki``). This makes\nthe result directly usable in an MkDocs ``nav`` block with\n\n- ``index.md`` at the wiki root becomes the ``Home`` entry.\n- Page labels are derived from filenames: numeric order prefixes such as\n  ``01_`` or ``02-`` are stripped, separators are replaced with spaces, and\n  names are title-cased (``01_overview.md`` becomes ``Overview``).\n- Subdirectories become nested navigation groups. A nested ``index.md`` is\n  rendered as the section root placed first inside the group.\n- Only ``.md`` files are considered; hidden entries are ignored.\n\nArgs:\n    wiki_dir (Path):\n        Path to the hand-written wiki directory, for example ``docs/wiki``.\n\nReturns:\n    list[dict[str, Any]]:\n        Navigation entries compatible with the MkDocs ``nav`` configuration.\n        The list is empty if the wiki contains no Markdown files.\n\nRaises:\n    FileNotFoundError:\n        If the wiki directory does not exist."
                  },
                  "load_nav_spec": {
                    "name": "load_nav_spec",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.load_nav_spec",
                    "signature": "load_nav_spec(path: Path)",
                    "docstring": "Load a navigation specification file.\n\nThis helper function reads a YAML navigation file and constructs a\ncorresponding ``NavSpec`` instance.\n\nArgs:\n    path (Path):\n        Path to the navigation specification file.\n\nReturns:\n    NavSpec:\n        A ``NavSpec`` instance representing the parsed specification.\n\nRaises:\n    FileNotFoundError: If the specification file does not exist.\n    ValueError: If the YAML structure is invalid."
                  },
                  "resolve_nav": {
                    "name": "resolve_nav",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.resolve_nav",
                    "signature": "resolve_nav(spec: NavSpec, docs_root: Path)",
                    "docstring": "Resolve a navigation specification against the filesystem.\n\nThe function expands glob patterns defined in a ``NavSpec`` and verifies\nthat referenced documentation files exist within the documentation root.\n\nArgs:\n    spec (NavSpec):\n        Navigation specification describing documentation layout.\n    docs_root (Path):\n        Root directory containing documentation Markdown files.\n\nReturns:\n    ResolvedNav:\n        A `ResolvedNav` instance containing validated navigation paths.\n\nRaises:\n    FileNotFoundError: If the documentation root does not exist or a\n        navigation pattern does not match any files."
                  },
                  "MkDocsRenderer": {
                    "name": "MkDocsRenderer",
                    "kind": "class",
                    "path": "docforge.cli.commands.mkdocs_utils.MkDocsRenderer",
                    "signature": null,
                    "docstring": "Renderer that produces Markdown documentation for MkDocs.\n\nGenerated pages use mkdocstrings directives to reference Python modules,\nallowing MkDocs to render API documentation dynamically.",
                    "members": {
                      "name": {
                        "name": "name",
                        "kind": "attribute",
                        "path": "docforge.cli.commands.mkdocs_utils.MkDocsRenderer.name",
                        "signature": null,
                        "docstring": null
                      },
                      "generate_sources": {
                        "name": "generate_sources",
                        "kind": "function",
                        "path": "docforge.cli.commands.mkdocs_utils.MkDocsRenderer.generate_sources",
                        "signature": "generate_sources(project: Project, out_dir: Path, module_is_source: bool | None = None)",
                        "docstring": "Generate Markdown documentation files for a project.\n\nThis method renders a documentation structure from the provided\nproject model and writes the resulting Markdown files to the\nspecified output directory.\n\nArgs:\n    project (Project):\n        Project model containing modules to document.\n\n    out_dir (Path):\n        Directory where generated Markdown files will be written.\n\n    module_is_source (bool | None):\n        If True, treat the specified module as the documentation root\n        rather than nesting it inside a folder."
                      },
                      "generate_readme": {
                        "name": "generate_readme",
                        "kind": "function",
                        "path": "docforge.cli.commands.mkdocs_utils.MkDocsRenderer.generate_readme",
                        "signature": "generate_readme(project: Project, docs_dir: Path, module_is_source: bool | None = None, readme_dir: Path | None = None)",
                        "docstring": "Generate a `README.md` file from the root module docstring.\n\nNotes:\n    - If `module_is_source` is True, `README.md` is written to the\n      project root directory.\n    - If False, README generation is currently not implemented.\n\nArgs:\n    project (Project):\n        Project model containing documentation metadata.\n\n    docs_dir (Path):\n        Directory containing generated documentation sources.\n\n    module_is_source (bool | None):\n        Whether the module is treated as the project source root.\n\n    readme_dir (Path | None):\n        Directory where the generated README.md should be written.\n        Defaults to the parent of `docs_dir`."
                      }
                    }
                  },
                  "generate_sources": {
                    "name": "generate_sources",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.generate_sources",
                    "signature": "generate_sources(module: str, docs_dir: Path, project_name: str | None = None, module_is_source: bool | None = None, readme_dir: Path | None = None)",
                    "docstring": "Generate MkDocs Markdown sources for a Python module.\n\nThis function introspects the specified module, builds the internal\ndocumentation model, and renders Markdown documentation files for\nuse with MkDocs.\n\nArgs:\n    module (str):\n        Python module import path used as the entry point for\n        documentation generation.\n\n    docs_dir (Path):\n        Directory where the generated Markdown files will be written.\n\n    project_name (str | None):\n        Optional override for the project name used in documentation metadata.\n\n    module_is_source (bool | None):\n        If True, treat the specified module directory as the project root\n        rather than a nested module.\n\n    readme_dir (Path | None):\n        Directory where the generated README.md should be written. If not\n        provided, defaults to the parent of ``docs_dir``."
                  },
                  "build_lib_nav": {
                    "name": "build_lib_nav",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.build_lib_nav",
                    "signature": "build_lib_nav(nav_file: Path, docs_root: Path)",
                    "docstring": "Build the re-rooted navigation block for a lib site.\n\nThe navigation specification is resolved against the shared documentation\nroot and every resulting path is re-rooted relative to the ``lib``\nsubdirectory by stripping its leading ``lib/`` scope component.\n\nArgs:\n    nav_file (Path):\n        Path to the `docforge.nav.yml` navigation specification.\n\n    docs_root (Path):\n        Shared documentation root containing the ``lib`` sources.\n\nReturns:\n    tuple[list[dict[str, Any]], dict[str, str] | None]:\n        The re-rooted navigation block and the optional theme icon\n        mapping from the specification.\n\nRaises:\n    click.FileError:\n        If the navigation specification cannot be found."
                  },
                  "build_wiki_nav_block": {
                    "name": "build_wiki_nav_block",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.build_wiki_nav_block",
                    "signature": "build_wiki_nav_block(wiki_dir: Path)",
                    "docstring": "Build the re-rooted navigation block for a wiki site.\n\nThe wiki navigation derived from the wiki file structure is re-rooted\nrelative to the wiki directory itself by stripping the leading ``wiki/``\nscope component.\n\nArgs:\n    wiki_dir (Path):\n        Path to the hand-written wiki directory, for example ``docs/wiki``.\n\nReturns:\n    list[dict[str, Any]]:\n        Navigation entries relative to the wiki directory.\n\nRaises:\n    click.FileError:\n        If the wiki directory does not exist."
                  },
                  "load_spec_icon": {
                    "name": "load_spec_icon",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.load_spec_icon",
                    "signature": "load_spec_icon(nav_file: Path)",
                    "docstring": "Load the theme icon mapping from a navigation specification.\n\nArgs:\n    nav_file (Path):\n        Path to the navigation specification file.\n\nReturns:\n    dict[str, str] | None:\n        The icon mapping, or ``None`` when the specification file is\n        absent or cannot be parsed."
                  },
                  "generate_site_config": {
                    "name": "generate_site_config",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.generate_site_config",
                    "signature": "generate_site_config(kind: str, kind_root: Path, nav_block: list[dict[str, Any]], out: Path, site_name: str, docs_dir: str, site_dir: str, template: Path | None = None, site_description: str | None = None, site_author: str | None = None, theme_icon: dict[str, str] | None = None)",
                    "docstring": "Generate a per-kind `mkdocs.{kind}.yml` configuration file.\n\nThe configuration is created by merging the shared ``mkdocs.common.yml``\ntemplate with the fragment contributed by the kind (``lib``, ``api``, or\n``wiki``). Both ``docs_dir`` and ``site_dir`` are written relative to the\nconfiguration file's directory: the kind's sources when expressed as a\nsibling path (for example ``lib``) and the per-kind site output (for\nexample ``../site/lib``).\n\nArgs:\n    kind (str):\n        Documentation kind, one of ``lib``, ``api``, or ``wiki``.\n\n    kind_root (Path):\n        Directory scoped to the kind (for example ``docs/lib``) that\n        serves as the MkDocs ``docs_dir``.\n\n    nav_block (list[dict[str, Any]]):\n        Re-rooted navigation entries for the kind's site.\n\n    out (Path):\n        Destination path where the generated ``mkdocs.{kind}.yml`` file\n        is written.\n\n    site_name (str):\n        Display name for the generated documentation site.\n\n    docs_dir (str):\n        MkDocs ``docs_dir`` value, relative to the configuration\n        file's directory.\n\n    site_dir (str):\n        MkDocs ``site_dir`` value, relative to the configuration\n        file's directory.\n\n    template (Path | None):\n        Optional path to a fully custom MkDocs configuration template\n        that replaces the built-in templates entirely.\n\n    site_description (str | None):\n        Optional site description written into the configuration.\n\n    site_author (str | None):\n        Optional site author written into the configuration.\n\n    theme_icon (dict[str, str] | None):\n        Optional mapping of theme icon entries injected as\n        ``theme.icon``."
                  },
                  "build_configs": {
                    "name": "build_configs",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.build_configs",
                    "signature": "build_configs(yml_paths: Iterable[Path])",
                    "docstring": "Build the MkDocs documentation site for every given configuration.\n\nEach configuration file is loaded and built in turn, producing the\nper-kind static sites (``site/lib``, ``site/api``, ``site/wiki``).\n\nArgs:\n    yml_paths (Iterable[Path]):\n        Configuration files to build, in order.\n\nRaises:\n    click.ClickException:\n        If a configuration file does not exist."
                  },
                  "serve": {
                    "name": "serve",
                    "kind": "function",
                    "path": "docforge.cli.commands.mkdocs_utils.serve",
                    "signature": "serve(mkdocs_yml: Path)",
                    "docstring": "Start an MkDocs development server with live reload.\n\nThe server watches documentation files and automatically reloads\nthe site when changes are detected.\n\nArgs:\n    mkdocs_yml (Path):\n        Path to the `mkdocs.yml` configuration file.\n\nRaises:\n    click.ClickException:\n        If the configuration file does not exist."
                  }
                }
              },
              "GriffeLoader": {
                "name": "GriffeLoader",
                "kind": "class",
                "path": "docforge.cli.commands.GriffeLoader",
                "signature": "GriffeLoader()",
                "docstring": "Load Python modules using Griffe and convert them into doc-forge models.\n\nThis loader uses the Griffe introspection engine to analyze Python source\ncode and transform the extracted information into `Project`, `Module`,\nand `DocObject` instances used by doc-forge.\n\nAttributes:\n    _loader (_GriffeLoader):\n        Internal Griffe loader with dedicated module and line collections.",
                "members": {
                  "load_project": {
                    "name": "load_project",
                    "kind": "function",
                    "path": "docforge.cli.commands.GriffeLoader.load_project",
                    "signature": "load_project(module_paths: list[str], project_name: str | None = None, skip_import_errors: bool | None = None)",
                    "docstring": "Load multiple modules and assemble them into a Project model.\n\nEach module path is introspected and converted into a `Module`\ninstance. All modules are then aggregated into a single `Project`\nobject.\n\nArgs:\n    module_paths (list[str]):\n        List of dotted module import paths to load.\n\n    project_name (str | None):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool | None):\n        If True, modules that fail to load will be skipped instead of raising an error.\n\nReturns:\n    Project:\n        A populated `Project` instance containing the loaded modules.\n\nRaises:\n    ValueError:\n        If no module paths are provided.\n\n    ImportError:\n        If a module fails to load and `skip_import_errors` is False."
                  },
                  "load_module": {
                    "name": "load_module",
                    "kind": "function",
                    "path": "docforge.cli.commands.GriffeLoader.load_module",
                    "signature": "load_module(path: str)",
                    "docstring": "Load and convert a single Python module.\n\nThe module is introspected using Griffe and then transformed into\na doc-forge `Module` model.\n\nArgs:\n    path (str):\n        Dotted import path of the module.\n\nReturns:\n    Module:\n        A populated `Module` instance.\n\nRaises:\n    ImportError:\n        If the module cannot be loaded by Griffe.\n\n    KeyError:\n        If the loaded module is missing from the module collection.\n\nExample:\n    Load a single module:\n\n        ```python\n        loader = GriffeLoader()\n        module = loader.load_module(\"mypackage.submodule\")\n        ```"
                  }
                }
              },
              "DocObject": {
                "name": "DocObject",
                "kind": "class",
                "path": "docforge.cli.commands.DocObject",
                "signature": "DocObject(name: str, kind: str, path: str, signature: str | None = None, docstring: str | None = None)",
                "docstring": "Representation of a documented Python object.\n\nA `DocObject` models a single Python entity discovered during\nintrospection. Objects may contain nested members, allowing the structure\nof modules, classes, and other containers to be represented recursively.\n\nAttributes:\n    name (str):\n        Local name of the object.\n\n    kind (str):\n        Type of object (for example `class`, `function`, `method`, or `attribute`).\n\n    path (str):\n        Fully qualified dotted path to the object.\n\n    signature (str | None):\n        Callable signature if the object represents a callable.\n\n    docstring (str | None):\n        Raw docstring text extracted from the source code.\n\n    members (dict[str, DocObject]):\n        Mapping of member names to child `DocObject` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.cli.commands.DocObject.name",
                    "signature": null,
                    "docstring": null
                  },
                  "kind": {
                    "name": "kind",
                    "kind": "attribute",
                    "path": "docforge.cli.commands.DocObject.kind",
                    "signature": null,
                    "docstring": null
                  },
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.cli.commands.DocObject.path",
                    "signature": null,
                    "docstring": null
                  },
                  "signature": {
                    "name": "signature",
                    "kind": "attribute",
                    "path": "docforge.cli.commands.DocObject.signature",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.cli.commands.DocObject.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.cli.commands.DocObject.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_member": {
                    "name": "add_member",
                    "kind": "function",
                    "path": "docforge.cli.commands.DocObject.add_member",
                    "signature": "add_member(obj: DocObject)",
                    "docstring": "Add a child documentation object.\n\nThis is typically used when attaching methods to classes or\nnested objects to their parent containers.\n\nArgs:\n    obj (DocObject):\n        Documentation object to add as a member."
                  },
                  "get_member": {
                    "name": "get_member",
                    "kind": "function",
                    "path": "docforge.cli.commands.DocObject.get_member",
                    "signature": "get_member(name: str)",
                    "docstring": "Retrieve a member object by name.\n\nArgs:\n    name (str):\n        Name of the member to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If the member does not exist."
                  },
                  "get_all_members": {
                    "name": "get_all_members",
                    "kind": "function",
                    "path": "docforge.cli.commands.DocObject.get_all_members",
                    "signature": "get_all_members()",
                    "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
                  }
                }
              },
              "cli": {
                "name": "cli",
                "kind": "attribute",
                "path": "docforge.cli.commands.cli",
                "signature": null,
                "docstring": null
              },
              "build": {
                "name": "build",
                "kind": "function",
                "path": "docforge.cli.commands.build",
                "signature": "build(mcp: bool, mkdocs: bool, api: bool, wiki: bool, refresh: bool, module_is_source: bool, module: str | None, openapi_spec: Path | None, project_name: str | None, site_name: str | None, docs_dir: Path, wiki_dir: Path, nav_file: Path, template: Path | None, out_dir: Path) -> None",
                "docstring": "Build documentation artifacts.\n\nThis command runs the full documentation pipeline: it loads Python\nmodules, generates renderer-specific documentation sources, and\noptionally builds the final output.\n\nDepending on the selected options, the build can target:\n\n- A lib MkDocs site (`--mkdocs`) for library reference docs\n- A swagger-enabled API MkDocs site (`--api`) built from an OpenAPI spec\n- A wiki MkDocs site (`--wiki`) built from hand-written markdown\n- MCP structured documentation resources (`--mcp`)\n\nEach enabled site kind produces its own MkDocs configuration\n(`docs/mkdocs.{kind}.yml`) and its own build (`site/{kind}`).\n\nNotes:\n    - At least one of `--mcp`, `--mkdocs`, `--wiki`, or `--api` must be\n      provided.\n    - `--mkdocs`, `--api`, and `--wiki` emit independent MkDocs builds,\n      while `--mcp` emits a machine-readable bundle.\n    - Configuration files are generated only when absent; an existing\n      `docs/mkdocs.{kind}.yml` is used as-is. Pass `--refresh` to\n      rebaseline it from the templates.\n\nArgs:\n    mcp (bool):\n        Enable MCP documentation generation.\n\n    mkdocs (bool):\n        Enable the lib MkDocs documentation generation.\n\n    api (bool):\n        Enable API documentation generation from an OpenAPI spec.\n\n    wiki (bool):\n        Build a hand-written wiki directory as its own MkDocs site.\n\n    refresh (bool):\n        Regenerate ``docs/mkdocs.{kind}.yml`` from templates even when\n        it already exists. By default, existing configs are used as-is.\n\n    module_is_source (bool):\n        Treat the specified module directory as the project root.\n\n    module (str | None):\n        Python module import path to document.\n\n    openapi_spec (Path | None):\n        Path to the OpenAPI JSON specification used for API docs.\n\n    project_name (str | None):\n        Optional override for the project name.\n\n    site_name (str | None):\n        Display name for the lib and wiki MkDocs sites.\n\n    docs_dir (Path):\n        Shared documentation root used for generated sources.\n    wiki_dir (Path):\n        Directory containing hand-written wiki markdown files.\n\n    nav_file (Path):\n        Path to the navigation specification file.\n\n    template (Path | None):\n        Optional custom MkDocs configuration template.\n\n    out_dir (Path):\n        Output directory for generated MCP resources.\n\nRaises:\n    click.UsageError:\n        If required options are missing or conflicting."
              },
              "serve": {
                "name": "serve",
                "kind": "function",
                "path": "docforge.cli.commands.serve",
                "signature": "serve(mcp: bool, mkdocs: bool, lib: bool, api: bool, wiki: bool, module: str | None, mkdocs_yml: Path, out_dir: Path) -> None",
                "docstring": "Serve generated documentation locally.\n\nDepending on the selected mode, this command starts either:\n\n- A MkDocs development server for browsing a site, or\n- An MCP server exposing structured documentation resources\n\nThe kind flags (`--lib`, `--api`, `--wiki`) select the generated\nper-kind config (`docs/mkdocs.{kind}.yml`); `--mkdocs` serves the config\npassed via `--mkdocs-yml`.\n\nArgs:\n    mcp (bool):\n        Serve documentation using the MCP server.\n\n    mkdocs (bool):\n        Serve the MkDocs development site from ``--mkdocs-yml``.\n\n    lib (bool):\n        Serve the lib MkDocs site.\n\n    api (bool):\n        Serve the API MkDocs site.\n\n    wiki (bool):\n        Serve the wiki MkDocs site.\n\n    module (str | None):\n        Python module import path to serve via MCP.\n\n    mkdocs_yml (Path):\n        Path to the MkDocs configuration file.\n\n    out_dir (Path):\n        Root directory containing MCP documentation resources.\n\nRaises:\n    click.UsageError:\n        If invalid or conflicting options are provided."
              },
              "tree": {
                "name": "tree",
                "kind": "function",
                "path": "docforge.cli.commands.tree",
                "signature": "tree(module: str, project_name: str | None) -> None",
                "docstring": "Display the documentation object tree for a module.\n\nThis command introspects the specified module and prints a\nhierarchical representation of the discovered documentation\nobjects, including modules, classes, functions, and members.\n\nArgs:\n    module (str):\n        Python module import path to introspect.\n\n    project_name (str | None):\n        Optional name to display as the project root."
              }
            }
          },
          "mcp_utils": {
            "name": "mcp_utils",
            "kind": "module",
            "path": "docforge.cli.mcp_utils",
            "signature": null,
            "docstring": "# Summary\n\nUtilities for working with MCP in the doc-forge CLI.\n\n---\n\nNotes:\n    - `generate_resources` produces the bundle consumed by `MCPServer`:\n      `index.json`, `nav.json`, and per-module resources under `modules/`.\n    - Resource URIs use the `docs://` scheme: `docs://index`, `docs://nav`,\n      and `docs://modules/{module}`.\n\n---",
            "members": {
              "GriffeLoader": {
                "name": "GriffeLoader",
                "kind": "class",
                "path": "docforge.cli.mcp_utils.GriffeLoader",
                "signature": "GriffeLoader()",
                "docstring": "Load Python modules using Griffe and convert them into doc-forge models.\n\nThis loader uses the Griffe introspection engine to analyze Python source\ncode and transform the extracted information into `Project`, `Module`,\nand `DocObject` instances used by doc-forge.\n\nAttributes:\n    _loader (_GriffeLoader):\n        Internal Griffe loader with dedicated module and line collections.",
                "members": {
                  "load_project": {
                    "name": "load_project",
                    "kind": "function",
                    "path": "docforge.cli.mcp_utils.GriffeLoader.load_project",
                    "signature": "load_project(module_paths: list[str], project_name: str | None = None, skip_import_errors: bool | None = None)",
                    "docstring": "Load multiple modules and assemble them into a Project model.\n\nEach module path is introspected and converted into a `Module`\ninstance. All modules are then aggregated into a single `Project`\nobject.\n\nArgs:\n    module_paths (list[str]):\n        List of dotted module import paths to load.\n\n    project_name (str | None):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool | None):\n        If True, modules that fail to load will be skipped instead of raising an error.\n\nReturns:\n    Project:\n        A populated `Project` instance containing the loaded modules.\n\nRaises:\n    ValueError:\n        If no module paths are provided.\n\n    ImportError:\n        If a module fails to load and `skip_import_errors` is False."
                  },
                  "load_module": {
                    "name": "load_module",
                    "kind": "function",
                    "path": "docforge.cli.mcp_utils.GriffeLoader.load_module",
                    "signature": "load_module(path: str)",
                    "docstring": "Load and convert a single Python module.\n\nThe module is introspected using Griffe and then transformed into\na doc-forge `Module` model.\n\nArgs:\n    path (str):\n        Dotted import path of the module.\n\nReturns:\n    Module:\n        A populated `Module` instance.\n\nRaises:\n    ImportError:\n        If the module cannot be loaded by Griffe.\n\n    KeyError:\n        If the loaded module is missing from the module collection.\n\nExample:\n    Load a single module:\n\n        ```python\n        loader = GriffeLoader()\n        module = loader.load_module(\"mypackage.submodule\")\n        ```"
                  }
                }
              },
              "discover_module_paths": {
                "name": "discover_module_paths",
                "kind": "function",
                "path": "docforge.cli.mcp_utils.discover_module_paths",
                "signature": "discover_module_paths(module_name: str, project_root: Path | None = None)",
                "docstring": "Discover Python modules within a package directory.\n\nThe function scans the filesystem for `.py` files inside the specified\npackage and converts them into dotted module import paths.\n\nDiscovery rules:\n\n- Directories containing `__init__.py` are treated as packages.\n- Each `.py` file is treated as a module.\n- Results are returned as dotted import paths.\n\nArgs:\n    module_name (str):\n        Top-level package name to discover modules from.\n\n    project_root (Path | None):\n        Root directory used to resolve module paths. If not provided, the\n        current working directory is used.\n\nReturns:\n    list[str]:\n        A sorted list of unique dotted module import paths.\n\nRaises:\n    FileNotFoundError:\n        If the specified package directory does not exist."
              },
              "MCPRenderer": {
                "name": "MCPRenderer",
                "kind": "class",
                "path": "docforge.cli.mcp_utils.MCPRenderer",
                "signature": null,
                "docstring": "Renderer that generates MCP-compatible documentation resources.\n\nThis renderer converts doc-forge project models into structured JSON\nresources suitable for consumption by systems implementing the Model\nContext Protocol (MCP).",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.cli.mcp_utils.MCPRenderer.name",
                    "signature": null,
                    "docstring": null
                  },
                  "generate_sources": {
                    "name": "generate_sources",
                    "kind": "function",
                    "path": "docforge.cli.mcp_utils.MCPRenderer.generate_sources",
                    "signature": "generate_sources(project: Project, out_dir: Path)",
                    "docstring": "Generate MCP documentation resources for a project.\n\nThe renderer serializes each module into a JSON resource and produces\nsupporting metadata files such as `nav.json` and `index.json`.\n\nArgs:\n    project (Project):\n        Documentation project model to render.\n\n    out_dir (Path):\n        Directory where MCP resources will be written."
                  }
                }
              },
              "MCPServer": {
                "name": "MCPServer",
                "kind": "class",
                "path": "docforge.cli.mcp_utils.MCPServer",
                "signature": "MCPServer(mcp_root: Path, name: str)",
                "docstring": "MCP server for serving a pre-generated documentation bundle.\n\nThe server exposes documentation resources and diagnostic tools through\nMCP endpoints backed by JSON files generated by the MCP renderer.\n\nAttributes:\n    mcp_root (Path):\n        Directory containing the generated MCP documentation bundle.\n\n    app (FastMCP):\n        Underlying FastMCP application instance that registers resources\n        and tools.",
                "members": {
                  "mcp_root": {
                    "name": "mcp_root",
                    "kind": "attribute",
                    "path": "docforge.cli.mcp_utils.MCPServer.mcp_root",
                    "signature": null,
                    "docstring": null
                  },
                  "app": {
                    "name": "app",
                    "kind": "attribute",
                    "path": "docforge.cli.mcp_utils.MCPServer.app",
                    "signature": null,
                    "docstring": null
                  },
                  "run": {
                    "name": "run",
                    "kind": "function",
                    "path": "docforge.cli.mcp_utils.MCPServer.run",
                    "signature": "run(transport: Literal['stdio', 'sse', 'streamable-http'] = 'streamable-http')",
                    "docstring": "Start the MCP server.\n\nArgs:\n    transport (Literal[\"stdio\", \"sse\", \"streamable-http\"]):\n        Transport mechanism used by the MCP server. Supported options\n        include `stdio`, `sse`, and `streamable-http`."
                  }
                }
              },
              "generate_resources": {
                "name": "generate_resources",
                "kind": "function",
                "path": "docforge.cli.mcp_utils.generate_resources",
                "signature": "generate_resources(module: str, project_name: str | None, out_dir: Path) -> None",
                "docstring": "Generate MCP documentation resources from a Python module.\n\nThe function performs project introspection, builds the internal\ndocumentation model, and renders MCP-compatible JSON resources\nto the specified output directory.\n\nArgs:\n    module (str):\n        Python module import path used as the entry point for\n        documentation generation.\n\n    project_name (str | None):\n        Optional override for the project name used in generated\n        documentation metadata.\n\n    out_dir (Path):\n        Directory where MCP resources (index.json, nav.json, and module data)\n        will be written."
              },
              "serve": {
                "name": "serve",
                "kind": "function",
                "path": "docforge.cli.mcp_utils.serve",
                "signature": "serve(module: str, mcp_root: Path) -> None",
                "docstring": "Start an MCP server for a pre-generated documentation bundle.\n\nThe server exposes documentation resources such as project metadata,\nnavigation structure, and module documentation through MCP endpoints.\n\nArgs:\n    module (str):\n        Python module import path used to identify the served\n        documentation instance.\n\n    mcp_root (Path):\n        Path to the directory containing the MCP documentation\n        bundle (index.json, nav.json, and modules/).\n\nRaises:\n    click.ClickException:\n        If the MCP documentation bundle is missing required files or directories."
              }
            }
          },
          "mkdocs_utils": {
            "name": "mkdocs_utils",
            "kind": "module",
            "path": "docforge.cli.mkdocs_utils",
            "signature": null,
            "docstring": "# Summary\n\nUtilities for working with MkDocs in the doc-forge CLI.\n\n---\n\nNotes:\n    - A separate `mkdocs.{kind}.yml` configuration and build is emitted per\n      enabled kind (lib, api, wiki), each scoped to its own `docs_dir` and\n      written into its own `site_dir` (`site/lib`, `site/api`, `site/wiki`).\n    - Navigation blocks are re-rooted per kind: the wiki navigation drops its\n      leading `wiki/` scope and the resolved nav spec drops its `lib/` scope.\n\n---",
            "members": {
              "GriffeLoader": {
                "name": "GriffeLoader",
                "kind": "class",
                "path": "docforge.cli.mkdocs_utils.GriffeLoader",
                "signature": "GriffeLoader()",
                "docstring": "Load Python modules using Griffe and convert them into doc-forge models.\n\nThis loader uses the Griffe introspection engine to analyze Python source\ncode and transform the extracted information into `Project`, `Module`,\nand `DocObject` instances used by doc-forge.\n\nAttributes:\n    _loader (_GriffeLoader):\n        Internal Griffe loader with dedicated module and line collections.",
                "members": {
                  "load_project": {
                    "name": "load_project",
                    "kind": "function",
                    "path": "docforge.cli.mkdocs_utils.GriffeLoader.load_project",
                    "signature": "load_project(module_paths: list[str], project_name: str | None = None, skip_import_errors: bool | None = None)",
                    "docstring": "Load multiple modules and assemble them into a Project model.\n\nEach module path is introspected and converted into a `Module`\ninstance. All modules are then aggregated into a single `Project`\nobject.\n\nArgs:\n    module_paths (list[str]):\n        List of dotted module import paths to load.\n\n    project_name (str | None):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool | None):\n        If True, modules that fail to load will be skipped instead of raising an error.\n\nReturns:\n    Project:\n        A populated `Project` instance containing the loaded modules.\n\nRaises:\n    ValueError:\n        If no module paths are provided.\n\n    ImportError:\n        If a module fails to load and `skip_import_errors` is False."
                  },
                  "load_module": {
                    "name": "load_module",
                    "kind": "function",
                    "path": "docforge.cli.mkdocs_utils.GriffeLoader.load_module",
                    "signature": "load_module(path: str)",
                    "docstring": "Load and convert a single Python module.\n\nThe module is introspected using Griffe and then transformed into\na doc-forge `Module` model.\n\nArgs:\n    path (str):\n        Dotted import path of the module.\n\nReturns:\n    Module:\n        A populated `Module` instance.\n\nRaises:\n    ImportError:\n        If the module cannot be loaded by Griffe.\n\n    KeyError:\n        If the loaded module is missing from the module collection.\n\nExample:\n    Load a single module:\n\n        ```python\n        loader = GriffeLoader()\n        module = loader.load_module(\"mypackage.submodule\")\n        ```"
                  }
                }
              },
              "discover_module_paths": {
                "name": "discover_module_paths",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.discover_module_paths",
                "signature": "discover_module_paths(module_name: str, project_root: Path | None = None)",
                "docstring": "Discover Python modules within a package directory.\n\nThe function scans the filesystem for `.py` files inside the specified\npackage and converts them into dotted module import paths.\n\nDiscovery rules:\n\n- Directories containing `__init__.py` are treated as packages.\n- Each `.py` file is treated as a module.\n- Results are returned as dotted import paths.\n\nArgs:\n    module_name (str):\n        Top-level package name to discover modules from.\n\n    project_root (Path | None):\n        Root directory used to resolve module paths. If not provided, the\n        current working directory is used.\n\nReturns:\n    list[str]:\n        A sorted list of unique dotted module import paths.\n\nRaises:\n    FileNotFoundError:\n        If the specified package directory does not exist."
              },
              "MkDocsNavEmitter": {
                "name": "MkDocsNavEmitter",
                "kind": "class",
                "path": "docforge.cli.mkdocs_utils.MkDocsNavEmitter",
                "signature": null,
                "docstring": "Emit MkDocs navigation structures from resolved navigation data.\n\nThe emitter transforms a ``ResolvedNav`` object into the YAML-compatible\nlist structure expected by the MkDocs ``nav`` configuration field.",
                "members": {
                  "emit": {
                    "name": "emit",
                    "kind": "function",
                    "path": "docforge.cli.mkdocs_utils.MkDocsNavEmitter.emit",
                    "signature": "emit(nav: ResolvedNav)",
                    "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav (ResolvedNav):\n        Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\n    list[dict[str, Any]]:\n        A list of dictionaries representing the MkDocs navigation layout.\n        Each dictionary maps a navigation label to a page or a list of\n        pages."
                  }
                }
              },
              "build_wiki_nav": {
                "name": "build_wiki_nav",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.build_wiki_nav",
                "signature": "build_wiki_nav(wiki_dir: Path)",
                "docstring": "Derive an MkDocs navigation block from a wiki directory.\n\nReturned paths are relative to the parent of ``wiki_dir`` and carry the\nwiki directory name as their leading component (for example\n``wiki/01_overview.md`` when the wiki lives at ``docs/wiki``). This makes\nthe result directly usable in an MkDocs ``nav`` block with\n\n- ``index.md`` at the wiki root becomes the ``Home`` entry.\n- Page labels are derived from filenames: numeric order prefixes such as\n  ``01_`` or ``02-`` are stripped, separators are replaced with spaces, and\n  names are title-cased (``01_overview.md`` becomes ``Overview``).\n- Subdirectories become nested navigation groups. A nested ``index.md`` is\n  rendered as the section root placed first inside the group.\n- Only ``.md`` files are considered; hidden entries are ignored.\n\nArgs:\n    wiki_dir (Path):\n        Path to the hand-written wiki directory, for example ``docs/wiki``.\n\nReturns:\n    list[dict[str, Any]]:\n        Navigation entries compatible with the MkDocs ``nav`` configuration.\n        The list is empty if the wiki contains no Markdown files.\n\nRaises:\n    FileNotFoundError:\n        If the wiki directory does not exist."
              },
              "load_nav_spec": {
                "name": "load_nav_spec",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.load_nav_spec",
                "signature": "load_nav_spec(path: Path)",
                "docstring": "Load a navigation specification file.\n\nThis helper function reads a YAML navigation file and constructs a\ncorresponding ``NavSpec`` instance.\n\nArgs:\n    path (Path):\n        Path to the navigation specification file.\n\nReturns:\n    NavSpec:\n        A ``NavSpec`` instance representing the parsed specification.\n\nRaises:\n    FileNotFoundError: If the specification file does not exist.\n    ValueError: If the YAML structure is invalid."
              },
              "resolve_nav": {
                "name": "resolve_nav",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.resolve_nav",
                "signature": "resolve_nav(spec: NavSpec, docs_root: Path)",
                "docstring": "Resolve a navigation specification against the filesystem.\n\nThe function expands glob patterns defined in a ``NavSpec`` and verifies\nthat referenced documentation files exist within the documentation root.\n\nArgs:\n    spec (NavSpec):\n        Navigation specification describing documentation layout.\n    docs_root (Path):\n        Root directory containing documentation Markdown files.\n\nReturns:\n    ResolvedNav:\n        A `ResolvedNav` instance containing validated navigation paths.\n\nRaises:\n    FileNotFoundError: If the documentation root does not exist or a\n        navigation pattern does not match any files."
              },
              "MkDocsRenderer": {
                "name": "MkDocsRenderer",
                "kind": "class",
                "path": "docforge.cli.mkdocs_utils.MkDocsRenderer",
                "signature": null,
                "docstring": "Renderer that produces Markdown documentation for MkDocs.\n\nGenerated pages use mkdocstrings directives to reference Python modules,\nallowing MkDocs to render API documentation dynamically.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.cli.mkdocs_utils.MkDocsRenderer.name",
                    "signature": null,
                    "docstring": null
                  },
                  "generate_sources": {
                    "name": "generate_sources",
                    "kind": "function",
                    "path": "docforge.cli.mkdocs_utils.MkDocsRenderer.generate_sources",
                    "signature": "generate_sources(project: Project, out_dir: Path, module_is_source: bool | None = None)",
                    "docstring": "Generate Markdown documentation files for a project.\n\nThis method renders a documentation structure from the provided\nproject model and writes the resulting Markdown files to the\nspecified output directory.\n\nArgs:\n    project (Project):\n        Project model containing modules to document.\n\n    out_dir (Path):\n        Directory where generated Markdown files will be written.\n\n    module_is_source (bool | None):\n        If True, treat the specified module as the documentation root\n        rather than nesting it inside a folder."
                  },
                  "generate_readme": {
                    "name": "generate_readme",
                    "kind": "function",
                    "path": "docforge.cli.mkdocs_utils.MkDocsRenderer.generate_readme",
                    "signature": "generate_readme(project: Project, docs_dir: Path, module_is_source: bool | None = None, readme_dir: Path | None = None)",
                    "docstring": "Generate a `README.md` file from the root module docstring.\n\nNotes:\n    - If `module_is_source` is True, `README.md` is written to the\n      project root directory.\n    - If False, README generation is currently not implemented.\n\nArgs:\n    project (Project):\n        Project model containing documentation metadata.\n\n    docs_dir (Path):\n        Directory containing generated documentation sources.\n\n    module_is_source (bool | None):\n        Whether the module is treated as the project source root.\n\n    readme_dir (Path | None):\n        Directory where the generated README.md should be written.\n        Defaults to the parent of `docs_dir`."
                  }
                }
              },
              "generate_sources": {
                "name": "generate_sources",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.generate_sources",
                "signature": "generate_sources(module: str, docs_dir: Path, project_name: str | None = None, module_is_source: bool | None = None, readme_dir: Path | None = None) -> None",
                "docstring": "Generate MkDocs Markdown sources for a Python module.\n\nThis function introspects the specified module, builds the internal\ndocumentation model, and renders Markdown documentation files for\nuse with MkDocs.\n\nArgs:\n    module (str):\n        Python module import path used as the entry point for\n        documentation generation.\n\n    docs_dir (Path):\n        Directory where the generated Markdown files will be written.\n\n    project_name (str | None):\n        Optional override for the project name used in documentation metadata.\n\n    module_is_source (bool | None):\n        If True, treat the specified module directory as the project root\n        rather than a nested module.\n\n    readme_dir (Path | None):\n        Directory where the generated README.md should be written. If not\n        provided, defaults to the parent of ``docs_dir``."
              },
              "build_lib_nav": {
                "name": "build_lib_nav",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.build_lib_nav",
                "signature": "build_lib_nav(nav_file: Path, docs_root: Path) -> tuple[list[dict[str, Any]], dict[str, str] | None]",
                "docstring": "Build the re-rooted navigation block for a lib site.\n\nThe navigation specification is resolved against the shared documentation\nroot and every resulting path is re-rooted relative to the ``lib``\nsubdirectory by stripping its leading ``lib/`` scope component.\n\nArgs:\n    nav_file (Path):\n        Path to the `docforge.nav.yml` navigation specification.\n\n    docs_root (Path):\n        Shared documentation root containing the ``lib`` sources.\n\nReturns:\n    tuple[list[dict[str, Any]], dict[str, str] | None]:\n        The re-rooted navigation block and the optional theme icon\n        mapping from the specification.\n\nRaises:\n    click.FileError:\n        If the navigation specification cannot be found."
              },
              "build_wiki_nav_block": {
                "name": "build_wiki_nav_block",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.build_wiki_nav_block",
                "signature": "build_wiki_nav_block(wiki_dir: Path) -> list[dict[str, Any]]",
                "docstring": "Build the re-rooted navigation block for a wiki site.\n\nThe wiki navigation derived from the wiki file structure is re-rooted\nrelative to the wiki directory itself by stripping the leading ``wiki/``\nscope component.\n\nArgs:\n    wiki_dir (Path):\n        Path to the hand-written wiki directory, for example ``docs/wiki``.\n\nReturns:\n    list[dict[str, Any]]:\n        Navigation entries relative to the wiki directory.\n\nRaises:\n    click.FileError:\n        If the wiki directory does not exist."
              },
              "load_spec_icon": {
                "name": "load_spec_icon",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.load_spec_icon",
                "signature": "load_spec_icon(nav_file: Path) -> dict[str, str] | None",
                "docstring": "Load the theme icon mapping from a navigation specification.\n\nArgs:\n    nav_file (Path):\n        Path to the navigation specification file.\n\nReturns:\n    dict[str, str] | None:\n        The icon mapping, or ``None`` when the specification file is\n        absent or cannot be parsed."
              },
              "generate_site_config": {
                "name": "generate_site_config",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.generate_site_config",
                "signature": "generate_site_config(kind: str, kind_root: Path, nav_block: list[dict[str, Any]], out: Path, site_name: str, docs_dir: str, site_dir: str, template: Path | None = None, site_description: str | None = None, site_author: str | None = None, theme_icon: dict[str, str] | None = None) -> None",
                "docstring": "Generate a per-kind `mkdocs.{kind}.yml` configuration file.\n\nThe configuration is created by merging the shared ``mkdocs.common.yml``\ntemplate with the fragment contributed by the kind (``lib``, ``api``, or\n``wiki``). Both ``docs_dir`` and ``site_dir`` are written relative to the\nconfiguration file's directory: the kind's sources when expressed as a\nsibling path (for example ``lib``) and the per-kind site output (for\nexample ``../site/lib``).\n\nArgs:\n    kind (str):\n        Documentation kind, one of ``lib``, ``api``, or ``wiki``.\n\n    kind_root (Path):\n        Directory scoped to the kind (for example ``docs/lib``) that\n        serves as the MkDocs ``docs_dir``.\n\n    nav_block (list[dict[str, Any]]):\n        Re-rooted navigation entries for the kind's site.\n\n    out (Path):\n        Destination path where the generated ``mkdocs.{kind}.yml`` file\n        is written.\n\n    site_name (str):\n        Display name for the generated documentation site.\n\n    docs_dir (str):\n        MkDocs ``docs_dir`` value, relative to the configuration\n        file's directory.\n\n    site_dir (str):\n        MkDocs ``site_dir`` value, relative to the configuration\n        file's directory.\n\n    template (Path | None):\n        Optional path to a fully custom MkDocs configuration template\n        that replaces the built-in templates entirely.\n\n    site_description (str | None):\n        Optional site description written into the configuration.\n\n    site_author (str | None):\n        Optional site author written into the configuration.\n\n    theme_icon (dict[str, str] | None):\n        Optional mapping of theme icon entries injected as\n        ``theme.icon``."
              },
              "build_configs": {
                "name": "build_configs",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.build_configs",
                "signature": "build_configs(yml_paths: Iterable[Path]) -> None",
                "docstring": "Build the MkDocs documentation site for every given configuration.\n\nEach configuration file is loaded and built in turn, producing the\nper-kind static sites (``site/lib``, ``site/api``, ``site/wiki``).\n\nArgs:\n    yml_paths (Iterable[Path]):\n        Configuration files to build, in order.\n\nRaises:\n    click.ClickException:\n        If a configuration file does not exist."
              },
              "serve": {
                "name": "serve",
                "kind": "function",
                "path": "docforge.cli.mkdocs_utils.serve",
                "signature": "serve(mkdocs_yml: Path) -> None",
                "docstring": "Start an MkDocs development server with live reload.\n\nThe server watches documentation files and automatically reloads\nthe site when changes are detected.\n\nArgs:\n    mkdocs_yml (Path):\n        Path to the `mkdocs.yml` configuration file.\n\nRaises:\n    click.ClickException:\n        If the configuration file does not exist."
              }
            }
          }
        }
      },
      "loaders": {
        "name": "loaders",
        "kind": "module",
        "path": "docforge.loaders",
        "signature": null,
        "docstring": "# Summary\n\nLoader layer for doc-forge.\n\nThe `docforge.loaders` package is responsible for discovering Python modules\nand extracting documentation data using static analysis.\n\n---\n\n# Overview\n\nThis layer converts Python source code into an intermediate documentation\nmodel used by doc-forge. It performs module discovery, introspection, and\ninitial filtering before the data is passed to the core documentation models.\n\nCore capabilities include:\n\n- **Module discovery** – Locate Python modules and packages within a project.\n- **Static introspection** – Parse docstrings, signatures, and object\n  hierarchies using the `griffe` library without executing the code.\n- **Public API filtering** – Exclude private members (names prefixed with\n  `_`) to produce clean public documentation structures.\n\n---",
        "members": {
          "GriffeLoader": {
            "name": "GriffeLoader",
            "kind": "class",
            "path": "docforge.loaders.GriffeLoader",
            "signature": "GriffeLoader()",
            "docstring": "Load Python modules using Griffe and convert them into doc-forge models.\n\nThis loader uses the Griffe introspection engine to analyze Python source\ncode and transform the extracted information into `Project`, `Module`,\nand `DocObject` instances used by doc-forge.\n\nAttributes:\n    _loader (_GriffeLoader):\n        Internal Griffe loader with dedicated module and line collections.",
            "members": {
              "load_project": {
                "name": "load_project",
                "kind": "function",
                "path": "docforge.loaders.GriffeLoader.load_project",
                "signature": "load_project(module_paths: list[str], project_name: str | None = None, skip_import_errors: bool | None = None)",
                "docstring": "Load multiple modules and assemble them into a Project model.\n\nEach module path is introspected and converted into a `Module`\ninstance. All modules are then aggregated into a single `Project`\nobject.\n\nArgs:\n    module_paths (list[str]):\n        List of dotted module import paths to load.\n\n    project_name (str | None):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool | None):\n        If True, modules that fail to load will be skipped instead of raising an error.\n\nReturns:\n    Project:\n        A populated `Project` instance containing the loaded modules.\n\nRaises:\n    ValueError:\n        If no module paths are provided.\n\n    ImportError:\n        If a module fails to load and `skip_import_errors` is False."
              },
              "load_module": {
                "name": "load_module",
                "kind": "function",
                "path": "docforge.loaders.GriffeLoader.load_module",
                "signature": "load_module(path: str)",
                "docstring": "Load and convert a single Python module.\n\nThe module is introspected using Griffe and then transformed into\na doc-forge `Module` model.\n\nArgs:\n    path (str):\n        Dotted import path of the module.\n\nReturns:\n    Module:\n        A populated `Module` instance.\n\nRaises:\n    ImportError:\n        If the module cannot be loaded by Griffe.\n\n    KeyError:\n        If the loaded module is missing from the module collection.\n\nExample:\n    Load a single module:\n\n        ```python\n        loader = GriffeLoader()\n        module = loader.load_module(\"mypackage.submodule\")\n        ```"
              }
            }
          },
          "discover_module_paths": {
            "name": "discover_module_paths",
            "kind": "function",
            "path": "docforge.loaders.discover_module_paths",
            "signature": "discover_module_paths(module_name: str, project_root: Path | None = None)",
            "docstring": "Discover Python modules within a package directory.\n\nThe function scans the filesystem for `.py` files inside the specified\npackage and converts them into dotted module import paths.\n\nDiscovery rules:\n\n- Directories containing `__init__.py` are treated as packages.\n- Each `.py` file is treated as a module.\n- Results are returned as dotted import paths.\n\nArgs:\n    module_name (str):\n        Top-level package name to discover modules from.\n\n    project_root (Path | None):\n        Root directory used to resolve module paths. If not provided, the\n        current working directory is used.\n\nReturns:\n    list[str]:\n        A sorted list of unique dotted module import paths.\n\nRaises:\n    FileNotFoundError:\n        If the specified package directory does not exist."
          },
          "griffe_loader": {
            "name": "griffe_loader",
            "kind": "module",
            "path": "docforge.loaders.griffe_loader",
            "signature": null,
            "docstring": "# Summary\n\nUtilities for loading and introspecting Python modules using Griffe.\n\nThis module provides the `GriffeLoader` class and helper utilities used to\ndiscover Python modules, introspect their structure, and convert the results\ninto doc-forge documentation models.\n\n---\n\nNotes:\n    - All analysis is static; analyzed modules are never executed.\n    - Private members (names starting with `_`) are skipped during conversion.\n    - Imported aliases that cannot be resolved (stdlib/third-party names) are\n      skipped; aliases that resolve within the documented project are kept.\n\n---",
            "members": {
              "DocObject": {
                "name": "DocObject",
                "kind": "class",
                "path": "docforge.loaders.griffe_loader.DocObject",
                "signature": "DocObject(name: str, kind: str, path: str, signature: str | None = None, docstring: str | None = None)",
                "docstring": "Representation of a documented Python object.\n\nA `DocObject` models a single Python entity discovered during\nintrospection. Objects may contain nested members, allowing the structure\nof modules, classes, and other containers to be represented recursively.\n\nAttributes:\n    name (str):\n        Local name of the object.\n\n    kind (str):\n        Type of object (for example `class`, `function`, `method`, or `attribute`).\n\n    path (str):\n        Fully qualified dotted path to the object.\n\n    signature (str | None):\n        Callable signature if the object represents a callable.\n\n    docstring (str | None):\n        Raw docstring text extracted from the source code.\n\n    members (dict[str, DocObject]):\n        Mapping of member names to child `DocObject` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.DocObject.name",
                    "signature": null,
                    "docstring": null
                  },
                  "kind": {
                    "name": "kind",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.DocObject.kind",
                    "signature": null,
                    "docstring": null
                  },
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.DocObject.path",
                    "signature": null,
                    "docstring": null
                  },
                  "signature": {
                    "name": "signature",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.DocObject.signature",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.DocObject.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.DocObject.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_member": {
                    "name": "add_member",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.DocObject.add_member",
                    "signature": "add_member(obj: DocObject)",
                    "docstring": "Add a child documentation object.\n\nThis is typically used when attaching methods to classes or\nnested objects to their parent containers.\n\nArgs:\n    obj (DocObject):\n        Documentation object to add as a member."
                  },
                  "get_member": {
                    "name": "get_member",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.DocObject.get_member",
                    "signature": "get_member(name: str)",
                    "docstring": "Retrieve a member object by name.\n\nArgs:\n    name (str):\n        Name of the member to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If the member does not exist."
                  },
                  "get_all_members": {
                    "name": "get_all_members",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.DocObject.get_all_members",
                    "signature": "get_all_members()",
                    "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
                  }
                }
              },
              "Module": {
                "name": "Module",
                "kind": "class",
                "path": "docforge.loaders.griffe_loader.Module",
                "signature": "Module(path: str, docstring: str | None = None)",
                "docstring": "Representation of a documented Python module or package.\n\nA `Module` stores metadata about the module itself and maintains a\ncollection of top-level documentation objects discovered during\nintrospection.\n\nAttributes:\n    path (str):\n        Dotted import path of the module.\n\n    docstring (str | None):\n        Module-level documentation string, if present.\n\n    members (dict[str, DocObject]):\n        Mapping of object names to their corresponding `DocObject` representations.",
                "members": {
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.Module.path",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.Module.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.Module.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_object": {
                    "name": "add_object",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.Module.add_object",
                    "signature": "add_object(obj: DocObject)",
                    "docstring": "Add a documented object to the module.\n\nArgs:\n    obj (DocObject):\n        Documentation object to register as a top-level member of the module."
                  },
                  "get_object": {
                    "name": "get_object",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.Module.get_object",
                    "signature": "get_object(name: str)",
                    "docstring": "Retrieve a documented object by name.\n\nArgs:\n    name (str):\n        Name of the object to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If no object with the given name exists."
                  },
                  "get_all_objects": {
                    "name": "get_all_objects",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.Module.get_all_objects",
                    "signature": "get_all_objects()",
                    "docstring": "Return all top-level documentation objects in the module.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing the module's public members."
                  }
                }
              },
              "Project": {
                "name": "Project",
                "kind": "class",
                "path": "docforge.loaders.griffe_loader.Project",
                "signature": "Project(name: str)",
                "docstring": "Representation of a documentation project.\n\nA `Project` serves as the root container for all modules discovered during\nintrospection. Each module is stored by its dotted import path.\n\nAttributes:\n    name (str):\n        Name of the project.\n\n    modules (dict[str, Module]):\n        Mapping of module paths to `Module` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.Project.name",
                    "signature": null,
                    "docstring": null
                  },
                  "modules": {
                    "name": "modules",
                    "kind": "attribute",
                    "path": "docforge.loaders.griffe_loader.Project.modules",
                    "signature": null,
                    "docstring": null
                  },
                  "add_module": {
                    "name": "add_module",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.Project.add_module",
                    "signature": "add_module(module: Module)",
                    "docstring": "Register a module in the project.\n\nArgs:\n    module (Module):\n        Module instance to add to the project."
                  },
                  "get_module": {
                    "name": "get_module",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.Project.get_module",
                    "signature": "get_module(path: str)",
                    "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path (str):\n        Fully qualified dotted module path (for example `pkg.module`).\n\nReturns:\n    Module:\n        The corresponding `Module` instance.\n\nRaises:\n    KeyError:\n        If the module does not exist in the project."
                  },
                  "get_all_modules": {
                    "name": "get_all_modules",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.Project.get_all_modules",
                    "signature": "get_all_modules()",
                    "docstring": "Return all modules contained in the project.\n\nReturns:\n    Iterable[Module]:\n        An iterable of `Module` instances."
                  },
                  "get_module_list": {
                    "name": "get_module_list",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.Project.get_module_list",
                    "signature": "get_module_list()",
                    "docstring": "Return the list of module import paths.\n\nReturns:\n    list[str]:\n        A list containing the dotted paths of all modules in the project."
                  }
                }
              },
              "logger": {
                "name": "logger",
                "kind": "attribute",
                "path": "docforge.loaders.griffe_loader.logger",
                "signature": null,
                "docstring": null
              },
              "discover_module_paths": {
                "name": "discover_module_paths",
                "kind": "function",
                "path": "docforge.loaders.griffe_loader.discover_module_paths",
                "signature": "discover_module_paths(module_name: str, project_root: Path | None = None) -> list[str]",
                "docstring": "Discover Python modules within a package directory.\n\nThe function scans the filesystem for `.py` files inside the specified\npackage and converts them into dotted module import paths.\n\nDiscovery rules:\n\n- Directories containing `__init__.py` are treated as packages.\n- Each `.py` file is treated as a module.\n- Results are returned as dotted import paths.\n\nArgs:\n    module_name (str):\n        Top-level package name to discover modules from.\n\n    project_root (Path | None):\n        Root directory used to resolve module paths. If not provided, the\n        current working directory is used.\n\nReturns:\n    list[str]:\n        A sorted list of unique dotted module import paths.\n\nRaises:\n    FileNotFoundError:\n        If the specified package directory does not exist."
              },
              "GriffeLoader": {
                "name": "GriffeLoader",
                "kind": "class",
                "path": "docforge.loaders.griffe_loader.GriffeLoader",
                "signature": "GriffeLoader()",
                "docstring": "Load Python modules using Griffe and convert them into doc-forge models.\n\nThis loader uses the Griffe introspection engine to analyze Python source\ncode and transform the extracted information into `Project`, `Module`,\nand `DocObject` instances used by doc-forge.\n\nAttributes:\n    _loader (_GriffeLoader):\n        Internal Griffe loader with dedicated module and line collections.",
                "members": {
                  "load_project": {
                    "name": "load_project",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.GriffeLoader.load_project",
                    "signature": "load_project(module_paths: list[str], project_name: str | None = None, skip_import_errors: bool | None = None) -> Project",
                    "docstring": "Load multiple modules and assemble them into a Project model.\n\nEach module path is introspected and converted into a `Module`\ninstance. All modules are then aggregated into a single `Project`\nobject.\n\nArgs:\n    module_paths (list[str]):\n        List of dotted module import paths to load.\n\n    project_name (str | None):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool | None):\n        If True, modules that fail to load will be skipped instead of raising an error.\n\nReturns:\n    Project:\n        A populated `Project` instance containing the loaded modules.\n\nRaises:\n    ValueError:\n        If no module paths are provided.\n\n    ImportError:\n        If a module fails to load and `skip_import_errors` is False."
                  },
                  "load_module": {
                    "name": "load_module",
                    "kind": "function",
                    "path": "docforge.loaders.griffe_loader.GriffeLoader.load_module",
                    "signature": "load_module(path: str) -> Module",
                    "docstring": "Load and convert a single Python module.\n\nThe module is introspected using Griffe and then transformed into\na doc-forge `Module` model.\n\nArgs:\n    path (str):\n        Dotted import path of the module.\n\nReturns:\n    Module:\n        A populated `Module` instance.\n\nRaises:\n    ImportError:\n        If the module cannot be loaded by Griffe.\n\n    KeyError:\n        If the loaded module is missing from the module collection.\n\nExample:\n    Load a single module:\n\n        ```python\n        loader = GriffeLoader()\n        module = loader.load_module(\"mypackage.submodule\")\n        ```"
                  }
                }
              }
            }
          }
        }
      },
      "models": {
        "name": "models",
        "kind": "module",
        "path": "docforge.models",
        "signature": null,
        "docstring": "# Summary\n\nModel layer for doc-forge.\n\nThe `docforge.models` package defines the core data structures used to\nrepresent Python source code as a structured documentation model.\n\n---\n\n# Overview\n\nThe model layer forms the central intermediate representation used throughout\ndoc-forge. Python modules and objects discovered during introspection are\nconverted into a hierarchy of documentation models that can later be rendered\ninto different documentation formats.\n\nKey components:\n\n- **Project** – Root container representing an entire documented codebase.\n- **Module** – Representation of a Python module or package containing\n  documented members.\n- **DocObject** – Recursive structure representing Python objects such as\n  classes, functions, methods, and attributes.\n\nThese models are intentionally **renderer-agnostic**, allowing the same\ndocumentation structure to be transformed into multiple output formats\n(e.g., MkDocs, MCP, or other renderers).\n\n---",
        "members": {
          "Project": {
            "name": "Project",
            "kind": "class",
            "path": "docforge.models.Project",
            "signature": "Project(name: str)",
            "docstring": "Representation of a documentation project.\n\nA `Project` serves as the root container for all modules discovered during\nintrospection. Each module is stored by its dotted import path.\n\nAttributes:\n    name (str):\n        Name of the project.\n\n    modules (dict[str, Module]):\n        Mapping of module paths to `Module` instances.",
            "members": {
              "name": {
                "name": "name",
                "kind": "attribute",
                "path": "docforge.models.Project.name",
                "signature": null,
                "docstring": null
              },
              "modules": {
                "name": "modules",
                "kind": "attribute",
                "path": "docforge.models.Project.modules",
                "signature": null,
                "docstring": null
              },
              "add_module": {
                "name": "add_module",
                "kind": "function",
                "path": "docforge.models.Project.add_module",
                "signature": "add_module(module: Module)",
                "docstring": "Register a module in the project.\n\nArgs:\n    module (Module):\n        Module instance to add to the project."
              },
              "get_module": {
                "name": "get_module",
                "kind": "function",
                "path": "docforge.models.Project.get_module",
                "signature": "get_module(path: str)",
                "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path (str):\n        Fully qualified dotted module path (for example `pkg.module`).\n\nReturns:\n    Module:\n        The corresponding `Module` instance.\n\nRaises:\n    KeyError:\n        If the module does not exist in the project."
              },
              "get_all_modules": {
                "name": "get_all_modules",
                "kind": "function",
                "path": "docforge.models.Project.get_all_modules",
                "signature": "get_all_modules()",
                "docstring": "Return all modules contained in the project.\n\nReturns:\n    Iterable[Module]:\n        An iterable of `Module` instances."
              },
              "get_module_list": {
                "name": "get_module_list",
                "kind": "function",
                "path": "docforge.models.Project.get_module_list",
                "signature": "get_module_list()",
                "docstring": "Return the list of module import paths.\n\nReturns:\n    list[str]:\n        A list containing the dotted paths of all modules in the project."
              }
            }
          },
          "Module": {
            "name": "Module",
            "kind": "class",
            "path": "docforge.models.Module",
            "signature": "Module(path: str, docstring: str | None = None)",
            "docstring": "Representation of a documented Python module or package.\n\nA `Module` stores metadata about the module itself and maintains a\ncollection of top-level documentation objects discovered during\nintrospection.\n\nAttributes:\n    path (str):\n        Dotted import path of the module.\n\n    docstring (str | None):\n        Module-level documentation string, if present.\n\n    members (dict[str, DocObject]):\n        Mapping of object names to their corresponding `DocObject` representations.",
            "members": {
              "path": {
                "name": "path",
                "kind": "attribute",
                "path": "docforge.models.Module.path",
                "signature": null,
                "docstring": null
              },
              "docstring": {
                "name": "docstring",
                "kind": "attribute",
                "path": "docforge.models.Module.docstring",
                "signature": null,
                "docstring": null
              },
              "members": {
                "name": "members",
                "kind": "attribute",
                "path": "docforge.models.Module.members",
                "signature": null,
                "docstring": null
              },
              "add_object": {
                "name": "add_object",
                "kind": "function",
                "path": "docforge.models.Module.add_object",
                "signature": "add_object(obj: DocObject)",
                "docstring": "Add a documented object to the module.\n\nArgs:\n    obj (DocObject):\n        Documentation object to register as a top-level member of the module."
              },
              "get_object": {
                "name": "get_object",
                "kind": "function",
                "path": "docforge.models.Module.get_object",
                "signature": "get_object(name: str)",
                "docstring": "Retrieve a documented object by name.\n\nArgs:\n    name (str):\n        Name of the object to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If no object with the given name exists."
              },
              "get_all_objects": {
                "name": "get_all_objects",
                "kind": "function",
                "path": "docforge.models.Module.get_all_objects",
                "signature": "get_all_objects()",
                "docstring": "Return all top-level documentation objects in the module.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing the module's public members."
              }
            }
          },
          "DocObject": {
            "name": "DocObject",
            "kind": "class",
            "path": "docforge.models.DocObject",
            "signature": "DocObject(name: str, kind: str, path: str, signature: str | None = None, docstring: str | None = None)",
            "docstring": "Representation of a documented Python object.\n\nA `DocObject` models a single Python entity discovered during\nintrospection. Objects may contain nested members, allowing the structure\nof modules, classes, and other containers to be represented recursively.\n\nAttributes:\n    name (str):\n        Local name of the object.\n\n    kind (str):\n        Type of object (for example `class`, `function`, `method`, or `attribute`).\n\n    path (str):\n        Fully qualified dotted path to the object.\n\n    signature (str | None):\n        Callable signature if the object represents a callable.\n\n    docstring (str | None):\n        Raw docstring text extracted from the source code.\n\n    members (dict[str, DocObject]):\n        Mapping of member names to child `DocObject` instances.",
            "members": {
              "name": {
                "name": "name",
                "kind": "attribute",
                "path": "docforge.models.DocObject.name",
                "signature": null,
                "docstring": null
              },
              "kind": {
                "name": "kind",
                "kind": "attribute",
                "path": "docforge.models.DocObject.kind",
                "signature": null,
                "docstring": null
              },
              "path": {
                "name": "path",
                "kind": "attribute",
                "path": "docforge.models.DocObject.path",
                "signature": null,
                "docstring": null
              },
              "signature": {
                "name": "signature",
                "kind": "attribute",
                "path": "docforge.models.DocObject.signature",
                "signature": null,
                "docstring": null
              },
              "docstring": {
                "name": "docstring",
                "kind": "attribute",
                "path": "docforge.models.DocObject.docstring",
                "signature": null,
                "docstring": null
              },
              "members": {
                "name": "members",
                "kind": "attribute",
                "path": "docforge.models.DocObject.members",
                "signature": null,
                "docstring": null
              },
              "add_member": {
                "name": "add_member",
                "kind": "function",
                "path": "docforge.models.DocObject.add_member",
                "signature": "add_member(obj: DocObject)",
                "docstring": "Add a child documentation object.\n\nThis is typically used when attaching methods to classes or\nnested objects to their parent containers.\n\nArgs:\n    obj (DocObject):\n        Documentation object to add as a member."
              },
              "get_member": {
                "name": "get_member",
                "kind": "function",
                "path": "docforge.models.DocObject.get_member",
                "signature": "get_member(name: str)",
                "docstring": "Retrieve a member object by name.\n\nArgs:\n    name (str):\n        Name of the member to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If the member does not exist."
              },
              "get_all_members": {
                "name": "get_all_members",
                "kind": "function",
                "path": "docforge.models.DocObject.get_all_members",
                "signature": "get_all_members()",
                "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
              }
            }
          },
          "module": {
            "name": "module",
            "kind": "module",
            "path": "docforge.models.module",
            "signature": null,
            "docstring": "# Summary\n\nDocumentation model representing a Python module or package.\n\nThis module defines the `Module` class used in the doc-forge documentation\nmodel. A `Module` acts as a container for top-level documented objects\n(classes, functions, variables, and other members) discovered during\nintrospection.\n\n---\n\nNotes:\n    - Only public members are stored; private names are filtered by the loader.\n\n---",
            "members": {
              "DocObject": {
                "name": "DocObject",
                "kind": "class",
                "path": "docforge.models.module.DocObject",
                "signature": "DocObject(name: str, kind: str, path: str, signature: str | None = None, docstring: str | None = None)",
                "docstring": "Representation of a documented Python object.\n\nA `DocObject` models a single Python entity discovered during\nintrospection. Objects may contain nested members, allowing the structure\nof modules, classes, and other containers to be represented recursively.\n\nAttributes:\n    name (str):\n        Local name of the object.\n\n    kind (str):\n        Type of object (for example `class`, `function`, `method`, or `attribute`).\n\n    path (str):\n        Fully qualified dotted path to the object.\n\n    signature (str | None):\n        Callable signature if the object represents a callable.\n\n    docstring (str | None):\n        Raw docstring text extracted from the source code.\n\n    members (dict[str, DocObject]):\n        Mapping of member names to child `DocObject` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.models.module.DocObject.name",
                    "signature": null,
                    "docstring": null
                  },
                  "kind": {
                    "name": "kind",
                    "kind": "attribute",
                    "path": "docforge.models.module.DocObject.kind",
                    "signature": null,
                    "docstring": null
                  },
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.models.module.DocObject.path",
                    "signature": null,
                    "docstring": null
                  },
                  "signature": {
                    "name": "signature",
                    "kind": "attribute",
                    "path": "docforge.models.module.DocObject.signature",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.models.module.DocObject.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.models.module.DocObject.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_member": {
                    "name": "add_member",
                    "kind": "function",
                    "path": "docforge.models.module.DocObject.add_member",
                    "signature": "add_member(obj: DocObject)",
                    "docstring": "Add a child documentation object.\n\nThis is typically used when attaching methods to classes or\nnested objects to their parent containers.\n\nArgs:\n    obj (DocObject):\n        Documentation object to add as a member."
                  },
                  "get_member": {
                    "name": "get_member",
                    "kind": "function",
                    "path": "docforge.models.module.DocObject.get_member",
                    "signature": "get_member(name: str)",
                    "docstring": "Retrieve a member object by name.\n\nArgs:\n    name (str):\n        Name of the member to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If the member does not exist."
                  },
                  "get_all_members": {
                    "name": "get_all_members",
                    "kind": "function",
                    "path": "docforge.models.module.DocObject.get_all_members",
                    "signature": "get_all_members()",
                    "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
                  }
                }
              },
              "Module": {
                "name": "Module",
                "kind": "class",
                "path": "docforge.models.module.Module",
                "signature": "Module(path: str, docstring: str | None = None)",
                "docstring": "Representation of a documented Python module or package.\n\nA `Module` stores metadata about the module itself and maintains a\ncollection of top-level documentation objects discovered during\nintrospection.\n\nAttributes:\n    path (str):\n        Dotted import path of the module.\n\n    docstring (str | None):\n        Module-level documentation string, if present.\n\n    members (dict[str, DocObject]):\n        Mapping of object names to their corresponding `DocObject` representations.",
                "members": {
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.models.module.Module.path",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.models.module.Module.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.models.module.Module.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_object": {
                    "name": "add_object",
                    "kind": "function",
                    "path": "docforge.models.module.Module.add_object",
                    "signature": "add_object(obj: DocObject) -> None",
                    "docstring": "Add a documented object to the module.\n\nArgs:\n    obj (DocObject):\n        Documentation object to register as a top-level member of the module."
                  },
                  "get_object": {
                    "name": "get_object",
                    "kind": "function",
                    "path": "docforge.models.module.Module.get_object",
                    "signature": "get_object(name: str) -> DocObject",
                    "docstring": "Retrieve a documented object by name.\n\nArgs:\n    name (str):\n        Name of the object to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If no object with the given name exists."
                  },
                  "get_all_objects": {
                    "name": "get_all_objects",
                    "kind": "function",
                    "path": "docforge.models.module.Module.get_all_objects",
                    "signature": "get_all_objects() -> Iterable[DocObject]",
                    "docstring": "Return all top-level documentation objects in the module.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing the module's public members."
                  }
                }
              }
            }
          },
          "object": {
            "name": "object",
            "kind": "module",
            "path": "docforge.models.object",
            "signature": null,
            "docstring": "# Summary\n\nDocumentation model representing individual Python objects.\n\nThis module defines the `DocObject` class, the fundamental recursive unit of\nthe doc-forge documentation model. Each `DocObject` represents a Python\nentity such as a class, function, method, or attribute, and may contain nested\nmembers that form a hierarchical documentation structure.\n\n---\n\nNotes:\n    - `DocObject` instances form a tree mirroring the Python import hierarchy.\n    - Objects are renderer-agnostic and may be consumed by any renderer.\n\n---",
            "members": {
              "DocObject": {
                "name": "DocObject",
                "kind": "class",
                "path": "docforge.models.object.DocObject",
                "signature": "DocObject(name: str, kind: str, path: str, signature: str | None = None, docstring: str | None = None)",
                "docstring": "Representation of a documented Python object.\n\nA `DocObject` models a single Python entity discovered during\nintrospection. Objects may contain nested members, allowing the structure\nof modules, classes, and other containers to be represented recursively.\n\nAttributes:\n    name (str):\n        Local name of the object.\n\n    kind (str):\n        Type of object (for example `class`, `function`, `method`, or `attribute`).\n\n    path (str):\n        Fully qualified dotted path to the object.\n\n    signature (str | None):\n        Callable signature if the object represents a callable.\n\n    docstring (str | None):\n        Raw docstring text extracted from the source code.\n\n    members (dict[str, DocObject]):\n        Mapping of member names to child `DocObject` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.models.object.DocObject.name",
                    "signature": null,
                    "docstring": null
                  },
                  "kind": {
                    "name": "kind",
                    "kind": "attribute",
                    "path": "docforge.models.object.DocObject.kind",
                    "signature": null,
                    "docstring": null
                  },
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.models.object.DocObject.path",
                    "signature": null,
                    "docstring": null
                  },
                  "signature": {
                    "name": "signature",
                    "kind": "attribute",
                    "path": "docforge.models.object.DocObject.signature",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.models.object.DocObject.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.models.object.DocObject.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_member": {
                    "name": "add_member",
                    "kind": "function",
                    "path": "docforge.models.object.DocObject.add_member",
                    "signature": "add_member(obj: DocObject) -> None",
                    "docstring": "Add a child documentation object.\n\nThis is typically used when attaching methods to classes or\nnested objects to their parent containers.\n\nArgs:\n    obj (DocObject):\n        Documentation object to add as a member."
                  },
                  "get_member": {
                    "name": "get_member",
                    "kind": "function",
                    "path": "docforge.models.object.DocObject.get_member",
                    "signature": "get_member(name: str) -> DocObject",
                    "docstring": "Retrieve a member object by name.\n\nArgs:\n    name (str):\n        Name of the member to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If the member does not exist."
                  },
                  "get_all_members": {
                    "name": "get_all_members",
                    "kind": "function",
                    "path": "docforge.models.object.DocObject.get_all_members",
                    "signature": "get_all_members() -> Iterable[DocObject]",
                    "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
                  }
                }
              }
            }
          },
          "project": {
            "name": "project",
            "kind": "module",
            "path": "docforge.models.project",
            "signature": null,
            "docstring": "# Summary\n\nDocumentation model representing a project.\n\nThis module defines the `Project` class, the top-level container used by\ndoc-forge to represent a documented codebase. A `Project` aggregates multiple\nmodules and provides access to them through a unified interface.\n\n---\n\nNotes:\n    - Modules are keyed by their dotted import path.\n    - Objects are renderer-agnostic; the same model feeds every renderer.\n\n---",
            "members": {
              "Module": {
                "name": "Module",
                "kind": "class",
                "path": "docforge.models.project.Module",
                "signature": "Module(path: str, docstring: str | None = None)",
                "docstring": "Representation of a documented Python module or package.\n\nA `Module` stores metadata about the module itself and maintains a\ncollection of top-level documentation objects discovered during\nintrospection.\n\nAttributes:\n    path (str):\n        Dotted import path of the module.\n\n    docstring (str | None):\n        Module-level documentation string, if present.\n\n    members (dict[str, DocObject]):\n        Mapping of object names to their corresponding `DocObject` representations.",
                "members": {
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.models.project.Module.path",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.models.project.Module.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.models.project.Module.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_object": {
                    "name": "add_object",
                    "kind": "function",
                    "path": "docforge.models.project.Module.add_object",
                    "signature": "add_object(obj: DocObject)",
                    "docstring": "Add a documented object to the module.\n\nArgs:\n    obj (DocObject):\n        Documentation object to register as a top-level member of the module."
                  },
                  "get_object": {
                    "name": "get_object",
                    "kind": "function",
                    "path": "docforge.models.project.Module.get_object",
                    "signature": "get_object(name: str)",
                    "docstring": "Retrieve a documented object by name.\n\nArgs:\n    name (str):\n        Name of the object to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If no object with the given name exists."
                  },
                  "get_all_objects": {
                    "name": "get_all_objects",
                    "kind": "function",
                    "path": "docforge.models.project.Module.get_all_objects",
                    "signature": "get_all_objects()",
                    "docstring": "Return all top-level documentation objects in the module.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing the module's public members."
                  }
                }
              },
              "Project": {
                "name": "Project",
                "kind": "class",
                "path": "docforge.models.project.Project",
                "signature": "Project(name: str)",
                "docstring": "Representation of a documentation project.\n\nA `Project` serves as the root container for all modules discovered during\nintrospection. Each module is stored by its dotted import path.\n\nAttributes:\n    name (str):\n        Name of the project.\n\n    modules (dict[str, Module]):\n        Mapping of module paths to `Module` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.models.project.Project.name",
                    "signature": null,
                    "docstring": null
                  },
                  "modules": {
                    "name": "modules",
                    "kind": "attribute",
                    "path": "docforge.models.project.Project.modules",
                    "signature": null,
                    "docstring": null
                  },
                  "add_module": {
                    "name": "add_module",
                    "kind": "function",
                    "path": "docforge.models.project.Project.add_module",
                    "signature": "add_module(module: Module) -> None",
                    "docstring": "Register a module in the project.\n\nArgs:\n    module (Module):\n        Module instance to add to the project."
                  },
                  "get_module": {
                    "name": "get_module",
                    "kind": "function",
                    "path": "docforge.models.project.Project.get_module",
                    "signature": "get_module(path: str) -> Module",
                    "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path (str):\n        Fully qualified dotted module path (for example `pkg.module`).\n\nReturns:\n    Module:\n        The corresponding `Module` instance.\n\nRaises:\n    KeyError:\n        If the module does not exist in the project."
                  },
                  "get_all_modules": {
                    "name": "get_all_modules",
                    "kind": "function",
                    "path": "docforge.models.project.Project.get_all_modules",
                    "signature": "get_all_modules() -> Iterable[Module]",
                    "docstring": "Return all modules contained in the project.\n\nReturns:\n    Iterable[Module]:\n        An iterable of `Module` instances."
                  },
                  "get_module_list": {
                    "name": "get_module_list",
                    "kind": "function",
                    "path": "docforge.models.project.Project.get_module_list",
                    "signature": "get_module_list() -> list[str]",
                    "docstring": "Return the list of module import paths.\n\nReturns:\n    list[str]:\n        A list containing the dotted paths of all modules in the project."
                  }
                }
              }
            }
          }
        }
      },
      "nav": {
        "name": "nav",
        "kind": "module",
        "path": "docforge.nav",
        "signature": null,
        "docstring": "Navigation layer for doc-forge.\n\nThe ``docforge.nav`` package manages the relationship between the logical\ndocumentation structure defined by the user and the physical documentation\nfiles generated on disk.\n\n---\n\nWorkflow\n--------\n\n1. **Specification** – Users define navigation intent in ``docforge.nav.yml``.\n2. **Resolution** – ``resolve_nav`` expands patterns and matches them against\n   generated Markdown files.\n3. **Emission** – ``MkDocsNavEmitter`` converts the resolved structure into\n   the YAML navigation format required by ``mkdocs.yml``.\n\nThis layer separates documentation organization from the underlying source\ncode layout, enabling flexible grouping, ordering, and navigation structures\nindependent of module hierarchy.\n\n---",
        "members": {
          "NavSpec": {
            "name": "NavSpec",
            "kind": "class",
            "path": "docforge.nav.NavSpec",
            "signature": "NavSpec(home: str | None, groups: dict[str, list[str]], icon: dict[str, str] | None = None)",
            "docstring": "Parsed representation of a navigation specification.\n\nA ``NavSpec`` describes the intended documentation navigation layout before\nit is resolved against the filesystem.\n\nAttributes:\n    home: Relative path to the documentation home page (for example\n        ``index.md``).\n    groups: Mapping of navigation group titles to lists of file patterns\n        or glob expressions.\n    icon: Optional mapping of theme icon entries (for example\n        ``{\"logo\": \"material/code-tags\"}``) injected into the MkDocs\n        theme as ``theme.icon``.",
            "members": {
              "home": {
                "name": "home",
                "kind": "attribute",
                "path": "docforge.nav.NavSpec.home",
                "signature": null,
                "docstring": null
              },
              "groups": {
                "name": "groups",
                "kind": "attribute",
                "path": "docforge.nav.NavSpec.groups",
                "signature": null,
                "docstring": null
              },
              "icon": {
                "name": "icon",
                "kind": "attribute",
                "path": "docforge.nav.NavSpec.icon",
                "signature": null,
                "docstring": null
              },
              "load": {
                "name": "load",
                "kind": "function",
                "path": "docforge.nav.NavSpec.load",
                "signature": "load(path: Path)",
                "docstring": "Load a navigation specification from a YAML file.\n\nArgs:\n    path (Path):\n        Filesystem path to the navigation specification file.\n\nReturns:\n    NavSpec:\n        A ``NavSpec`` instance representing the parsed configuration.\n\nRaises:\n    FileNotFoundError: If the specified file does not exist.\n    ValueError: If the file contents are not a valid navigation\n        specification."
              },
              "all_patterns": {
                "name": "all_patterns",
                "kind": "function",
                "path": "docforge.nav.NavSpec.all_patterns",
                "signature": "all_patterns()",
                "docstring": "Return all path patterns referenced by the specification.\n\nReturns:\n    list[str]:\n        A list containing the home document (if defined) and all\n        group pattern entries."
              }
            }
          },
          "load_nav_spec": {
            "name": "load_nav_spec",
            "kind": "function",
            "path": "docforge.nav.load_nav_spec",
            "signature": "load_nav_spec(path: Path)",
            "docstring": "Load a navigation specification file.\n\nThis helper function reads a YAML navigation file and constructs a\ncorresponding ``NavSpec`` instance.\n\nArgs:\n    path (Path):\n        Path to the navigation specification file.\n\nReturns:\n    NavSpec:\n        A ``NavSpec`` instance representing the parsed specification.\n\nRaises:\n    FileNotFoundError: If the specification file does not exist.\n    ValueError: If the YAML structure is invalid."
          },
          "ResolvedNav": {
            "name": "ResolvedNav",
            "kind": "class",
            "path": "docforge.nav.ResolvedNav",
            "signature": "ResolvedNav(home: str | None, groups: dict[str, list[Path]], docs_root: Path | None = None)",
            "docstring": "Resolved navigation structure.\n\nA ``ResolvedNav`` represents navigation data after glob patterns have been\nexpanded and paths validated against the filesystem.\n\nAttributes:\n    home: Relative path to the documentation home page.\n    groups: Mapping of navigation group titles to lists of resolved\n        documentation file paths.",
            "members": {
              "home": {
                "name": "home",
                "kind": "attribute",
                "path": "docforge.nav.ResolvedNav.home",
                "signature": null,
                "docstring": null
              },
              "groups": {
                "name": "groups",
                "kind": "attribute",
                "path": "docforge.nav.ResolvedNav.groups",
                "signature": null,
                "docstring": null
              },
              "all_files": {
                "name": "all_files",
                "kind": "function",
                "path": "docforge.nav.ResolvedNav.all_files",
                "signature": "all_files()",
                "docstring": "Iterate over all files referenced by the navigation structure.\n\nYields:\n    Path:\n        A documentation file referenced by the navigation, including\n        the home page when defined.\n\nRaises:\n    RuntimeError: If the home page is defined but the documentation\n        root is not available for resolution."
              }
            }
          },
          "resolve_nav": {
            "name": "resolve_nav",
            "kind": "function",
            "path": "docforge.nav.resolve_nav",
            "signature": "resolve_nav(spec: NavSpec, docs_root: Path)",
            "docstring": "Resolve a navigation specification against the filesystem.\n\nThe function expands glob patterns defined in a ``NavSpec`` and verifies\nthat referenced documentation files exist within the documentation root.\n\nArgs:\n    spec (NavSpec):\n        Navigation specification describing documentation layout.\n    docs_root (Path):\n        Root directory containing documentation Markdown files.\n\nReturns:\n    ResolvedNav:\n        A `ResolvedNav` instance containing validated navigation paths.\n\nRaises:\n    FileNotFoundError: If the documentation root does not exist or a\n        navigation pattern does not match any files."
          },
          "MkDocsNavEmitter": {
            "name": "MkDocsNavEmitter",
            "kind": "class",
            "path": "docforge.nav.MkDocsNavEmitter",
            "signature": null,
            "docstring": "Emit MkDocs navigation structures from resolved navigation data.\n\nThe emitter transforms a ``ResolvedNav`` object into the YAML-compatible\nlist structure expected by the MkDocs ``nav`` configuration field.",
            "members": {
              "emit": {
                "name": "emit",
                "kind": "function",
                "path": "docforge.nav.MkDocsNavEmitter.emit",
                "signature": "emit(nav: ResolvedNav)",
                "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav (ResolvedNav):\n        Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\n    list[dict[str, Any]]:\n        A list of dictionaries representing the MkDocs navigation layout.\n        Each dictionary maps a navigation label to a page or a list of\n        pages."
              }
            }
          },
          "build_wiki_nav": {
            "name": "build_wiki_nav",
            "kind": "function",
            "path": "docforge.nav.build_wiki_nav",
            "signature": "build_wiki_nav(wiki_dir: Path)",
            "docstring": "Derive an MkDocs navigation block from a wiki directory.\n\nReturned paths are relative to the parent of ``wiki_dir`` and carry the\nwiki directory name as their leading component (for example\n``wiki/01_overview.md`` when the wiki lives at ``docs/wiki``). This makes\nthe result directly usable in an MkDocs ``nav`` block with\n\n- ``index.md`` at the wiki root becomes the ``Home`` entry.\n- Page labels are derived from filenames: numeric order prefixes such as\n  ``01_`` or ``02-`` are stripped, separators are replaced with spaces, and\n  names are title-cased (``01_overview.md`` becomes ``Overview``).\n- Subdirectories become nested navigation groups. A nested ``index.md`` is\n  rendered as the section root placed first inside the group.\n- Only ``.md`` files are considered; hidden entries are ignored.\n\nArgs:\n    wiki_dir (Path):\n        Path to the hand-written wiki directory, for example ``docs/wiki``.\n\nReturns:\n    list[dict[str, Any]]:\n        Navigation entries compatible with the MkDocs ``nav`` configuration.\n        The list is empty if the wiki contains no Markdown files.\n\nRaises:\n    FileNotFoundError:\n        If the wiki directory does not exist."
          },
          "mkdocs": {
            "name": "mkdocs",
            "kind": "module",
            "path": "docforge.nav.mkdocs",
            "signature": null,
            "docstring": "MkDocs navigation emitter.\n\nThis module provides the ``MkDocsNavEmitter`` class, which converts a\n``ResolvedNav`` instance into the navigation structure required by the\nMkDocs ``nav`` configuration.\n\n---\n\nNotes:\n    - The emitted structure is a list of dictionaries, one per top-level nav\n      entry, matching the MkDocs ``nav`` YAML format.\n\n---",
            "members": {
              "ResolvedNav": {
                "name": "ResolvedNav",
                "kind": "class",
                "path": "docforge.nav.mkdocs.ResolvedNav",
                "signature": "ResolvedNav(home: str | None, groups: dict[str, list[Path]], docs_root: Path | None = None)",
                "docstring": "Resolved navigation structure.\n\nA ``ResolvedNav`` represents navigation data after glob patterns have been\nexpanded and paths validated against the filesystem.\n\nAttributes:\n    home: Relative path to the documentation home page.\n    groups: Mapping of navigation group titles to lists of resolved\n        documentation file paths.",
                "members": {
                  "home": {
                    "name": "home",
                    "kind": "attribute",
                    "path": "docforge.nav.mkdocs.ResolvedNav.home",
                    "signature": null,
                    "docstring": null
                  },
                  "groups": {
                    "name": "groups",
                    "kind": "attribute",
                    "path": "docforge.nav.mkdocs.ResolvedNav.groups",
                    "signature": null,
                    "docstring": null
                  },
                  "all_files": {
                    "name": "all_files",
                    "kind": "function",
                    "path": "docforge.nav.mkdocs.ResolvedNav.all_files",
                    "signature": "all_files()",
                    "docstring": "Iterate over all files referenced by the navigation structure.\n\nYields:\n    Path:\n        A documentation file referenced by the navigation, including\n        the home page when defined.\n\nRaises:\n    RuntimeError: If the home page is defined but the documentation\n        root is not available for resolution."
                  }
                }
              },
              "MkDocsNavEmitter": {
                "name": "MkDocsNavEmitter",
                "kind": "class",
                "path": "docforge.nav.mkdocs.MkDocsNavEmitter",
                "signature": null,
                "docstring": "Emit MkDocs navigation structures from resolved navigation data.\n\nThe emitter transforms a ``ResolvedNav`` object into the YAML-compatible\nlist structure expected by the MkDocs ``nav`` configuration field.",
                "members": {
                  "emit": {
                    "name": "emit",
                    "kind": "function",
                    "path": "docforge.nav.mkdocs.MkDocsNavEmitter.emit",
                    "signature": "emit(nav: ResolvedNav) -> list[dict[str, Any]]",
                    "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav (ResolvedNav):\n        Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\n    list[dict[str, Any]]:\n        A list of dictionaries representing the MkDocs navigation layout.\n        Each dictionary maps a navigation label to a page or a list of\n        pages."
                  }
                }
              }
            }
          },
          "resolver": {
            "name": "resolver",
            "kind": "module",
            "path": "docforge.nav.resolver",
            "signature": null,
            "docstring": "Navigation resolution utilities.\n\nThis module resolves a ``NavSpec`` against the filesystem by expanding glob\npatterns and validating that referenced documentation files exist.\n\n---\n\nNotes:\n    - Glob resolution is recursive and returns paths in sorted order.\n    - Unmatched patterns raise ``FileNotFoundError`` to fail fast on typos.\n\n---",
            "members": {
              "NavSpec": {
                "name": "NavSpec",
                "kind": "class",
                "path": "docforge.nav.resolver.NavSpec",
                "signature": "NavSpec(home: str | None, groups: dict[str, list[str]], icon: dict[str, str] | None = None)",
                "docstring": "Parsed representation of a navigation specification.\n\nA ``NavSpec`` describes the intended documentation navigation layout before\nit is resolved against the filesystem.\n\nAttributes:\n    home: Relative path to the documentation home page (for example\n        ``index.md``).\n    groups: Mapping of navigation group titles to lists of file patterns\n        or glob expressions.\n    icon: Optional mapping of theme icon entries (for example\n        ``{\"logo\": \"material/code-tags\"}``) injected into the MkDocs\n        theme as ``theme.icon``.",
                "members": {
                  "home": {
                    "name": "home",
                    "kind": "attribute",
                    "path": "docforge.nav.resolver.NavSpec.home",
                    "signature": null,
                    "docstring": null
                  },
                  "groups": {
                    "name": "groups",
                    "kind": "attribute",
                    "path": "docforge.nav.resolver.NavSpec.groups",
                    "signature": null,
                    "docstring": null
                  },
                  "icon": {
                    "name": "icon",
                    "kind": "attribute",
                    "path": "docforge.nav.resolver.NavSpec.icon",
                    "signature": null,
                    "docstring": null
                  },
                  "load": {
                    "name": "load",
                    "kind": "function",
                    "path": "docforge.nav.resolver.NavSpec.load",
                    "signature": "load(path: Path)",
                    "docstring": "Load a navigation specification from a YAML file.\n\nArgs:\n    path (Path):\n        Filesystem path to the navigation specification file.\n\nReturns:\n    NavSpec:\n        A ``NavSpec`` instance representing the parsed configuration.\n\nRaises:\n    FileNotFoundError: If the specified file does not exist.\n    ValueError: If the file contents are not a valid navigation\n        specification."
                  },
                  "all_patterns": {
                    "name": "all_patterns",
                    "kind": "function",
                    "path": "docforge.nav.resolver.NavSpec.all_patterns",
                    "signature": "all_patterns()",
                    "docstring": "Return all path patterns referenced by the specification.\n\nReturns:\n    list[str]:\n        A list containing the home document (if defined) and all\n        group pattern entries."
                  }
                }
              },
              "ResolvedNav": {
                "name": "ResolvedNav",
                "kind": "class",
                "path": "docforge.nav.resolver.ResolvedNav",
                "signature": "ResolvedNav(home: str | None, groups: dict[str, list[Path]], docs_root: Path | None = None)",
                "docstring": "Resolved navigation structure.\n\nA ``ResolvedNav`` represents navigation data after glob patterns have been\nexpanded and paths validated against the filesystem.\n\nAttributes:\n    home: Relative path to the documentation home page.\n    groups: Mapping of navigation group titles to lists of resolved\n        documentation file paths.",
                "members": {
                  "home": {
                    "name": "home",
                    "kind": "attribute",
                    "path": "docforge.nav.resolver.ResolvedNav.home",
                    "signature": null,
                    "docstring": null
                  },
                  "groups": {
                    "name": "groups",
                    "kind": "attribute",
                    "path": "docforge.nav.resolver.ResolvedNav.groups",
                    "signature": null,
                    "docstring": null
                  },
                  "all_files": {
                    "name": "all_files",
                    "kind": "function",
                    "path": "docforge.nav.resolver.ResolvedNav.all_files",
                    "signature": "all_files() -> Iterable[Path]",
                    "docstring": "Iterate over all files referenced by the navigation structure.\n\nYields:\n    Path:\n        A documentation file referenced by the navigation, including\n        the home page when defined.\n\nRaises:\n    RuntimeError: If the home page is defined but the documentation\n        root is not available for resolution."
                  }
                }
              },
              "resolve_nav": {
                "name": "resolve_nav",
                "kind": "function",
                "path": "docforge.nav.resolver.resolve_nav",
                "signature": "resolve_nav(spec: NavSpec, docs_root: Path) -> ResolvedNav",
                "docstring": "Resolve a navigation specification against the filesystem.\n\nThe function expands glob patterns defined in a ``NavSpec`` and verifies\nthat referenced documentation files exist within the documentation root.\n\nArgs:\n    spec (NavSpec):\n        Navigation specification describing documentation layout.\n    docs_root (Path):\n        Root directory containing documentation Markdown files.\n\nReturns:\n    ResolvedNav:\n        A `ResolvedNav` instance containing validated navigation paths.\n\nRaises:\n    FileNotFoundError: If the documentation root does not exist or a\n        navigation pattern does not match any files."
              }
            }
          },
          "spec": {
            "name": "spec",
            "kind": "module",
            "path": "docforge.nav.spec",
            "signature": null,
            "docstring": "Navigation specification model.\n\nThis module defines the ``NavSpec`` class, which represents the navigation\nstructure defined by the user in the doc-forge navigation specification\n(typically ``docforge.nav.yml``).\n\n---\n\nNotes:\n    - The spec file supports an optional ``icon`` mapping for MkDocs theme\n      customization.\n    - All file references in ``groups`` are relative to the documentation root.\n\n---",
            "members": {
              "NavSpec": {
                "name": "NavSpec",
                "kind": "class",
                "path": "docforge.nav.spec.NavSpec",
                "signature": "NavSpec(home: str | None, groups: dict[str, list[str]], icon: dict[str, str] | None = None)",
                "docstring": "Parsed representation of a navigation specification.\n\nA ``NavSpec`` describes the intended documentation navigation layout before\nit is resolved against the filesystem.\n\nAttributes:\n    home: Relative path to the documentation home page (for example\n        ``index.md``).\n    groups: Mapping of navigation group titles to lists of file patterns\n        or glob expressions.\n    icon: Optional mapping of theme icon entries (for example\n        ``{\"logo\": \"material/code-tags\"}``) injected into the MkDocs\n        theme as ``theme.icon``.",
                "members": {
                  "home": {
                    "name": "home",
                    "kind": "attribute",
                    "path": "docforge.nav.spec.NavSpec.home",
                    "signature": null,
                    "docstring": null
                  },
                  "groups": {
                    "name": "groups",
                    "kind": "attribute",
                    "path": "docforge.nav.spec.NavSpec.groups",
                    "signature": null,
                    "docstring": null
                  },
                  "icon": {
                    "name": "icon",
                    "kind": "attribute",
                    "path": "docforge.nav.spec.NavSpec.icon",
                    "signature": null,
                    "docstring": null
                  },
                  "load": {
                    "name": "load",
                    "kind": "function",
                    "path": "docforge.nav.spec.NavSpec.load",
                    "signature": "load(path: Path) -> NavSpec",
                    "docstring": "Load a navigation specification from a YAML file.\n\nArgs:\n    path (Path):\n        Filesystem path to the navigation specification file.\n\nReturns:\n    NavSpec:\n        A ``NavSpec`` instance representing the parsed configuration.\n\nRaises:\n    FileNotFoundError: If the specified file does not exist.\n    ValueError: If the file contents are not a valid navigation\n        specification."
                  },
                  "all_patterns": {
                    "name": "all_patterns",
                    "kind": "function",
                    "path": "docforge.nav.spec.NavSpec.all_patterns",
                    "signature": "all_patterns() -> list[str]",
                    "docstring": "Return all path patterns referenced by the specification.\n\nReturns:\n    list[str]:\n        A list containing the home document (if defined) and all\n        group pattern entries."
                  }
                }
              },
              "load_nav_spec": {
                "name": "load_nav_spec",
                "kind": "function",
                "path": "docforge.nav.spec.load_nav_spec",
                "signature": "load_nav_spec(path: Path) -> NavSpec",
                "docstring": "Load a navigation specification file.\n\nThis helper function reads a YAML navigation file and constructs a\ncorresponding ``NavSpec`` instance.\n\nArgs:\n    path (Path):\n        Path to the navigation specification file.\n\nReturns:\n    NavSpec:\n        A ``NavSpec`` instance representing the parsed specification.\n\nRaises:\n    FileNotFoundError: If the specification file does not exist.\n    ValueError: If the YAML structure is invalid."
              }
            }
          },
          "wiki": {
            "name": "wiki",
            "kind": "module",
            "path": "docforge.nav.wiki",
            "signature": null,
            "docstring": "# Summary\n\nWiki navigation derivation.\n\nThis module provides ``build_wiki_nav``, which derives an MkDocs-ready\nnavigation block from the file structure of a hand-written wiki directory\n(typically ``docs/wiki``). wiki content is authored by hand and is never\nmodified by doc-forge; only the navigation layout is inferred.\n\n# Notes\n\n- ``index.md`` at the wiki root becomes the ``Home`` entry.\n- Page labels are derived from filenames: numeric order prefixes such as\n  ``01_`` or ``02-`` are stripped, separators are replaced with spaces, and\n  names are title-cased (``01_overview.md`` becomes ``Overview``).\n- Subdirectories become nested navigation groups. A nested ``index.md`` is\n  rendered as the section root placed first inside the group.\n- Only ``.md`` files are considered; hidden entries are ignored.",
            "members": {
              "build_wiki_nav": {
                "name": "build_wiki_nav",
                "kind": "function",
                "path": "docforge.nav.wiki.build_wiki_nav",
                "signature": "build_wiki_nav(wiki_dir: Path) -> list[dict[str, Any]]",
                "docstring": "Derive an MkDocs navigation block from a wiki directory.\n\nReturned paths are relative to the parent of ``wiki_dir`` and carry the\nwiki directory name as their leading component (for example\n``wiki/01_overview.md`` when the wiki lives at ``docs/wiki``). This makes\nthe result directly usable in an MkDocs ``nav`` block with\n\n- ``index.md`` at the wiki root becomes the ``Home`` entry.\n- Page labels are derived from filenames: numeric order prefixes such as\n  ``01_`` or ``02-`` are stripped, separators are replaced with spaces, and\n  names are title-cased (``01_overview.md`` becomes ``Overview``).\n- Subdirectories become nested navigation groups. A nested ``index.md`` is\n  rendered as the section root placed first inside the group.\n- Only ``.md`` files are considered; hidden entries are ignored.\n\nArgs:\n    wiki_dir (Path):\n        Path to the hand-written wiki directory, for example ``docs/wiki``.\n\nReturns:\n    list[dict[str, Any]]:\n        Navigation entries compatible with the MkDocs ``nav`` configuration.\n        The list is empty if the wiki contains no Markdown files.\n\nRaises:\n    FileNotFoundError:\n        If the wiki directory does not exist."
              }
            }
          }
        }
      },
      "renderers": {
        "name": "renderers",
        "kind": "module",
        "path": "docforge.renderers",
        "signature": null,
        "docstring": "# Summary\n\nRenderers layer for doc-forge.\n\nThe `docforge.renderers` package transforms the internal documentation\nmodels into files formatted for specific documentation systems.\n\n---\n\n# Overview\n\nRenderers consume the doc-forge project model and generate output suitable\nfor documentation tools or machine interfaces.\n\nCurrent implementations:\n\n- **MkDocsRenderer** – Produces Markdown files compatible with MkDocs and\n  the `mkdocstrings` plugin. It automatically handles package hierarchy\n  and generates `index.md` files for packages.\n- **MCPRenderer** – Emits structured JSON resources designed for consumption\n  by Model Context Protocol (MCP) clients.\n\n---\n\n# Extending\n\nNew renderers can be added by implementing the `DocRenderer` protocol\ndefined in `docforge.renderers.base`.\n\n---",
        "members": {
          "MkDocsRenderer": {
            "name": "MkDocsRenderer",
            "kind": "class",
            "path": "docforge.renderers.MkDocsRenderer",
            "signature": null,
            "docstring": "Renderer that produces Markdown documentation for MkDocs.\n\nGenerated pages use mkdocstrings directives to reference Python modules,\nallowing MkDocs to render API documentation dynamically.",
            "members": {
              "name": {
                "name": "name",
                "kind": "attribute",
                "path": "docforge.renderers.MkDocsRenderer.name",
                "signature": null,
                "docstring": null
              },
              "generate_sources": {
                "name": "generate_sources",
                "kind": "function",
                "path": "docforge.renderers.MkDocsRenderer.generate_sources",
                "signature": "generate_sources(project: Project, out_dir: Path, module_is_source: bool | None = None)",
                "docstring": "Generate Markdown documentation files for a project.\n\nThis method renders a documentation structure from the provided\nproject model and writes the resulting Markdown files to the\nspecified output directory.\n\nArgs:\n    project (Project):\n        Project model containing modules to document.\n\n    out_dir (Path):\n        Directory where generated Markdown files will be written.\n\n    module_is_source (bool | None):\n        If True, treat the specified module as the documentation root\n        rather than nesting it inside a folder."
              },
              "generate_readme": {
                "name": "generate_readme",
                "kind": "function",
                "path": "docforge.renderers.MkDocsRenderer.generate_readme",
                "signature": "generate_readme(project: Project, docs_dir: Path, module_is_source: bool | None = None, readme_dir: Path | None = None)",
                "docstring": "Generate a `README.md` file from the root module docstring.\n\nNotes:\n    - If `module_is_source` is True, `README.md` is written to the\n      project root directory.\n    - If False, README generation is currently not implemented.\n\nArgs:\n    project (Project):\n        Project model containing documentation metadata.\n\n    docs_dir (Path):\n        Directory containing generated documentation sources.\n\n    module_is_source (bool | None):\n        Whether the module is treated as the project source root.\n\n    readme_dir (Path | None):\n        Directory where the generated README.md should be written.\n        Defaults to the parent of `docs_dir`."
              }
            }
          },
          "MCPRenderer": {
            "name": "MCPRenderer",
            "kind": "class",
            "path": "docforge.renderers.MCPRenderer",
            "signature": null,
            "docstring": "Renderer that generates MCP-compatible documentation resources.\n\nThis renderer converts doc-forge project models into structured JSON\nresources suitable for consumption by systems implementing the Model\nContext Protocol (MCP).",
            "members": {
              "name": {
                "name": "name",
                "kind": "attribute",
                "path": "docforge.renderers.MCPRenderer.name",
                "signature": null,
                "docstring": null
              },
              "generate_sources": {
                "name": "generate_sources",
                "kind": "function",
                "path": "docforge.renderers.MCPRenderer.generate_sources",
                "signature": "generate_sources(project: Project, out_dir: Path)",
                "docstring": "Generate MCP documentation resources for a project.\n\nThe renderer serializes each module into a JSON resource and produces\nsupporting metadata files such as `nav.json` and `index.json`.\n\nArgs:\n    project (Project):\n        Documentation project model to render.\n\n    out_dir (Path):\n        Directory where MCP resources will be written."
              }
            }
          },
          "base": {
            "name": "base",
            "kind": "module",
            "path": "docforge.renderers.base",
            "signature": null,
            "docstring": "# Summary\n\nRenderer base interfaces and configuration models.\n\nThis module defines the base protocol and configuration container used by\ndoc-forge renderers. Concrete renderer implementations should implement the\n`DocRenderer` protocol.",
            "members": {
              "Project": {
                "name": "Project",
                "kind": "class",
                "path": "docforge.renderers.base.Project",
                "signature": "Project(name: str)",
                "docstring": "Representation of a documentation project.\n\nA `Project` serves as the root container for all modules discovered during\nintrospection. Each module is stored by its dotted import path.\n\nAttributes:\n    name (str):\n        Name of the project.\n\n    modules (dict[str, Module]):\n        Mapping of module paths to `Module` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.renderers.base.Project.name",
                    "signature": null,
                    "docstring": null
                  },
                  "modules": {
                    "name": "modules",
                    "kind": "attribute",
                    "path": "docforge.renderers.base.Project.modules",
                    "signature": null,
                    "docstring": null
                  },
                  "add_module": {
                    "name": "add_module",
                    "kind": "function",
                    "path": "docforge.renderers.base.Project.add_module",
                    "signature": "add_module(module: Module)",
                    "docstring": "Register a module in the project.\n\nArgs:\n    module (Module):\n        Module instance to add to the project."
                  },
                  "get_module": {
                    "name": "get_module",
                    "kind": "function",
                    "path": "docforge.renderers.base.Project.get_module",
                    "signature": "get_module(path: str)",
                    "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path (str):\n        Fully qualified dotted module path (for example `pkg.module`).\n\nReturns:\n    Module:\n        The corresponding `Module` instance.\n\nRaises:\n    KeyError:\n        If the module does not exist in the project."
                  },
                  "get_all_modules": {
                    "name": "get_all_modules",
                    "kind": "function",
                    "path": "docforge.renderers.base.Project.get_all_modules",
                    "signature": "get_all_modules()",
                    "docstring": "Return all modules contained in the project.\n\nReturns:\n    Iterable[Module]:\n        An iterable of `Module` instances."
                  },
                  "get_module_list": {
                    "name": "get_module_list",
                    "kind": "function",
                    "path": "docforge.renderers.base.Project.get_module_list",
                    "signature": "get_module_list()",
                    "docstring": "Return the list of module import paths.\n\nReturns:\n    list[str]:\n        A list containing the dotted paths of all modules in the project."
                  }
                }
              },
              "RendererConfig": {
                "name": "RendererConfig",
                "kind": "class",
                "path": "docforge.renderers.base.RendererConfig",
                "signature": "RendererConfig(out_dir: Path, project: Project)",
                "docstring": "Configuration container for documentation renderers.\n\nA `RendererConfig` instance groups together the project model and the\noutput directory used during rendering.\n\nAttributes:\n    out_dir (Path):\n        Directory where generated documentation files will be written.\n\n    project (Project):\n        Documentation project model to be rendered.",
                "members": {
                  "out_dir": {
                    "name": "out_dir",
                    "kind": "attribute",
                    "path": "docforge.renderers.base.RendererConfig.out_dir",
                    "signature": null,
                    "docstring": null
                  },
                  "project": {
                    "name": "project",
                    "kind": "attribute",
                    "path": "docforge.renderers.base.RendererConfig.project",
                    "signature": null,
                    "docstring": null
                  }
                }
              },
              "DocRenderer": {
                "name": "DocRenderer",
                "kind": "class",
                "path": "docforge.renderers.base.DocRenderer",
                "signature": null,
                "docstring": "Protocol defining the interface for documentation renderers.\n\nImplementations of this protocol are responsible for transforming a\n`Project` model into renderer-specific documentation sources.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.renderers.base.DocRenderer.name",
                    "signature": null,
                    "docstring": null
                  },
                  "generate_sources": {
                    "name": "generate_sources",
                    "kind": "function",
                    "path": "docforge.renderers.base.DocRenderer.generate_sources",
                    "signature": "generate_sources(project: Project, out_dir: Path) -> None",
                    "docstring": "Generate renderer-specific documentation sources.\n\nArgs:\n    project (Project):\n        Project model containing modules and documentation objects.\n\n    out_dir (Path):\n        Directory where generated documentation sources should be written."
                  }
                }
              }
            }
          },
          "mcp_renderer": {
            "name": "mcp_renderer",
            "kind": "module",
            "path": "docforge.renderers.mcp_renderer",
            "signature": null,
            "docstring": "# Summary\n\nMCP renderer implementation.\n\nThis module defines the `MCPRenderer` class, which generates documentation\nresources compatible with the Model Context Protocol (MCP).",
            "members": {
              "DocObject": {
                "name": "DocObject",
                "kind": "class",
                "path": "docforge.renderers.mcp_renderer.DocObject",
                "signature": "DocObject(name: str, kind: str, path: str, signature: str | None = None, docstring: str | None = None)",
                "docstring": "Representation of a documented Python object.\n\nA `DocObject` models a single Python entity discovered during\nintrospection. Objects may contain nested members, allowing the structure\nof modules, classes, and other containers to be represented recursively.\n\nAttributes:\n    name (str):\n        Local name of the object.\n\n    kind (str):\n        Type of object (for example `class`, `function`, `method`, or `attribute`).\n\n    path (str):\n        Fully qualified dotted path to the object.\n\n    signature (str | None):\n        Callable signature if the object represents a callable.\n\n    docstring (str | None):\n        Raw docstring text extracted from the source code.\n\n    members (dict[str, DocObject]):\n        Mapping of member names to child `DocObject` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.DocObject.name",
                    "signature": null,
                    "docstring": null
                  },
                  "kind": {
                    "name": "kind",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.DocObject.kind",
                    "signature": null,
                    "docstring": null
                  },
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.DocObject.path",
                    "signature": null,
                    "docstring": null
                  },
                  "signature": {
                    "name": "signature",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.DocObject.signature",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.DocObject.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.DocObject.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_member": {
                    "name": "add_member",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.DocObject.add_member",
                    "signature": "add_member(obj: DocObject)",
                    "docstring": "Add a child documentation object.\n\nThis is typically used when attaching methods to classes or\nnested objects to their parent containers.\n\nArgs:\n    obj (DocObject):\n        Documentation object to add as a member."
                  },
                  "get_member": {
                    "name": "get_member",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.DocObject.get_member",
                    "signature": "get_member(name: str)",
                    "docstring": "Retrieve a member object by name.\n\nArgs:\n    name (str):\n        Name of the member to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If the member does not exist."
                  },
                  "get_all_members": {
                    "name": "get_all_members",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.DocObject.get_all_members",
                    "signature": "get_all_members()",
                    "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
                  }
                }
              },
              "Module": {
                "name": "Module",
                "kind": "class",
                "path": "docforge.renderers.mcp_renderer.Module",
                "signature": "Module(path: str, docstring: str | None = None)",
                "docstring": "Representation of a documented Python module or package.\n\nA `Module` stores metadata about the module itself and maintains a\ncollection of top-level documentation objects discovered during\nintrospection.\n\nAttributes:\n    path (str):\n        Dotted import path of the module.\n\n    docstring (str | None):\n        Module-level documentation string, if present.\n\n    members (dict[str, DocObject]):\n        Mapping of object names to their corresponding `DocObject` representations.",
                "members": {
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.Module.path",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.Module.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.Module.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_object": {
                    "name": "add_object",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.Module.add_object",
                    "signature": "add_object(obj: DocObject)",
                    "docstring": "Add a documented object to the module.\n\nArgs:\n    obj (DocObject):\n        Documentation object to register as a top-level member of the module."
                  },
                  "get_object": {
                    "name": "get_object",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.Module.get_object",
                    "signature": "get_object(name: str)",
                    "docstring": "Retrieve a documented object by name.\n\nArgs:\n    name (str):\n        Name of the object to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If no object with the given name exists."
                  },
                  "get_all_objects": {
                    "name": "get_all_objects",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.Module.get_all_objects",
                    "signature": "get_all_objects()",
                    "docstring": "Return all top-level documentation objects in the module.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing the module's public members."
                  }
                }
              },
              "Project": {
                "name": "Project",
                "kind": "class",
                "path": "docforge.renderers.mcp_renderer.Project",
                "signature": "Project(name: str)",
                "docstring": "Representation of a documentation project.\n\nA `Project` serves as the root container for all modules discovered during\nintrospection. Each module is stored by its dotted import path.\n\nAttributes:\n    name (str):\n        Name of the project.\n\n    modules (dict[str, Module]):\n        Mapping of module paths to `Module` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.Project.name",
                    "signature": null,
                    "docstring": null
                  },
                  "modules": {
                    "name": "modules",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.Project.modules",
                    "signature": null,
                    "docstring": null
                  },
                  "add_module": {
                    "name": "add_module",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.Project.add_module",
                    "signature": "add_module(module: Module)",
                    "docstring": "Register a module in the project.\n\nArgs:\n    module (Module):\n        Module instance to add to the project."
                  },
                  "get_module": {
                    "name": "get_module",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.Project.get_module",
                    "signature": "get_module(path: str)",
                    "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path (str):\n        Fully qualified dotted module path (for example `pkg.module`).\n\nReturns:\n    Module:\n        The corresponding `Module` instance.\n\nRaises:\n    KeyError:\n        If the module does not exist in the project."
                  },
                  "get_all_modules": {
                    "name": "get_all_modules",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.Project.get_all_modules",
                    "signature": "get_all_modules()",
                    "docstring": "Return all modules contained in the project.\n\nReturns:\n    Iterable[Module]:\n        An iterable of `Module` instances."
                  },
                  "get_module_list": {
                    "name": "get_module_list",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.Project.get_module_list",
                    "signature": "get_module_list()",
                    "docstring": "Return the list of module import paths.\n\nReturns:\n    list[str]:\n        A list containing the dotted paths of all modules in the project."
                  }
                }
              },
              "MCPRenderer": {
                "name": "MCPRenderer",
                "kind": "class",
                "path": "docforge.renderers.mcp_renderer.MCPRenderer",
                "signature": null,
                "docstring": "Renderer that generates MCP-compatible documentation resources.\n\nThis renderer converts doc-forge project models into structured JSON\nresources suitable for consumption by systems implementing the Model\nContext Protocol (MCP).",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.renderers.mcp_renderer.MCPRenderer.name",
                    "signature": null,
                    "docstring": null
                  },
                  "generate_sources": {
                    "name": "generate_sources",
                    "kind": "function",
                    "path": "docforge.renderers.mcp_renderer.MCPRenderer.generate_sources",
                    "signature": "generate_sources(project: Project, out_dir: Path) -> None",
                    "docstring": "Generate MCP documentation resources for a project.\n\nThe renderer serializes each module into a JSON resource and produces\nsupporting metadata files such as `nav.json` and `index.json`.\n\nArgs:\n    project (Project):\n        Documentation project model to render.\n\n    out_dir (Path):\n        Directory where MCP resources will be written."
                  }
                }
              }
            }
          },
          "mkdocs_renderer": {
            "name": "mkdocs_renderer",
            "kind": "module",
            "path": "docforge.renderers.mkdocs_renderer",
            "signature": null,
            "docstring": "# Summary\n\nMkDocs renderer implementation.\n\nThis module defines the `MkDocsRenderer` class, which generates Markdown\ndocumentation sources compatible with MkDocs Material and the mkdocstrings\nplugin.\n\nThe renderer ensures a consistent documentation structure by:\n\n- Creating a root `index.md` if one does not exist\n- Generating package index pages automatically\n- Linking child modules within parent package pages\n- Optionally generating `README.md` from the root package docstring",
            "members": {
              "Module": {
                "name": "Module",
                "kind": "class",
                "path": "docforge.renderers.mkdocs_renderer.Module",
                "signature": "Module(path: str, docstring: str | None = None)",
                "docstring": "Representation of a documented Python module or package.\n\nA `Module` stores metadata about the module itself and maintains a\ncollection of top-level documentation objects discovered during\nintrospection.\n\nAttributes:\n    path (str):\n        Dotted import path of the module.\n\n    docstring (str | None):\n        Module-level documentation string, if present.\n\n    members (dict[str, DocObject]):\n        Mapping of object names to their corresponding `DocObject` representations.",
                "members": {
                  "path": {
                    "name": "path",
                    "kind": "attribute",
                    "path": "docforge.renderers.mkdocs_renderer.Module.path",
                    "signature": null,
                    "docstring": null
                  },
                  "docstring": {
                    "name": "docstring",
                    "kind": "attribute",
                    "path": "docforge.renderers.mkdocs_renderer.Module.docstring",
                    "signature": null,
                    "docstring": null
                  },
                  "members": {
                    "name": "members",
                    "kind": "attribute",
                    "path": "docforge.renderers.mkdocs_renderer.Module.members",
                    "signature": null,
                    "docstring": null
                  },
                  "add_object": {
                    "name": "add_object",
                    "kind": "function",
                    "path": "docforge.renderers.mkdocs_renderer.Module.add_object",
                    "signature": "add_object(obj: DocObject)",
                    "docstring": "Add a documented object to the module.\n\nArgs:\n    obj (DocObject):\n        Documentation object to register as a top-level member of the module."
                  },
                  "get_object": {
                    "name": "get_object",
                    "kind": "function",
                    "path": "docforge.renderers.mkdocs_renderer.Module.get_object",
                    "signature": "get_object(name: str)",
                    "docstring": "Retrieve a documented object by name.\n\nArgs:\n    name (str):\n        Name of the object to retrieve.\n\nReturns:\n    DocObject:\n        The corresponding `DocObject` instance.\n\nRaises:\n    KeyError:\n        If no object with the given name exists."
                  },
                  "get_all_objects": {
                    "name": "get_all_objects",
                    "kind": "function",
                    "path": "docforge.renderers.mkdocs_renderer.Module.get_all_objects",
                    "signature": "get_all_objects()",
                    "docstring": "Return all top-level documentation objects in the module.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing the module's public members."
                  }
                }
              },
              "Project": {
                "name": "Project",
                "kind": "class",
                "path": "docforge.renderers.mkdocs_renderer.Project",
                "signature": "Project(name: str)",
                "docstring": "Representation of a documentation project.\n\nA `Project` serves as the root container for all modules discovered during\nintrospection. Each module is stored by its dotted import path.\n\nAttributes:\n    name (str):\n        Name of the project.\n\n    modules (dict[str, Module]):\n        Mapping of module paths to `Module` instances.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.renderers.mkdocs_renderer.Project.name",
                    "signature": null,
                    "docstring": null
                  },
                  "modules": {
                    "name": "modules",
                    "kind": "attribute",
                    "path": "docforge.renderers.mkdocs_renderer.Project.modules",
                    "signature": null,
                    "docstring": null
                  },
                  "add_module": {
                    "name": "add_module",
                    "kind": "function",
                    "path": "docforge.renderers.mkdocs_renderer.Project.add_module",
                    "signature": "add_module(module: Module)",
                    "docstring": "Register a module in the project.\n\nArgs:\n    module (Module):\n        Module instance to add to the project."
                  },
                  "get_module": {
                    "name": "get_module",
                    "kind": "function",
                    "path": "docforge.renderers.mkdocs_renderer.Project.get_module",
                    "signature": "get_module(path: str)",
                    "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path (str):\n        Fully qualified dotted module path (for example `pkg.module`).\n\nReturns:\n    Module:\n        The corresponding `Module` instance.\n\nRaises:\n    KeyError:\n        If the module does not exist in the project."
                  },
                  "get_all_modules": {
                    "name": "get_all_modules",
                    "kind": "function",
                    "path": "docforge.renderers.mkdocs_renderer.Project.get_all_modules",
                    "signature": "get_all_modules()",
                    "docstring": "Return all modules contained in the project.\n\nReturns:\n    Iterable[Module]:\n        An iterable of `Module` instances."
                  },
                  "get_module_list": {
                    "name": "get_module_list",
                    "kind": "function",
                    "path": "docforge.renderers.mkdocs_renderer.Project.get_module_list",
                    "signature": "get_module_list()",
                    "docstring": "Return the list of module import paths.\n\nReturns:\n    list[str]:\n        A list containing the dotted paths of all modules in the project."
                  }
                }
              },
              "MkDocsRenderer": {
                "name": "MkDocsRenderer",
                "kind": "class",
                "path": "docforge.renderers.mkdocs_renderer.MkDocsRenderer",
                "signature": null,
                "docstring": "Renderer that produces Markdown documentation for MkDocs.\n\nGenerated pages use mkdocstrings directives to reference Python modules,\nallowing MkDocs to render API documentation dynamically.",
                "members": {
                  "name": {
                    "name": "name",
                    "kind": "attribute",
                    "path": "docforge.renderers.mkdocs_renderer.MkDocsRenderer.name",
                    "signature": null,
                    "docstring": null
                  },
                  "generate_sources": {
                    "name": "generate_sources",
                    "kind": "function",
                    "path": "docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_sources",
                    "signature": "generate_sources(project: Project, out_dir: Path, module_is_source: bool | None = None) -> None",
                    "docstring": "Generate Markdown documentation files for a project.\n\nThis method renders a documentation structure from the provided\nproject model and writes the resulting Markdown files to the\nspecified output directory.\n\nArgs:\n    project (Project):\n        Project model containing modules to document.\n\n    out_dir (Path):\n        Directory where generated Markdown files will be written.\n\n    module_is_source (bool | None):\n        If True, treat the specified module as the documentation root\n        rather than nesting it inside a folder."
                  },
                  "generate_readme": {
                    "name": "generate_readme",
                    "kind": "function",
                    "path": "docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_readme",
                    "signature": "generate_readme(project: Project, docs_dir: Path, module_is_source: bool | None = None, readme_dir: Path | None = None) -> None",
                    "docstring": "Generate a `README.md` file from the root module docstring.\n\nNotes:\n    - If `module_is_source` is True, `README.md` is written to the\n      project root directory.\n    - If False, README generation is currently not implemented.\n\nArgs:\n    project (Project):\n        Project model containing documentation metadata.\n\n    docs_dir (Path):\n        Directory containing generated documentation sources.\n\n    module_is_source (bool | None):\n        Whether the module is treated as the project source root.\n\n    readme_dir (Path | None):\n        Directory where the generated README.md should be written.\n        Defaults to the parent of `docs_dir`."
                  }
                }
              }
            }
          }
        }
      },
      "servers": {
        "name": "servers",
        "kind": "module",
        "path": "docforge.servers",
        "signature": null,
        "docstring": "# Summary\n\nServer layer for doc-forge.\n\nThis module exposes server implementations used to provide live access\nto generated documentation resources. Currently, it includes the MCP\ndocumentation server.\n\n---",
        "members": {
          "MCPServer": {
            "name": "MCPServer",
            "kind": "class",
            "path": "docforge.servers.MCPServer",
            "signature": "MCPServer(mcp_root: Path, name: str)",
            "docstring": "MCP server for serving a pre-generated documentation bundle.\n\nThe server exposes documentation resources and diagnostic tools through\nMCP endpoints backed by JSON files generated by the MCP renderer.\n\nAttributes:\n    mcp_root (Path):\n        Directory containing the generated MCP documentation bundle.\n\n    app (FastMCP):\n        Underlying FastMCP application instance that registers resources\n        and tools.",
            "members": {
              "mcp_root": {
                "name": "mcp_root",
                "kind": "attribute",
                "path": "docforge.servers.MCPServer.mcp_root",
                "signature": null,
                "docstring": null
              },
              "app": {
                "name": "app",
                "kind": "attribute",
                "path": "docforge.servers.MCPServer.app",
                "signature": null,
                "docstring": null
              },
              "run": {
                "name": "run",
                "kind": "function",
                "path": "docforge.servers.MCPServer.run",
                "signature": "run(transport: Literal['stdio', 'sse', 'streamable-http'] = 'streamable-http')",
                "docstring": "Start the MCP server.\n\nArgs:\n    transport (Literal[\"stdio\", \"sse\", \"streamable-http\"]):\n        Transport mechanism used by the MCP server. Supported options\n        include `stdio`, `sse`, and `streamable-http`."
              }
            }
          },
          "mcp_server": {
            "name": "mcp_server",
            "kind": "module",
            "path": "docforge.servers.mcp_server",
            "signature": null,
            "docstring": "# Summary\n\nMCP server implementation.\n\nThis module defines the `MCPServer` class, which serves pre-generated\ndocumentation bundles through the Model Context Protocol (MCP).\n\n---\n\nNotes:\n    - The served bundle is generated offline by `MCPRenderer`.\n    - Missing resources are reported as structured error dictionaries rather\n      than raising exceptions.\n    - The server exposes read-only resources and a single health-check tool.\n\n---",
            "members": {
              "MCPServer": {
                "name": "MCPServer",
                "kind": "class",
                "path": "docforge.servers.mcp_server.MCPServer",
                "signature": "MCPServer(mcp_root: Path, name: str)",
                "docstring": "MCP server for serving a pre-generated documentation bundle.\n\nThe server exposes documentation resources and diagnostic tools through\nMCP endpoints backed by JSON files generated by the MCP renderer.\n\nAttributes:\n    mcp_root (Path):\n        Directory containing the generated MCP documentation bundle.\n\n    app (FastMCP):\n        Underlying FastMCP application instance that registers resources\n        and tools.",
                "members": {
                  "mcp_root": {
                    "name": "mcp_root",
                    "kind": "attribute",
                    "path": "docforge.servers.mcp_server.MCPServer.mcp_root",
                    "signature": null,
                    "docstring": null
                  },
                  "app": {
                    "name": "app",
                    "kind": "attribute",
                    "path": "docforge.servers.mcp_server.MCPServer.app",
                    "signature": null,
                    "docstring": null
                  },
                  "run": {
                    "name": "run",
                    "kind": "function",
                    "path": "docforge.servers.mcp_server.MCPServer.run",
                    "signature": "run(transport: Literal['stdio', 'sse', 'streamable-http'] = 'streamable-http') -> None",
                    "docstring": "Start the MCP server.\n\nArgs:\n    transport (Literal[\"stdio\", \"sse\", \"streamable-http\"]):\n        Transport mechanism used by the MCP server. Supported options\n        include `stdio`, `sse`, and `streamable-http`."
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}