updated docs strings and added README.md

# Improve documentation look & feel via MkDocs Material template enhancements

## Summary

This MR improves the overall **documentation experience and visual presentation** of the doc-forge docs by enhancing the MkDocs Material template configuration.

The changes focus on **navigation usability, code readability, and richer Markdown rendering**, resulting in a cleaner and more professional documentation site.

Docstring changes were made across the codebase for consistency, but this MR description focuses on the **template and presentation improvements**.

---

## Navigation Improvements

The navigation system has been enhanced to provide a clearer structure and better discoverability.

Key improvements include:

* Section-aware navigation in the sidebar
* Automatic expansion of module/package hierarchy
* Scroll tracking within the sidebar
* Clickable package index pages

Material navigation features added:

* `navigation.sections`
* `navigation.expand`
* `navigation.tracking`
* `navigation.indexes`

This results in a **single cohesive navigation tree** that exposes the entire documentation hierarchy from the sidebar.

---

## Code Block Improvements

Code blocks previously appeared relatively plain. The template now enables richer syntax highlighting and improved readability.

Enhancements include:

* Syntax highlighting using `pymdownx.highlight`
* Line numbers for code blocks
* Anchored line numbers for deep linking
* Improved fenced code block rendering

Additional Material features:

* `content.code.copy` — copy button for code blocks
* `content.code.annotate` — support for code annotations

These changes significantly improve the readability of examples and API snippets throughout the documentation.

---

## Markdown Rendering Enhancements

Additional Markdown extensions were enabled to support richer documentation features:

* `pymdownx.superfences` for advanced fenced blocks
* `pymdownx.inlinehilite` for inline code highlighting
* `pymdownx.snippets` for reusable snippets
* `admonition` and `pymdownx.details` for callouts and collapsible sections
* `pymdownx.tabbed` for tabbed content blocks
* `pymdownx.tasklist` for checklist-style items
* `tables`, `footnotes`, and advanced formatting extensions

These extensions make it easier to write expressive and structured documentation.

---

## Search Experience

The documentation search experience has been improved using Material search features:

* `search.highlight`
* `search.share`
* `search.suggest`

These enhancements provide:

* highlighted search matches
* sharable search URLs
* auto-suggestions while typing

---

## mkdocstrings Improvements

The mkdocstrings configuration has been expanded to produce clearer API documentation.

Notable improvements include:

* grouping objects by category
* explicit category headings
* improved symbol headings
* cleaner object path display

This results in more structured API documentation pages.

---

## Result

Overall, these changes provide:

* cleaner and more intuitive navigation
* significantly improved code presentation
* richer Markdown capabilities
* better search usability

The documentation now has a **more polished, modern appearance** and improved usability for both readers and contributors.

Reviewed-on: #5
Co-authored-by: Vishesh 'ironeagle' Bangotra <aetoskia@gmail.com>
Co-committed-by: Vishesh 'ironeagle' Bangotra <aetoskia@gmail.com>

.run/pytests.run.xml

@@ -1,5 +1,5 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="pytest" type="tests" factoryName="py.test">
+  <configuration default="false" name="pytests" type="tests" factoryName="py.test">
     <module name="docforge" />
     <option name="ENV_FILES" value="" />
     <option name="INTERPRETER_OPTIONS" value="" />

ADS.llm.md

@@ -1,327 +0,0 @@
-# doc-forge — Architecture & Design Specification
-
-**doc-forge** is a renderer-agnostic Python documentation compiler. It converts Python source code and docstrings into a structured, semantic documentation model and then emits multiple downstream representations, including:
-
-* Human-facing documentation sites (MkDocs, Sphinx)
-* Machine-facing documentation bundles (MCP JSON)
-* Live documentation APIs (MCP servers)
-
-This document is the **authoritative design and codebase specification** for the library. It is written to be both **LLM-friendly** and **developer-facing**, and should be treated as the canonical reference for implementation decisions.
-
----
-
-## 1. Design Goals
-
-1. **Single Source of Truth**
-   Python source code and docstrings are the only authoritative input.
-
-2. **Renderer Agnosticism**
-   MkDocs, Sphinx, MCP, or future renderers must not influence the core model.
-
-3. **Deterministic Output**
-   Given the same codebase, outputs must be reproducible.
-
-4. **AI-Native Documentation**
-   Documentation must be structured, queryable, and machine-consumable.
-
-5. **Library-First, CLI-Second**
-   All functionality must be accessible as a Python API. The CLI is a thin wrapper.
-
----
-
-## 2. Core Mental Model
-
-### Fundamental Abstraction
-
-> **The atomic unit of documentation is a Python import path**
-
-Examples:
-
-* `mail_intake`
-* `mail_intake.config`
-* `mail_intake.adapters.base`
-
-Files, Markdown, HTML, and JSON are *representations*, not documentation units.
-
----
-
-## 3. High-Level Architecture
-
-```
-Python Source Code
-        ↓
-Introspection Layer (Griffe)
-        ↓
-Documentation Model (doc-forge core)
-        ↓
-Renderer / Exporter Layer
-   ├── MkDocs
-   ├── Sphinx
-   ├── MCP (static JSON)
-   └── MCP Server (live)
-```
-
-Only the **Documentation Model** is shared across all outputs.
-
----
-
-## 4. Package Layout (Proposed)
-
-```
-docforge/
-├── __init__.py
-├── model/
-│   ├── project.py
-│   ├── module.py
-│   ├── object.py
-│   └── nav.py
-├── loader/
-│   └── griffe_loader.py
-├── renderers/
-│   ├── base.py
-│   ├── mkdocs.py
-│   └── sphinx.py
-├── exporters/
-│   └── mcp.py
-├── server/
-│   └── mcp_server.py
-├── cli/
-│   └── main.py
-└── utils/
-```
-
----
-
-## 5. Documentation Model (Core)
-
-The documentation model is renderer-neutral and must not contain any MkDocs-, Sphinx-, or MCP-specific logic.
-
-### 5.1 Project
-
-```python
-class Project:
-    name: str
-    version: str | None
-    modules: dict[str, Module]
-    nav: Navigation
-```
-
----
-
-### 5.2 Module
-
-```python
-class Module:
-    path: str                # import path
-    docstring: str | None
-    members: dict[str, DocObject]
-```
-
----
-
-### 5.3 DocObject
-
-Represents classes, functions, variables, etc.
-
-```python
-class DocObject:
-    name: str
-    kind: str                # class, function, attribute, module
-    path: str
-    signature: str | None
-    docstring: str | None
-    members: dict[str, DocObject]
-```
-
-Private members (`_name`) are excluded by default.
-
----
-
-### 5.4 Navigation
-
-```python
-class Navigation:
-    entries: list[NavEntry]
-
-class NavEntry:
-    title: str
-    module: str
-```
-
-Navigation is derived, not authored.
-
----
-
-## 6. Introspection Layer
-
-### 6.1 Griffe Loader
-
-Griffe is the **only supported introspection backend**.
-
-Responsibilities:
-
-* Load modules by import path
-* Resolve docstrings, signatures, and members
-* Tolerate alias resolution failures
-
-Output: fully populated `Project` and `Module` objects.
-
----
-
-## 7. Renderer Interface
-
-Renderers consume the documentation model and emit renderer-specific source trees.
-
-```python
-class DocRenderer(Protocol):
-    name: str
-
-    def generate_sources(self, project: Project, out_dir: Path) -> None:
-        """Generate renderer-specific source files."""
-
-    def build(self, config: RendererConfig) -> None:
-        """Build final artifacts (HTML, site, etc.)."""
-
-    def serve(self, config: RendererConfig) -> None:
-        """Serve documentation locally (optional)."""
-```
-
----
-
-## 8. MkDocs Renderer
-
-### Source Generation
-
-* Emits `.md` files
-* One file per module
-* Uses `mkdocstrings` directives exclusively
-
-```md
-# Config
-
-::: mail_intake.config
-```
-
-### Build
-
-* Uses `mkdocs.commands.build`
-
-### Serve
-
-* Uses `mkdocs.commands.serve`
-
-MkDocs-specific configuration lives outside the core model.
-
----
-
-## 9. Sphinx Renderer
-
-### Source Generation
-
-* Emits `.rst` files
-* Uses `autodoc` directives
-
-```rst
-mail_intake.config
-==================
-
-.. automodule:: mail_intake.config
-   :members:
-   :undoc-members:
-```
-
-### Build
-
-* Uses `sphinx.application.Sphinx` directly
-
-### Serve
-
-* Optional (static build is sufficient)
-
----
-
-## 10. MCP Exporter (Static)
-
-The MCP exporter bypasses renderers entirely.
-
-### Output Structure
-
-```
-mcp/
-├── index.json
-├── nav.json
-└── modules/
-    └── package.module.json
-```
-
-### Design Principles
-
-* Alias-safe
-* Deterministic
-* Fully self-contained
-* No Markdown, HTML, or templates
-
----
-
-## 11. MCP Server (Live)
-
-The MCP server exposes documentation as queryable resources.
-
-### Resources
-
-* `docs://index`
-* `docs://nav`
-* `docs://module/{module}`
-
-### Characteristics
-
-* Read-only
-* Stateless
-* Backed by MCP JSON bundle
-
----
-
-## 12. CLI Design
-
-The CLI is a thin orchestration layer.
-
-```bash
-doc-forge generate --renderer mkdocs
-doc-forge generate --renderer sphinx
-
-doc-forge build --renderer mkdocs
-doc-forge serve --renderer mkdocs
-
-doc-forge export mcp
-```
-
-Renderer choice never affects the core model.
-
----
-
-## 13. Explicit Non-Goals
-
-* Markdown authoring
-* Theme design
-* Runtime code execution
-* Code formatting or linting
-
----
-
-## 14. Invariants (Must Never Break)
-
-1. Import paths are canonical identifiers
-2. Core model contains no renderer logic
-3. MCP does not depend on MkDocs or Sphinx
-4. Renderers do not introspect Python directly
-5. All outputs trace back to the same model
-
----
-
-## 15. One-Line Definition
-
-> **doc-forge is a documentation compiler that turns Python code into structured knowledge and emits it through multiple human and machine interfaces.**
-
----
-
-*End of specification.*

README.md

@@ -1,244 +1,547 @@
-# doc-forge
+# docforge
 
-A renderer-agnostic Python documentation compiler that converts Python source code and docstrings into a structured, semantic documentation model and emits multiple downstream representations.
+# Summary
 
-## Features
+Renderer-agnostic Python documentation compiler that converts Python docstrings
+into structured documentation for both humans (MkDocs) and machines (MCP / AI agents).
 
-- **Single Source of Truth**: Python source code and docstrings are the only authoritative input
-- **Renderer Agnosticism**: MkDocs, Sphinx, MCP, or future renderers don't influence the core model
-- **Deterministic Output**: Given the same codebase, outputs are reproducible
-- **AI-Native Documentation**: Structured, queryable, and machine-consumable
-- **Library-First Design**: All functionality accessible as a Python API
+`doc-forge` statically analyzes source code, builds a semantic model of modules,
+classes, functions, and attributes, and renders that model into documentation
+outputs without executing user code.
 
-## Installation
+---
+
+# Installation
+
+Install using pip:
 
 ```bash
 pip install doc-forge
 ```
 
-### Optional Dependencies
+---
+
+# CLI usage
+
+## Generate an MkDocs site from a Python package:
 
 ```bash
-# For MkDocs rendering
-pip install doc-forge[mkdocs]
-
-# For Sphinx rendering  
-pip install doc-forge[sphinx]
-
-# For MCP support
-pip install doc-forge[mcp]
-
-# For development
-pip install doc-forge[dev]
+doc-forge build --mkdocs --module my_package
 ```
 
-## Quick Start
-
-### Command Line Interface
+## Generate MCP JSON documentation:
 
 ```bash
-# Generate MkDocs documentation
-doc-forge generate --renderer mkdocs mypackage
-
-# Build final HTML documentation
-doc-forge build --renderer mkdocs mypackage
-
-# Serve documentation locally
-doc-forge serve --renderer mkdocs mypackage
-
-# Export to MCP format
-doc-forge export mypackage
-
-# Start live MCP server
-doc-forge server mypackage
+doc-forge build --mcp --module my_package
 ```
 
-### Python API
 
-```python
-from docforge.loaders import GriffeLoader
-from docforge.renderers import MkDocsRenderer
-from pathlib import Path
-
-# Load your project
-loader = GriffeLoader()
-project = loader.load_project(["mypackage", "mypackage.utils"])
-
-# Generate MkDocs sources
-renderer = MkDocsRenderer()
-renderer.generate_sources(project, Path("docs"))
-
-# Build final documentation
-from docforge.renderers.base import RendererConfig
-
-config = RendererConfig(Path("docs"), project)
-renderer.build(config)
-```
-
-## Architecture
-
-doc-forge follows this high-level architecture:
-
-```
-Python Source Code
-        ↓
-Introspection Layer (Griffe)
-        ↓
-Documentation Model (doc-forge core)
-        ↓
-Renderer / Exporter Layer
-   ├── MkDocs
-   ├── Sphinx
-   ├── MCP (static JSON)
-   └── MCP Server (live)
-```
-
-## Core Components
-
-### Documentation Model
-
-- **Project**: Root container for all documentation
-- **Module**: Represents Python modules
-- **DocObject**: Base class for classes, functions, variables, etc.
-- **Navigation**: Hierarchical structure for browsing
-
-### Renderers
-
-- **MkDocs Renderer**: Generates Markdown with mkdocstrings directives
-- **Sphinx Renderer**: Generates reStructuredText with autodoc directives
-
-### Exporters
-
-- **MCP Exporter**: Creates static JSON bundles for machine consumption
-- **MCP Server**: Live server for real-time documentation access
-
-## CLI Commands
-
-### `generate`
-Generate renderer-specific source files without building final artifacts.
+## Generate MkDocs site and MCP JSON documentation:
 
 ```bash
-doc-forge generate --renderer mkdocs --out-dir docs mypackage
+doc-forge build --mcp --mkdocs --module my_package
 ```
 
-### `build`
-Build final documentation artifacts (HTML, etc.).
+## Serve MkDocs locally:
 
 ```bash
-doc-forge build --renderer sphinx mypackage
+doc-forge serve --mkdocs --module my_package
 ```
 
-### `serve`
-Start a local development server.
+## Serve MCP locally:
 
 ```bash
-doc-forge serve --renderer mkdocs --port 9000 mypackage
+doc-forge serve --mcp --module my_package
 ```
 
-### `export`
-Export to MCP format for machine consumption.
-
-```bash
-doc-forge export --out-dir mcp mypackage
-```
-
-### `server`
-Start live MCP server for real-time access.
-
-```bash
-doc-forge server --host 0.0.0.0 --port 8080 mypackage
-```
-
-## Configuration
-
-doc-forge is designed to work with minimal configuration. Most settings are derived automatically from your Python code structure.
-
-### MkDocs Configuration
-
-The MkDocs renderer automatically generates `mkdocs.yml` with sensible defaults:
-
-```yaml
-site_name: Your Project
-plugins:
-  - mkdocstrings
-theme:
-  name: material
-```
-
-### Sphinx Configuration
-
-The Sphinx renderer automatically generates `conf.py` with standard extensions:
-
-```python
-extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.viewcode', 
-    'sphinx.ext.napoleon',
-]
-```
-
-## MCP Integration
-
-doc-forge provides two ways to integrate with MCP (Model Context Protocol):
-
-### Static Export
-```bash
-doc-forge export mypackage
-```
-Creates a static JSON bundle in `mcp/` directory that can be loaded by MCP clients.
-
-### Live Server
-```bash
-doc-forge server mypackage
-```
-Starts a live MCP server providing real-time access to documentation resources:
-
-- `docs://index` - Project metadata
-- `docs://nav` - Navigation structure
-- `docs://module/{module}` - Individual module data
-
-## Development
-
-### Setup
-
-```bash
-git clone https://github.com/doc-forge/doc-forge
-cd doc-forge
-pip install -e ".[dev]"
-```
-
-### Running Tests
-
-```bash
-pytest
-```
-
-### Code Quality
-
-```bash
-black docforge/
-ruff check docforge/
-mypy docforge/
-```
-
-## License
-
-MIT License - see LICENSE file for details.
-
-## Contributing
-
-Contributions are welcome! Please see CONTRIBUTING.md for guidelines.
-
-## Philosophy
-
-doc-forge is built on these core principles:
-
-1. **Single Source of Truth**: Python source code and docstrings are the only authoritative input
-2. **Renderer Agnosticism**: The core model contains no renderer-specific logic
-3. **Deterministic Output**: Same input always produces same output
-4. **AI-Native Documentation**: Documentation must be structured, queryable, and machine-consumable
-5. **Library-First**: All functionality must be accessible as a Python API
-
 ---
 
-*doc-forge turns Python code into structured knowledge and emits it through multiple human and machine interfaces.*
+# Core concepts
+
+## Loader
+Extracts symbols, signatures, and docstrings using static analysis.
+
+## Semantic model
+Structured, renderer-agnostic representation of the API.
+
+## Renderer
+Converts the semantic model into output formats such as MkDocs or MCP JSON.
+
+## Symbol
+Any documentable object
+
+- module
+- class
+- function
+- method
+- property
+- attribute
+
+---
+
+# Architecture
+
+`doc-forge` follows a compiler architecture:
+
+## Front-end:
+
+Static analysis of modules, classes, functions, type hints, and docstrings.
+
+## Middle-end:
+
+Builds a semantic model describing symbols and relationships.
+
+## Back-end:
+
+Renders documentation using interchangeable renderers.
+
+This architecture ensures deterministic documentation generation.
+
+---
+
+# Rendering pipeline
+
+Typical flow:
+
+    Python package
+        |
+    Loader (static analysis)
+        |
+    Semantic model
+        |
+    Renderer
+        |
+    MkDocs site or MCP JSON
+
+---
+
+# Google-Styled Doc-Forge Convention (GSDFC)
+
+GSDFC defines how docstrings must be written so they render correctly in MkDocs and remain machine-parsable by doc-forge and AI tooling.
+
+- Docstrings are the single source of truth.
+- `doc-forge` compiles docstrings but does not generate documentation content.
+- Documentation follows the Python import hierarchy.
+- Every public symbol should have a complete and accurate docstring.
+
+---
+
+## General rules
+
+- Use **Markdown headings** at package and module level.
+- Use **Google-style structured sections** at class, function, and method level.
+- Use type hints in signatures instead of duplicating types in prose.
+- Write summaries in imperative form.
+- Sections are separated by `---`
+
+---
+
+# Notes subsection grouping
+
+Group related information using labeled subsections.
+
+Example:
+
+    Notes:
+        **Guarantees:**
+
+            - deterministic behavior
+
+        **Lifecycle:**
+
+            - created during initialization
+            - reused across executions
+
+        **Thread safety:**
+
+            - safe for concurrent reads
+
+---
+
+# Example formatting
+
+- Use indentation for examples.
+- Indent section contents using four spaces.
+- Use code blocks for example code.
+
+Example:
+    Single example:
+
+        Example:
+
+            ```python
+            foo = Foo("example")
+            process(foo, multiplier=2)
+            ```
+
+    Multiple examples:
+
+        Example:
+            Create foo:
+
+                ```python
+                foo = Foo("example")
+                ```
+
+            Run engine:
+
+                ```python
+                engine = BarEngine([foo])
+                engine.run()
+                ```
+
+Avoid fenced code blocks inside structured sections.
+
+---
+
+# Separator rules
+
+Use horizontal separators only at docstring root level to separate sections:
+
+```markdown
+---
+```
+
+Allowed locations:
+
+- package docstrings
+- module docstrings
+- major documentation sections
+
+Do not use separators inside code sections.
+
+---
+
+# Package docstrings
+
+Package docstrings act as the documentation home page.
+
+Recommended sections:
+
+    # Summary
+    # Installation
+    # Quick start
+    # CLI usage
+    # Core concepts
+    # Architecture
+    # Rendering pipeline
+    # Examples
+    # Notes
+
+Example:
+    Package Doc String:
+
+        '''
+        # Summary
+
+        Foo-bar processing framework.
+
+        Provides tools for defining Foo objects and executing Bar pipelines.
+
+        ---
+
+        # Installation
+
+        ```bash
+        pip install foo-bar
+        ```
+
+        ---
+
+        # Quick start
+
+        ```python
+        from foobar import Foo, BarEngine
+
+        foo = Foo("example")
+        engine = BarEngine([foo])
+
+        result = engine.run()
+        ```
+
+        ---
+        '''
+
+---
+
+# Module docstrings
+
+Module docstrings describe a subsystem.
+
+Recommended sections:
+
+    # Summary
+    # Examples
+    # Notes
+
+Example:
+    Module Doc String:
+
+        '''
+        # Summary
+
+        Foo execution subsystem.
+
+        Provides utilities for executing Foo objects through Bar stages.
+
+        ---
+
+        Example:
+
+            ```python
+            from foobar.engine import BarEngine
+            from foobar.foo import Foo
+
+            foo = Foo("example")
+
+            engine = BarEngine([foo])
+            engine.run()
+            ```
+
+        ---
+        '''
+
+---
+
+# Class docstrings
+
+Class docstrings define object responsibility, lifecycle, and attributes.
+
+Recommended sections:
+
+    Attributes:
+    Notes:
+    Example:
+    Raises:
+
+Example:
+    Simple Foo:
+
+    ```python
+    class Foo:
+        '''
+        Represents a unit of work.
+
+        Attributes:
+            name (str):
+                Identifier of the foo instance.
+
+            value (int):
+                Numeric value associated with foo.
+
+        Notes:
+            Guarantees:
+
+                - instances are immutable after creation
+
+            Lifecycle:
+
+                - create instance
+                - pass to processing engine
+
+        Example:
+            Create and inspect a Foo:
+
+                ```python
+                foo = Foo("example", value=42)
+                print(foo.name)
+                ```
+        '''
+    ```
+
+    Complex Bar:
+
+    ```python
+    class BarEngine:
+        '''
+        Executes Foo objects through Bar stages.
+
+        Attributes:
+            foos (tuple[Foo, ...]):
+                Foo instances managed by the engine.
+
+        Notes:
+            Guarantees:
+
+                - deterministic execution order
+
+        Example:
+            Run engine:
+
+                ```python
+                foo1 = Foo("a")
+                foo2 = Foo("b")
+
+                engine = BarEngine([foo1, foo2])
+                engine.run()
+                ```
+        '''
+    ```
+
+---
+
+# Function and method docstrings
+
+Function docstrings define API contracts.
+
+Recommended sections:
+
+    Args:
+    Returns:
+    Raises:
+    Yields:
+    Notes:
+    Example:
+
+Example:
+    Simple process method:
+
+    ```python
+    def process(foo: Foo, multiplier: int) -> int:
+        '''
+        Process a Foo instance.
+
+        Args:
+            foo (Foo):
+                Foo instance to process.
+
+            multiplier (int):
+                Value used to scale foo.
+
+        Returns:
+            int:
+                Processed result.
+
+        Raises:
+            ValueError:
+                If multiplier is negative.
+
+        Notes:
+            Guarantees:
+
+                - foo is not modified
+
+        Example:
+            Process foo:
+
+                ```python
+                foo = Foo("example", value=10)
+
+                result = process(foo, multiplier=2)
+                print(result)
+                ```
+        '''
+    ```
+
+    Multiple Examples:
+
+    ```python
+    def combine(foo_a: Foo, foo_b: Foo) -> Foo:
+        '''
+        Combine two Foo instances.
+
+        Args:
+            foo_a (Foo):
+                First foo.
+
+            foo_b (Foo):
+                Second foo.
+
+        Returns:
+            Foo:
+                Combined foo.
+
+        Example:
+            Basic usage:
+
+                ```python
+                foo1 = Foo("a")
+                foo2 = Foo("b")
+
+                combined = combine(foo1, foo2)
+                ```
+
+            Pipeline usage:
+
+                ```python
+                engine = BarEngine([foo1, foo2])
+                engine.run()
+                ```
+        '''
+    ```
+
+---
+
+# Property docstrings
+
+Properties must document return values.
+
+Example:
+    Property Doc String:
+
+        ```python
+        @property
+        def foos(self) -> tuple[Foo, ...]:
+            '''
+            Return contained Foo instances.
+
+            Returns:
+                tuple[Foo, ...]:
+                    Stored foo objects.
+
+            Example:
+                ```python
+                container = FooContainer()
+
+                foos = container.foos
+                ```
+            '''
+        ```
+
+---
+
+# Attribute documentation
+
+Document attributes in class docstrings using `Attributes:`.
+
+Example:
+    Attribute Doc String:
+
+        ```python
+        '''
+        Represents a processing stage.
+
+        Attributes:
+            id (str):
+                Unique identifier.
+
+            enabled (bool):
+                Whether the stage is active.
+        '''
+        ```
+
+---
+
+# Parsing guarantees
+
+GSDFC ensures doc-forge can deterministically extract:
+
+- symbol kind (module, class, function, property, attribute)
+- symbol name
+- parameters
+- return values
+- attributes
+- examples
+- structured Notes subsections
+
+This enables:
+
+- reliable MkDocs rendering
+- deterministic MCP export
+- accurate AI semantic interpretation
+
+---
+
+Notes:
+    - doc-forge never executes analyzed modules.
+    - Documentation is generated entirely through static analysis.

docforge.nav.yml

@@ -1,24 +1,26 @@
-home: docforge/index.md
+home: index.md
 groups:
   Loaders:
-    - docforge/loaders/index.md
-    - docforge/loaders/griffe_loader.md
+    - loaders/index.md
+    - loaders/griffe_loader.md
   Models:
-    - docforge/models/index.md
-    - docforge/models/module.md
-    - docforge/models/object.md
-    - docforge/models/project.md
+    - models/index.md
+    - models/module.md
+    - models/object.md
+    - models/project.md
   Navigation:
-    - docforge/nav/index.md
-    - docforge/nav/spec.md
-    - docforge/nav/resolver.md
-    - docforge/nav/mkdocs.md
+    - nav/index.md
+    - nav/spec.md
+    - nav/resolver.md
+    - nav/mkdocs.md
   Renderers:
-    - docforge/renderers/index.md
-    - docforge/renderers/base.md
-    - docforge/renderers/mkdocs_renderer.md
-    - docforge/renderers/mcp_renderer.md
+    - renderers/index.md
+    - renderers/base.md
+    - renderers/mkdocs_renderer.md
+    - renderers/mcp_renderer.md
   CLI:
-    - docforge/cli/index.md
-    - docforge/cli/main.md
-    - docforge/cli/mkdocs.md
+    - cli/index.md
+    - cli/main.md
+    - cli/commands.md
+    - cli/mcp_utils.md
+    - cli/mkdocs_utils.md

docforge/__init__.py

@@ -1,54 +1,549 @@
 """
-# doc-forge
+# Summary
 
-`doc-forge` is a renderer-agnostic Python documentation compiler designed for
-speed, flexibility, and beautiful output. It decouples the introspection of
-your code from the rendering process, allowing you to generate documentation
-for various platforms (starting with MkDocs) from a single internal models.
+Renderer-agnostic Python documentation compiler that converts Python docstrings
+into structured documentation for both humans (MkDocs) and machines (MCP / AI agents).
 
-## Installation
+`doc-forge` statically analyzes source code, builds a semantic model of modules,
+classes, functions, and attributes, and renders that model into documentation
+outputs without executing user code.
 
-Install using `pip` with the optional `mkdocs` dependencies for a complete setup:
+---
+
+# Installation
+
+Install using pip:
 
 ```bash
 pip install doc-forge
 ```
 
-## Quick Start
+---
 
-1.  **Generate Markdown Sources**:
-    Introspect your package and create ready-to-use Markdown files:
-    ```bash
-    doc-forge generate --module my_package --docs-dir docs
+# CLI usage
+
+## Generate an MkDocs site from a Python package:
+
+```bash
+doc-forge build --mkdocs --module my_package
+```
+
+## Generate MCP JSON documentation:
+
+```bash
+doc-forge build --mcp --module my_package
+```
+
+
+## Generate MkDocs site and MCP JSON documentation:
+
+```bash
+doc-forge build --mcp --mkdocs --module my_package
+```
+
+## Serve MkDocs locally:
+
+```bash
+doc-forge serve --mkdocs --module my_package
+```
+
+## Serve MCP locally:
+
+```bash
+doc-forge serve --mcp --module my_package
+```
+
+---
+
+# Core concepts
+
+## Loader
+Extracts symbols, signatures, and docstrings using static analysis.
+
+## Semantic model
+Structured, renderer-agnostic representation of the API.
+
+## Renderer
+Converts the semantic model into output formats such as MkDocs or MCP JSON.
+
+## Symbol
+Any documentable object
+
+- module
+- class
+- function
+- method
+- property
+- attribute
+
+---
+
+# Architecture
+
+`doc-forge` follows a compiler architecture:
+
+## Front-end:
+
+Static analysis of modules, classes, functions, type hints, and docstrings.
+
+## Middle-end:
+
+Builds a semantic model describing symbols and relationships.
+
+## Back-end:
+
+Renders documentation using interchangeable renderers.
+
+This architecture ensures deterministic documentation generation.
+
+---
+
+# Rendering pipeline
+
+Typical flow:
+
+    Python package
+        |
+    Loader (static analysis)
+        |
+    Semantic model
+        |
+    Renderer
+        |
+    MkDocs site or MCP JSON
+
+---
+
+# Google-Styled Doc-Forge Convention (GSDFC)
+
+GSDFC defines how docstrings must be written so they render correctly in MkDocs and remain machine-parsable by doc-forge and AI tooling.
+
+- Docstrings are the single source of truth.
+- `doc-forge` compiles docstrings but does not generate documentation content.
+- Documentation follows the Python import hierarchy.
+- Every public symbol should have a complete and accurate docstring.
+
+---
+
+## General rules
+
+- Use **Markdown headings** at package and module level.
+- Use **Google-style structured sections** at class, function, and method level.
+- Use type hints in signatures instead of duplicating types in prose.
+- Write summaries in imperative form.
+- Sections are separated by `---`
+
+---
+
+# Notes subsection grouping
+
+Group related information using labeled subsections.
+
+Example:
+
+    Notes:
+        **Guarantees:**
+
+            - deterministic behavior
+
+        **Lifecycle:**
+
+            - created during initialization
+            - reused across executions
+
+        **Thread safety:**
+
+            - safe for concurrent reads
+
+---
+
+# Example formatting
+
+- Use indentation for examples.
+- Indent section contents using four spaces.
+- Use code blocks for example code.
+
+Example:
+    Single example:
+
+        Example:
+
+            ```python
+            foo = Foo("example")
+            process(foo, multiplier=2)
+            ```
+
+    Multiple examples:
+
+        Example:
+            Create foo:
+
+                ```python
+                foo = Foo("example")
+                ```
+
+            Run engine:
+
+                ```python
+                engine = BarEngine([foo])
+                engine.run()
+                ```
+
+Avoid fenced code blocks inside structured sections.
+
+---
+
+# Separator rules
+
+Use horizontal separators only at docstring root level to separate sections:
+
+```markdown
+---
+```
+
+Allowed locations:
+
+- package docstrings
+- module docstrings
+- major documentation sections
+
+Do not use separators inside code sections.
+
+---
+
+# Package docstrings
+
+Package docstrings act as the documentation home page.
+
+Recommended sections:
+
+    # Summary
+    # Installation
+    # Quick start
+    # CLI usage
+    # Core concepts
+    # Architecture
+    # Rendering pipeline
+    # Examples
+    # Notes
+
+Example:
+    Package Doc String:
+
+        '''
+        # Summary
+
+        Foo-bar processing framework.
+
+        Provides tools for defining Foo objects and executing Bar pipelines.
+
+        ---
+
+        # Installation
+
+        ```bash
+        pip install foo-bar
+        ```
+
+        ---
+
+        # Quick start
+
+        ```python
+        from foobar import Foo, BarEngine
+
+        foo = Foo("example")
+        engine = BarEngine([foo])
+
+        result = engine.run()
+        ```
+
+        ---
+        '''
+
+---
+
+# Module docstrings
+
+Module docstrings describe a subsystem.
+
+Recommended sections:
+
+    # Summary
+    # Examples
+    # Notes
+
+Example:
+    Module Doc String:
+
+        '''
+        # Summary
+
+        Foo execution subsystem.
+
+        Provides utilities for executing Foo objects through Bar stages.
+
+        ---
+
+        Example:
+
+            ```python
+            from foobar.engine import BarEngine
+            from foobar.foo import Foo
+
+            foo = Foo("example")
+
+            engine = BarEngine([foo])
+            engine.run()
+            ```
+
+        ---
+        '''
+
+---
+
+# Class docstrings
+
+Class docstrings define object responsibility, lifecycle, and attributes.
+
+Recommended sections:
+
+    Attributes:
+    Notes:
+    Example:
+    Raises:
+
+Example:
+    Simple Foo:
+
+    ```python
+    class Foo:
+        '''
+        Represents a unit of work.
+
+        Attributes:
+            name (str):
+                Identifier of the foo instance.
+
+            value (int):
+                Numeric value associated with foo.
+
+        Notes:
+            Guarantees:
+
+                - instances are immutable after creation
+
+            Lifecycle:
+
+                - create instance
+                - pass to processing engine
+
+        Example:
+            Create and inspect a Foo:
+
+                ```python
+                foo = Foo("example", value=42)
+                print(foo.name)
+                ```
+        '''
     ```
 
-2.  **Define Navigation**:
-    Create a `docforge.nav.yml` to organize your documentation:
-    ```yaml
-    home: my_package/index.md
-    groups:
-      Core API:
-        - my_package/core/*.md
-      Utilities:
-        - my_package/utils.md
+    Complex Bar:
+
+    ```python
+    class BarEngine:
+        '''
+        Executes Foo objects through Bar stages.
+
+        Attributes:
+            foos (tuple[Foo, ...]):
+                Foo instances managed by the engine.
+
+        Notes:
+            Guarantees:
+
+                - deterministic execution order
+
+        Example:
+            Run engine:
+
+                ```python
+                foo1 = Foo("a")
+                foo2 = Foo("b")
+
+                engine = BarEngine([foo1, foo2])
+                engine.run()
+                ```
+        '''
     ```
 
-3.  **Generate MkDocs Configuration**:
-    ```bash
-    doc-forge mkdocs --site-name "My Awesome Docs"
+---
+
+# Function and method docstrings
+
+Function docstrings define API contracts.
+
+Recommended sections:
+
+    Args:
+    Returns:
+    Raises:
+    Yields:
+    Notes:
+    Example:
+
+Example:
+    Simple process method:
+
+    ```python
+    def process(foo: Foo, multiplier: int) -> int:
+        '''
+        Process a Foo instance.
+
+        Args:
+            foo (Foo):
+                Foo instance to process.
+
+            multiplier (int):
+                Value used to scale foo.
+
+        Returns:
+            int:
+                Processed result.
+
+        Raises:
+            ValueError:
+                If multiplier is negative.
+
+        Notes:
+            Guarantees:
+
+                - foo is not modified
+
+        Example:
+            Process foo:
+
+                ```python
+                foo = Foo("example", value=10)
+
+                result = process(foo, multiplier=2)
+                print(result)
+                ```
+        '''
     ```
 
-4.  **Preview**:
-    ```bash
-    doc-forge serve
+    Multiple Examples:
+
+    ```python
+    def combine(foo_a: Foo, foo_b: Foo) -> Foo:
+        '''
+        Combine two Foo instances.
+
+        Args:
+            foo_a (Foo):
+                First foo.
+
+            foo_b (Foo):
+                Second foo.
+
+        Returns:
+            Foo:
+                Combined foo.
+
+        Example:
+            Basic usage:
+
+                ```python
+                foo1 = Foo("a")
+                foo2 = Foo("b")
+
+                combined = combine(foo1, foo2)
+                ```
+
+            Pipeline usage:
+
+                ```python
+                engine = BarEngine([foo1, foo2])
+                engine.run()
+                ```
+        '''
     ```
 
-## Project Structure
+---
 
-- `docforge.loaders`: Introspects source code using static analysis (`griffe`).
-- `docforge.models`: The internal representation of your project, modules, and objects.
-- `docforge.renderers`: Converters that turn the models into physical files.
-- `docforge.nav`: Managers for logical-to-physical path mapping and navigation.
+# Property docstrings
+
+Properties must document return values.
+
+Example:
+    Property Doc String:
+
+        ```python
+        @property
+        def foos(self) -> tuple[Foo, ...]:
+            '''
+            Return contained Foo instances.
+
+            Returns:
+                tuple[Foo, ...]:
+                    Stored foo objects.
+
+            Example:
+                ```python
+                container = FooContainer()
+
+                foos = container.foos
+                ```
+            '''
+        ```
+
+---
+
+# Attribute documentation
+
+Document attributes in class docstrings using `Attributes:`.
+
+Example:
+    Attribute Doc String:
+
+        ```python
+        '''
+        Represents a processing stage.
+
+        Attributes:
+            id (str):
+                Unique identifier.
+
+            enabled (bool):
+                Whether the stage is active.
+        '''
+        ```
+
+---
+
+# Parsing guarantees
+
+GSDFC ensures doc-forge can deterministically extract:
+
+- symbol kind (module, class, function, property, attribute)
+- symbol name
+- parameters
+- return values
+- attributes
+- examples
+- structured Notes subsections
+
+This enables:
+
+- reliable MkDocs rendering
+- deterministic MCP export
+- accurate AI semantic interpretation
+
+---
+
+Notes:
+    - doc-forge never executes analyzed modules.
+    - Documentation is generated entirely through static analysis.
 """
 
 from .loaders import GriffeLoader, discover_module_paths

docforge/cli/__init__.py

@@ -1,16 +1,38 @@
 """
-# CLI Layer
+# Summary
 
-The `docforge.cli` package provides the command-line interface for interacting
-with doc-forge.
+Command line interface entry point for doc-forge.
 
-## Available Commands
+This module exposes the primary CLI entry function used by the
+`doc-forge` command. The actual command implementation resides in
+`docforge.cli.main`, while this module provides a stable import path
+for external tools and the package entry point configuration.
 
-- **tree**: Visualize the introspected project structure.
-- **generate**: Create Markdown source files from Python code.
-- **mkdocs**: Generate the primary `mkdocs.yml` configuration.
-- **build**: Build the final documentation site.
-- **serve**: Launch a local development server with live-reloading.
+The CLI is responsible for orchestrating documentation workflows such as
+generating renderer sources, building documentation sites, exporting
+machine-readable documentation bundles, and starting development or MCP
+servers.
+
+---
+
+# Typical usage
+
+The CLI is normally invoked through the installed command:
+
+```bash
+doc-forge <command> [options]
+```
+
+Programmatic invocation is also possible:
+
+Example:
+
+    ```python
+    from docforge.cli import main
+    main()
+    ```
+
+---
 """
 
 from .main import main

docforge/cli/commands.py

@@ -0,0 +1,248 @@
+"""
+# Summary
+
+Command definitions for the doc-forge CLI.
+
+Provides the CLI structure using Click, including build, serve, and tree commands.
+"""
+
+import click
+from pathlib import Path
+from typing import Sequence, Optional
+from docforge.loaders import GriffeLoader
+from docforge.cli import mkdocs_utils
+from docforge.cli import mcp_utils
+
+
+@click.group()
+def cli() -> None:
+    """
+    Root command group for the doc-forge CLI.
+
+    Provides commands for building, serving, and inspecting
+    documentation generated from Python source code.
+    """
+    pass
+
+
+@cli.command()
+@click.option("--mcp", is_flag=True, help="Build MCP resources")
+@click.option("--mkdocs", is_flag=True, help="Build MkDocs site")
+@click.option("--module-is-source", is_flag=True, help="Module is source folder and to be treated as root folder")
+@click.option("--module", help="Python module to document")
+@click.option("--project-name", help="Project name override")
+@click.option("--site-name", help="MkDocs site name")
+@click.option("--docs-dir", type=click.Path(path_type=Path), default=Path("docs"), help="Directory for MD sources")
+@click.option("--nav", "nav_file", type=click.Path(path_type=Path), default=Path("docforge.nav.yml"),
+              help="Nav spec path")
+@click.option("--template", type=click.Path(path_type=Path), help="MkDocs template path")
+@click.option("--mkdocs-yml", type=click.Path(path_type=Path), default=Path("mkdocs.yml"), help="Output config path")
+@click.option("--out-dir", type=click.Path(path_type=Path), default=Path("mcp_docs"), help="MCP output directory")
+def build(
+    mcp: bool,
+    mkdocs: bool,
+    module_is_source: bool,
+    module: Optional[str],
+    project_name: Optional[str],
+    site_name: Optional[str],
+    docs_dir: Path,
+    nav_file: Path,
+    template: Optional[Path],
+    mkdocs_yml: Path,
+    out_dir: Path,
+) -> None:
+    """
+    Build documentation artifacts.
+
+    This command performs the full documentation build pipeline:
+
+    1. Introspects the Python project using Griffe
+    2. Generates renderer-specific documentation sources
+    3. Optionally builds the final documentation output
+
+    Depending on the selected options, the build can target:
+
+    - MkDocs static documentation sites
+    - MCP structured documentation resources
+
+    Args:
+        mcp (bool):
+            Enable MCP documentation generation.
+
+        mkdocs (bool):
+            Enable MkDocs documentation generation.
+
+        module_is_source (bool):
+            Treat the specified module directory as the project root.
+
+        module (Optional[str]):
+            Python module import path to document.
+
+        project_name (Optional[str]):
+            Optional override for the project name.
+
+        site_name (Optional[str]):
+            Display name for the MkDocs site.
+
+        docs_dir (Path):
+            Directory where Markdown documentation sources will be generated.
+
+        nav_file (Path):
+            Path to the navigation specification file.
+
+        template (Optional[Path]):
+            Optional custom MkDocs configuration template.
+
+        mkdocs_yml (Path):
+            Output path for the generated MkDocs configuration.
+
+        out_dir (Path):
+            Output directory for generated MCP resources.
+
+    Raises:
+        click.UsageError:
+            If required options are missing or conflicting.
+    """
+    if not mcp and not mkdocs:
+        raise click.UsageError("Must specify either --mcp or --mkdocs")
+
+    if mkdocs:
+        if not module:
+            raise click.UsageError("--module is required for MkDocs build")
+        if not site_name:
+            site_name = module
+
+        click.echo(f"Generating MkDocs sources in {docs_dir}...")
+        mkdocs_utils.generate_sources(
+            module,
+            docs_dir,
+            project_name,
+            module_is_source,
+        )
+
+        click.echo(f"Generating MkDocs config {mkdocs_yml}...")
+        mkdocs_utils.generate_config(docs_dir, nav_file, template, mkdocs_yml, site_name)
+
+        click.echo("Running MkDocs build...")
+        mkdocs_utils.build(mkdocs_yml)
+        click.echo("MkDocs build completed.")
+
+    if mcp:
+        if not module:
+            raise click.UsageError("--module is required for MCP build")
+
+        click.echo(f"Generating MCP resources in {out_dir}...")
+        mcp_utils.generate_resources(module, project_name, out_dir)
+        click.echo("MCP build completed.")
+
+
+@cli.command()
+@click.option("--mcp", is_flag=True, help="Serve MCP documentation")
+@click.option("--mkdocs", is_flag=True, help="Serve MkDocs site")
+@click.option("--module", help="Python module to serve")
+@click.option("--mkdocs-yml", type=click.Path(path_type=Path), default=Path("mkdocs.yml"), help="MkDocs config path")
+@click.option("--out-dir", type=click.Path(path_type=Path), default=Path("mcp_docs"), help="MCP root directory")
+def serve(
+    mcp: bool,
+    mkdocs: bool,
+    module: Optional[str],
+    mkdocs_yml: Path,
+    out_dir: Path,
+) -> None:
+    """
+    Serve generated documentation locally.
+
+    Depending on the selected mode, this command starts either:
+
+    - A MkDocs development server for browsing documentation
+    - An MCP server exposing structured documentation resources
+
+    Args:
+        mcp (bool):
+            Serve documentation using the MCP server.
+
+        mkdocs (bool):
+            Serve the MkDocs development site.
+
+        module (Optional[str]):
+            Python module import path to serve via MCP.
+
+        mkdocs_yml (Path):
+            Path to the MkDocs configuration file.
+
+        out_dir (Path):
+            Root directory containing MCP documentation resources.
+
+    Raises:
+        click.UsageError:
+            If invalid or conflicting options are provided.
+    """
+    if mcp and mkdocs:
+        raise click.UsageError("Cannot specify both --mcp and --mkdocs")
+    if not mcp and not mkdocs:
+        raise click.UsageError("Must specify either --mcp or --mkdocs")
+    if mcp and not module:
+        raise click.UsageError("--module is required for MCP serve")
+
+    if mkdocs:
+        mkdocs_utils.serve(mkdocs_yml)
+    elif mcp:
+        mcp_utils.serve(module, out_dir)
+
+
+@cli.command()
+@click.option(
+    "--module",
+    required=True,
+    help="Python module import path to introspect",
+)
+@click.option(
+    "--project-name",
+    help="Project name (defaults to specified module)",
+)
+def tree(
+    module: str,
+    project_name: Optional[str],
+) -> None:
+    """
+    Display the documentation object tree for a module.
+
+    This command introspects the specified module and prints a
+    hierarchical representation of the discovered documentation
+    objects, including modules, classes, functions, and members.
+
+    Args:
+        module (str):
+            Python module import path to introspect.
+
+        project_name (Optional[str]):
+            Optional name to display as the project root.
+    """
+    loader = GriffeLoader()
+    project = loader.load_project([module], project_name)
+
+    click.echo(project.name)
+
+    for module in project.get_all_modules():
+        click.echo(f"├── {module.path}")
+        for obj in module.get_all_objects():
+            _print_object(obj, indent="│   ")
+
+
+def _print_object(obj, indent: str) -> None:
+    """
+    Recursively print a documentation object and its members.
+
+    This helper function traverses the documentation object graph
+    and prints each object with indentation to represent hierarchy.
+
+    Args:
+        obj:
+            Documentation object to print.
+
+        indent (str):
+            Current indentation prefix used for nested members.
+    """
+    click.echo(f"{indent}├── {obj.name}")
+    for member in obj.get_all_members():
+        _print_object(member, indent + "│   ")

docforge/cli/commands.pyi

@@ -0,0 +1,34 @@
+from click.core import Group
+from pathlib import Path
+from typing import Sequence, Optional, Any
+
+cli: Group
+
+def build(
+    mcp: bool,
+    mkdocs: bool,
+    module_is_source: bool,
+    module: Optional[str],
+    project_name: Optional[str],
+    site_name: Optional[str],
+    docs_dir: Path,
+    nav_file: Path,
+    template: Optional[Path],
+    mkdocs_yml: Path,
+    out_dir: Path,
+) -> None: ...
+
+def serve(
+    mcp: bool,
+    mkdocs: bool,
+    module: Optional[str],
+    mkdocs_yml: Path,
+    out_dir: Path,
+) -> None: ...
+
+def tree(
+    module: str,
+    project_name: Optional[str],
+) -> None: ...
+
+def _print_object(obj: Any, indent: str) -> None: ...

docforge/cli/main.py

@@ -1,275 +1,25 @@
 """
-Main entry point for the doc-forge CLI. This module defines the core command
-group and the 'tree', 'generate', 'build', and 'serve' commands.
+# Summary
+
+Command-line entry point for the doc-forge CLI.
+
+This module exposes the executable entry point that initializes the
+Click command group defined in `docforge.cli.commands`.
 """
 
-from pathlib import Path
-from typing import Sequence, Optional
+from docforge.cli.commands import cli
 
-import click
-
-from docforge.loaders import GriffeLoader, discover_module_paths
-from docforge.renderers import MkDocsRenderer, MCPRenderer
-from docforge.cli.mkdocs import mkdocs_cmd
-
-
-@click.group()
-def cli() -> None:
-    """
-    doc-forge CLI: A tool for introspecting Python projects and generating
-    documentation.
-    """
-    pass
-
-
-cli.add_command(mkdocs_cmd)
-
-# ---------------------------------------------------------------------
-# tree
-# ---------------------------------------------------------------------
-
-@cli.command()
-@click.option(
-    "--modules",
-    multiple=True,
-    required=True,
-    help="Python module import paths to introspect",
-)
-@click.option(
-    "--project-name",
-    help="Project name (defaults to first module)",
-)
-def tree(
-    modules: Sequence[str],
-    project_name: Optional[str],
-) -> None:
-    """
-    Visualize the project structure including modules and their members.
-
-    Args:
-        modules: List of module paths to introspect.
-        project_name: Optional project name override.
-    """
-    loader = GriffeLoader()
-    project = loader.load_project(list(modules), project_name)
-
-    click.echo(project.name)
-
-    for module in project.get_all_modules():
-        click.echo(f"├── {module.path}")
-
-        for obj in module.get_all_objects():
-            _print_object(obj, indent="│   ")
-
-
-def _print_object(obj, indent: str) -> None:
-    """
-    Recursive helper to print doc objects and their members to the console.
-
-    Args:
-        obj: The DocObject to print.
-        indent: The current line indentation string.
-    """
-    click.echo(f"{indent}├── {obj.name}")
-    for member in obj.get_all_members():
-        _print_object(member, indent + "│   ")
-
-
-# ---------------------------------------------------------------------
-# generate
-# ---------------------------------------------------------------------
-
-@cli.command()
-@click.option(
-    "--module",
-    required=True,
-    help="Python module import paths to document",
-)
-@click.option(
-    "--project-name",
-    help="Project name (defaults to first module)",
-)
-@click.option(
-    "--docs-dir",
-    type=click.Path(path_type=Path),
-    default=Path("docs"),
-)
-def generate(
-    module: str,
-    project_name: Optional[str],
-    docs_dir: Path,
-) -> None:
-    """
-    Generate Markdown source files for the specified module.
-
-    Args:
-        module: The primary module path to document.
-        project_name: Optional project name override.
-        docs_dir: Directory where documentation sources will be written.
-    """
-    loader = GriffeLoader()
-    discovered_paths = discover_module_paths(
-        module,
-    )
-    project = loader.load_project(
-        discovered_paths,
-        project_name
-    )
-
-    renderer = MkDocsRenderer()
-    renderer.generate_sources(project, docs_dir)
-
-    click.echo(f"Documentation sources generated in {docs_dir}")
-
-
-# ---------------------------------------------------------------------
-# mcp-build
-# ---------------------------------------------------------------------
-
-@cli.command(name="generate-mcp")
-@click.option(
-    "--module",
-    required=True,
-    help="Python module import path to document",
-)
-@click.option(
-    "--project-name",
-    help="Project name (defaults to first module)",
-)
-@click.option(
-    "--out-dir",
-    type=click.Path(path_type=Path),
-    default=Path("mcp_docs"),
-)
-def generate_mcp(
-    module: str,
-    project_name: str | None,
-    out_dir: Path,
-) -> None:
-    """
-    Generate MCP-compatible documentation resources for the specified module.
-
-    Args:
-        module: The primary module path to document.
-        project_name: Optional project name override.
-        out_dir: Directory where MCP resources will be written.
-    """
-    loader = GriffeLoader()
-    discovered_paths = discover_module_paths(module)
-
-    project = loader.load_project(
-        discovered_paths,
-        project_name,
-    )
-
-    renderer = MCPRenderer()
-    renderer.generate_sources(project, out_dir)
-
-    click.echo(f"MCP documentation resources generated in {out_dir}")
-
-
-# ---------------------------------------------------------------------
-# build
-# ---------------------------------------------------------------------
-
-@cli.command()
-@click.option(
-    "--mkdocs-yml",
-    type=click.Path(path_type=Path),
-    default=Path("mkdocs.yml"),
-)
-def build(mkdocs_yml: Path) -> None:
-    """
-    Build the documentation site using MkDocs.
-
-    Args:
-        mkdocs_yml: Path to the mkdocs.yml configuration file.
-    """
-    if not mkdocs_yml.exists():
-        raise click.ClickException(f"mkdocs.yml not found: {mkdocs_yml}")
-
-    from mkdocs.config import load_config
-    from mkdocs.commands.build import build as mkdocs_build
-
-    mkdocs_build(load_config(str(mkdocs_yml)))
-
-    click.echo("MkDocs build completed")
-
-
-# ---------------------------------------------------------------------
-# serve-mcp
-# ---------------------------------------------------------------------
-
-@cli.command(name="serve-mcp")
-def serve_mcp() -> None:
-    """
-    Serve MCP documentation from the local mcp_docs directory.
-    """
-    from docforge.servers import MCPServer
-
-    mcp_root = Path.cwd() / "mcp_docs"
-
-    if not mcp_root.exists():
-        raise click.ClickException("mcp_docs directory not found")
-
-    required = [
-        mcp_root / "index.json",
-        mcp_root / "nav.json",
-        mcp_root / "modules",
-    ]
-
-    for path in required:
-        if not path.exists():
-            raise click.ClickException(f"Invalid MCP bundle, missing: {path.name}")
-
-    server = MCPServer(
-        mcp_root=mcp_root,
-        name="doc-forge-mcp",
-    )
-
-    server.run()
-
-
-# ---------------------------------------------------------------------
-# serve
-# ---------------------------------------------------------------------
-
-@cli.command()
-@click.option(
-    "--mkdocs-yml",
-    type=click.Path(path_type=Path),
-    default=Path("mkdocs.yml"),
-)
-def serve(mkdocs_yml: Path) -> None:
-    """
-    Serve the documentation site with live-reload using MkDocs.
-
-    Args:
-        mkdocs_yml: Path to the mkdocs.yml configuration file.
-    """
-    if not mkdocs_yml.exists():
-        raise click.ClickException(f"mkdocs.yml not found: {mkdocs_yml}")
-
-    from mkdocs.commands.serve import serve as mkdocs_serve
-
-    host = "127.0.0.1"
-    port = 8000
-    url = f"http://{host}:{port}/"
-
-    click.echo(f"Serving documentation at {url}")
-    mkdocs_serve(config_file=str(mkdocs_yml))
-
-
-# ---------------------------------------------------------------------
-# entry point
-# ---------------------------------------------------------------------
 
 def main() -> None:
     """
-    CLI Entry point. Boots the click application.
+    Run the doc-forge command-line interface.
+
+    This function initializes and executes the Click CLI application.
+    It is used as the console entry point when invoking `doc-forge`
+    from the command line.
     """
     cli()
 
 
 if __name__ == "__main__":
-    main()
+    main()

docforge/cli/main.pyi

@@ -1,109 +1 @@
-from typing import Sequence
-from pathlib import Path
-
-import click
-
-
-@click.group()
-def cli() -> None:
-    """doc-forge command-line interface."""
-
-
-@cli.command()
-@click.option(
-    "--modules",
-    multiple=True,
-    help="Python module import paths to introspect",
-)
-@click.option(
-    "--project-name",
-    help="Project name (defaults to first module)",
-)
-def tree(
-    modules: Sequence[str],
-    project_name: str | None,
-) -> None:
-    """Show introspection tree."""
-
-
-@cli.command()
-@click.option(
-    "--module",
-    help="Python module import paths to document",
-)
-@click.option(
-    "--project-name",
-    help="Project name (defaults to first module)",
-)
-@click.option(
-    "--docs-dir",
-    type=click.Path(path_type=Path),
-    default=Path("docs"),
-)
-def generate(
-    module: str,
-    project_name: str | None,
-    docs_dir: Path,
-) -> None:
-    """Generate documentation source files using MkDocs renderer."""
-
-@cli.command(name="generate-mcp")
-@click.option(
-    "--module",
-    required=True,
-    help="Python module import path to document",
-)
-@click.option(
-    "--project-name",
-    help="Project name (defaults to first module)",
-)
-@click.option(
-    "--out-dir",
-    type=click.Path(path_type=Path),
-    default=Path("mcp_docs"),
-)
-def generate_mcp(
-    module: str,
-    project_name: str | None,
-    out_dir: Path,
-) -> None:
-    """
-    Generate MCP-compatible documentation resources for the specified module.
-
-    Args:
-        module: The primary module path to document.
-        project_name: Optional project name override.
-        out_dir: Directory where MCP resources will be written.
-    """
-
-@cli.command()
-@click.option(
-    "--mkdocs-yml",
-    type=click.Path(path_type=Path),
-    default=Path("mkdocs.yml"),
-)
-def build(
-    mkdocs_yml: Path,
-) -> None:
-    """Build documentation using MkDocs."""
-
-
-@cli.command()
-@click.option(
-    "--mkdocs-yml",
-    type=click.Path(path_type=Path),
-    default=Path("mkdocs.yml"),
-)
-def serve(
-    mkdocs_yml: Path,
-) -> None:
-    """Serve documentation using MkDocs."""
-
-
-@cli.command(name="serve-mcp")
-def serve_mcp() -> None:
-    """Serve MCP documentation."""
-
-
-def main() -> None:
-    """CLI entry point."""
+def main() -> None: ...

docforge/cli/mcp_utils.py

@@ -0,0 +1,80 @@
+"""
+# Summary
+
+Utilities for working with MCP in the doc-forge CLI.
+"""
+
+from pathlib import Path
+import click
+from docforge.loaders import GriffeLoader, discover_module_paths
+from docforge.renderers import MCPRenderer
+from docforge.servers import MCPServer
+
+
+def generate_resources(module: str, project_name: str | None, out_dir: Path) -> None:
+    """
+    Generate MCP documentation resources from a Python module.
+
+    The function performs project introspection, builds the internal
+    documentation model, and renders MCP-compatible JSON resources
+    to the specified output directory.
+
+    Args:
+        module (str):
+            Python module import path used as the entry point for
+            documentation generation.
+
+        project_name (Optional[str]):
+            Optional override for the project name used in generated
+            documentation metadata.
+
+        out_dir (Path):
+            Directory where MCP resources (index.json, nav.json, and module data)
+            will be written.
+    """
+    loader = GriffeLoader()
+    discovered_paths = discover_module_paths(module)
+    project = loader.load_project(discovered_paths, project_name)
+
+    renderer = MCPRenderer()
+    renderer.generate_sources(project, out_dir)
+
+
+def serve(module: str, mcp_root: Path) -> None:
+    """
+    Start an MCP server for a pre-generated documentation bundle.
+
+    The server exposes documentation resources such as project metadata,
+    navigation structure, and module documentation through MCP endpoints.
+
+    Args:
+        module (str):
+            Python module import path used to identify the served
+            documentation instance.
+
+        mcp_root (Path):
+            Path to the directory containing the MCP documentation
+            bundle (index.json, nav.json, and modules/).
+
+    Raises:
+        click.ClickException:
+            If the MCP documentation bundle is missing required files or directories.
+    """
+    if not mcp_root.exists():
+        raise click.ClickException(f"mcp_docs directory not found: {mcp_root}")
+
+    required = [
+        mcp_root / "index.json",
+        mcp_root / "nav.json",
+        mcp_root / "modules",
+    ]
+
+    for path in required:
+        if not path.exists():
+            raise click.ClickException(f"Invalid MCP bundle, missing: {path.name}")
+
+    server = MCPServer(
+        mcp_root=mcp_root,
+        name=f"{module}-mcp",
+    )
+    server.run()

docforge/cli/mcp_utils.pyi

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+def generate_resources(module: str, project_name: str | None, out_dir: Path) -> None: ...
+def serve(module: str, mcp_root: Path) -> None: ...

docforge/cli/mkdocs.py

@@ -1,116 +0,0 @@
-"""
-This module contains the 'mkdocs' CLI command, which orchestrates the generation
-of the main mkdocs.yml configuration file.
-"""
-
-from pathlib import Path
-from importlib import resources
-
-import click
-import yaml
-
-from docforge.nav import load_nav_spec
-from docforge.nav import resolve_nav
-from docforge.nav import MkDocsNavEmitter
-
-
-def _load_template(template: Path | None) -> dict:
-    """
-    Load a YAML template for mkdocs.yml. If no template is provided,
-    loads the built-in sample template.
-
-    Args:
-        template: Path to the template file, or None.
-
-    Returns:
-        The loaded template data as a dictionary.
-    """
-    if template is not None:
-        if not template.exists():
-            raise click.FileError(str(template), hint="Template not found")
-        return yaml.safe_load(template.read_text(encoding="utf-8"))
-
-    # Load built-in default
-    text = (
-        resources.files("docforge.templates")
-        .joinpath("mkdocs.sample.yml")
-        .read_text(encoding="utf-8")
-    )
-    return yaml.safe_load(text)
-
-
-@click.command("mkdocs")
-@click.option(
-    "--site-name",
-    required=True,
-    help="MkDocs site_name (required)",
-)
-@click.option(
-    "--docs-dir",
-    type=click.Path(path_type=Path),
-    default=Path("docs"),
-)
-@click.option(
-    "--nav",
-    "nav_file",
-    type=click.Path(path_type=Path),
-    default=Path("docforge.nav.yml"),
-)
-@click.option(
-    "--template",
-    type=click.Path(path_type=Path),
-    default=None,
-    help="Override the built-in mkdocs template",
-)
-@click.option(
-    "--out",
-    type=click.Path(path_type=Path),
-    default=Path("mkdocs.yml"),
-)
-def mkdocs_cmd(
-    docs_dir: Path,
-    nav_file: Path,
-    template: Path | None,
-    out: Path,
-    site_name: str,
-) -> None:
-    """
-    Generate an mkdocs.yml configuration file by combining a template with
-    the navigation structure resolved from a docforge.nav.yml file.
-
-    Args:
-        docs_dir: Path to the directory containing documentation Markdown files.
-        nav_file: Path to the docforge.nav.yml specification.
-        template: Optional path to an mkdocs.yml template.
-        out: Path where the final mkdocs.yml will be written.
-        site_name: The name of the documentation site.
-    """
-
-    if not nav_file.exists():
-        raise click.FileError(str(nav_file), hint="Nav spec not found")
-
-    # Load nav spec
-    spec = load_nav_spec(nav_file)
-
-    # Resolve nav
-    resolved = resolve_nav(spec, docs_dir)
-
-    # Emit mkdocs nav
-    nav_block = MkDocsNavEmitter().emit(resolved)
-
-    # Load template (user or built-in)
-    data = _load_template(template)
-
-    # Inject site_name
-    data["site_name"] = site_name
-
-    # Inject nav
-    data["nav"] = nav_block
-
-    # Write output
-    out.write_text(
-        yaml.safe_dump(data, sort_keys=False),
-        encoding="utf-8",
-    )
-
-    click.echo(f"mkdocs.yml written to {out}")

docforge/cli/mkdocs.pyi

@@ -1,45 +0,0 @@
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-import click
-
-
-def _load_template(template: Optional[Path]) -> Dict[str, Any]:
-    ...
-
-
-@click.command("mkdocs")
-@click.option(
-    "--site-name",
-    required=True,
-    help="MkDocs site_name (required)",
-)
-@click.option(
-    "--docs-dir",
-    type=click.Path(path_type=Path),
-    default=Path("docs"),
-)
-@click.option(
-    "--nav",
-    "nav_file",
-    type=click.Path(path_type=Path),
-    default=Path("docforge.nav.yml"),
-)
-@click.option(
-    "--template",
-    type=click.Path(path_type=Path),
-    default=None,
-)
-@click.option(
-    "--out",
-    type=click.Path(path_type=Path),
-    default=Path("mkdocs.yml"),
-)
-def mkdocs_cmd(
-    docs_dir: Path,
-    nav_file: Path,
-    template: Optional[Path],
-    out: Path,
-    site_name: str,
-) -> None:
-    ...

docforge/cli/mkdocs_utils.py

@@ -0,0 +1,166 @@
+"""
+# Summary
+
+Utilities for working with MkDocs in the doc-forge CLI.
+"""
+
+from pathlib import Path
+from importlib import resources
+import click
+import yaml
+from docforge.loaders import GriffeLoader, discover_module_paths
+from docforge.renderers import MkDocsRenderer
+from docforge.nav import load_nav_spec, resolve_nav, MkDocsNavEmitter
+
+
+def generate_sources(
+    module: str,
+    docs_dir: Path,
+    project_name: str | None = None,
+    module_is_source: bool | None = None,
+) -> None:
+    """
+    Generate MkDocs Markdown sources for a Python module.
+
+    This function introspects the specified module, builds the internal
+    documentation model, and renders Markdown documentation files for
+    use with MkDocs.
+
+    Args:
+        module (str):
+            Python module import path used as the entry point for
+            documentation generation.
+
+        docs_dir (Path):
+            Directory where the generated Markdown files will be written.
+
+        project_name (Optional[str]):
+            Optional override for the project name used in documentation metadata.
+
+        module_is_source (Optional[bool]):
+            If True, treat the specified module directory as the project root
+            rather than a nested module.
+    """
+    loader = GriffeLoader()
+    discovered_paths = discover_module_paths(module)
+    project = loader.load_project(discovered_paths, project_name)
+
+    renderer = MkDocsRenderer()
+    renderer.generate_sources(
+        project,
+        docs_dir,
+        module_is_source,
+    )
+
+    renderer.generate_readme(
+        project,
+        docs_dir,
+        module_is_source,
+    )
+
+
+def generate_config(
+    docs_dir: Path,
+    nav_file: Path,
+    template: Path | None,
+    out: Path,
+    site_name: str,
+) -> None:
+    """
+    Generate an `mkdocs.yml` configuration file.
+
+    The configuration is created by combining a template configuration
+    with a navigation structure derived from the docforge navigation
+    specification.
+
+    Args:
+        docs_dir (Path):
+            Directory containing generated documentation Markdown files.
+
+        nav_file (Path):
+            Path to the `docforge.nav.yml` navigation specification.
+
+        template (Optional[Path]):
+            Optional path to a custom MkDocs configuration template. If not
+            provided, a built-in template will be used.
+
+        out (Path):
+            Destination path where the generated `mkdocs.yml` file will be written.
+
+        site_name (str):
+            Display name for the generated documentation site.
+
+    Raises:
+        click.FileError:
+            If the navigation specification or template file cannot be found.
+    """
+    if not nav_file.exists():
+        raise click.FileError(str(nav_file), hint="Nav spec not found")
+
+    spec = load_nav_spec(nav_file)
+    resolved = resolve_nav(spec, docs_dir)
+    nav_block = MkDocsNavEmitter().emit(resolved)
+
+    # Load template
+    if template is not None:
+        if not template.exists():
+            raise click.FileError(str(template), hint="Template not found")
+        data = yaml.safe_load(template.read_text(encoding="utf-8"))
+    else:
+        text = (
+            resources.files("docforge.templates")
+            .joinpath("mkdocs.sample.yml")
+            .read_text(encoding="utf-8")
+        )
+        data = yaml.safe_load(text)
+
+    data["site_name"] = site_name
+    data["nav"] = nav_block
+
+    out.write_text(yaml.safe_dump(data, sort_keys=False), encoding="utf-8")
+
+
+def build(mkdocs_yml: Path) -> None:
+    """
+    Build the MkDocs documentation site.
+
+    This function loads the MkDocs configuration and runs the MkDocs
+    build command to generate the final static documentation site.
+
+    Args:
+        mkdocs_yml (Path):
+            Path to the `mkdocs.yml` configuration file.
+
+    Raises:
+        click.ClickException:
+            If the configuration file does not exist.
+    """
+    if not mkdocs_yml.exists():
+        raise click.ClickException(f"mkdocs.yml not found: {mkdocs_yml}")
+
+    from mkdocs.config import load_config
+    from mkdocs.commands.build import build as mkdocs_build
+
+    mkdocs_build(load_config(str(mkdocs_yml)))
+
+
+def serve(mkdocs_yml: Path) -> None:
+    """
+    Start an MkDocs development server with live reload.
+
+    The server watches documentation files and automatically reloads
+    the site when changes are detected.
+
+    Args:
+        mkdocs_yml (Path):
+            Path to the `mkdocs.yml` configuration file.
+
+    Raises:
+        click.ClickException:
+            If the configuration file does not exist.
+    """
+    if not mkdocs_yml.exists():
+        raise click.ClickException(f"mkdocs.yml not found: {mkdocs_yml}")
+
+    from mkdocs.commands.serve import serve as mkdocs_serve
+    mkdocs_serve(config_file=str(mkdocs_yml))

docforge/cli/mkdocs_utils.pyi

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+def generate_sources(
+    module: str,
+    docs_dir: Path,
+    project_name: str | None = None,
+    module_is_source: bool | None = None,
+) -> None: ...
+def generate_config(docs_dir: Path, nav_file: Path, template: Path | None, out: Path, site_name: str) -> None: ...
+def build(mkdocs_yml: Path) -> None: ...
+def serve(mkdocs_yml: Path) -> None: ...

docforge/loaders/__init__.py

@@ -1,17 +1,28 @@
 """
-# Loader Layer
+# Summary
 
-The `docforge.loaders` package is responsible for discovering Python source files
-and extracting their documentation using static analysis.
+Loader layer for doc-forge.
 
-## Core Features
+The `docforge.loaders` package is responsible for discovering Python modules
+and extracting documentation data using static analysis.
 
-- **Discovery**: Automatically find all modules and packages in a project
-  directory.
-- **Introspection**: Uses `griffe` to parse docstrings, signatures, and
-  hierarchical relationships without executing the code.
-- **Filtering**: Automatically excludes private members (prefixed with `_`) to
-  ensure clean public documentation.
+---
+
+# Overview
+
+This layer converts Python source code into an intermediate documentation
+model used by doc-forge. It performs module discovery, introspection, and
+initial filtering before the data is passed to the core documentation models.
+
+Core capabilities include:
+
+- **Module discovery** – Locate Python modules and packages within a project.
+- **Static introspection** – Parse docstrings, signatures, and object
+  hierarchies using the `griffe` library without executing the code.
+- **Public API filtering** – Exclude private members (names prefixed with
+  `_`) to produce clean public documentation structures.
+
+---
 """
 
 from .griffe_loader import GriffeLoader, discover_module_paths

docforge/loaders/griffe_loader.py

@@ -1,6 +1,11 @@
 """
-This module provides the GriffeLoader, which uses the 'griffe' library to
-introspect Python source code and populate the doc-forge Project models.
+# Summary
+
+Utilities for loading and introspecting Python modules using Griffe.
+
+This module provides the `GriffeLoader` class and helper utilities used to
+discover Python modules, introspect their structure, and convert the results
+into doc-forge documentation models.
 """
 
 import logging
@@ -25,19 +30,32 @@ def discover_module_paths(
     project_root: Path | None = None,
 ) -> List[str]:
     """
-    Discover all Python modules under a package via filesystem traversal.
+    Discover Python modules within a package directory.
 
-    Rules:
-    - Directory with __init__.py is treated as a package.
-    - Any .py file is treated as a module.
-    - All paths are converted to dotted module paths.
+    The function scans the filesystem for `.py` files inside the specified
+    package and converts them into dotted module import paths.
+
+    Discovery rules:
+
+    - Directories containing `__init__.py` are treated as packages.
+    - Each `.py` file is treated as a module.
+    - Results are returned as dotted import paths.
 
     Args:
-        module_name: The name of the package to discover.
-        project_root: The root directory of the project. Defaults to current working directory.
+        module_name (str):
+            Top-level package name to discover modules from.
+
+        project_root (Path, optional):
+            Root directory used to resolve module paths. If not provided, the
+            current working directory is used.
 
     Returns:
-        A sorted list of dotted module paths.
+        List[str]:
+            A sorted list of unique dotted module import paths.
+
+    Raises:
+        FileNotFoundError:
+            If the specified package directory does not exist.
     """
 
     if project_root is None:
@@ -64,12 +82,19 @@ def discover_module_paths(
 
 class GriffeLoader:
     """
-    Loads Python modules and extracts documentation using the Griffe introspection engine.
+    Load Python modules using Griffe and convert them into doc-forge models.
+
+    This loader uses the Griffe introspection engine to analyze Python source
+    code and transform the extracted information into `Project`, `Module`,
+    and `DocObject` instances used by doc-forge.
     """
 
     def __init__(self) -> None:
         """
-        Initialize the GriffeLoader.
+        Initialize the Griffe-backed loader.
+
+        Creates an internal Griffe loader instance with dedicated collections
+        for modules and source lines.
         """
         self._loader = _GriffeLoader(
             modules_collection=ModulesCollection(),
@@ -77,21 +102,39 @@ class GriffeLoader:
         )
 
     def load_project(
-        self,
-        module_paths: List[str],
-        project_name: Optional[str] = None,
-        skip_import_errors: bool = None,
+            self,
+            module_paths: List[str],
+            project_name: Optional[str] = None,
+            skip_import_errors: bool = None,
     ) -> Project:
         """
-        Load multiple modules and combine them into a single Project models.
+        Load multiple modules and assemble them into a Project model.
+
+        Each module path is introspected and converted into a `Module`
+        instance. All modules are then aggregated into a single `Project`
+        object.
 
         Args:
-            module_paths: A list of dotted paths to the modules to load.
-            project_name: Optional name for the project. Defaults to the first module name.
-            skip_import_errors: If True, modules that fail to import will be skipped.
+            module_paths (List[str]):
+                List of dotted module import paths to load.
+
+            project_name (str, optional):
+                Optional override for the project name. Defaults to the top-level
+                name of the first module.
+
+            skip_import_errors (bool, optional):
+                If True, modules that fail to load will be skipped instead of raising an error.
 
         Returns:
-            A Project instance containing the loaded modules.
+            Project:
+                A populated `Project` instance containing the loaded modules.
+
+        Raises:
+            ValueError:
+                If no module paths are provided.
+
+            ImportError:
+                If a module fails to load and `skip_import_errors` is False.
         """
         if not module_paths:
             raise ValueError("At least one module path must be provided")
@@ -116,13 +159,18 @@ class GriffeLoader:
 
     def load_module(self, path: str) -> Module:
         """
-        Load a single module and convert its introspection data into the docforge models.
+        Load and convert a single Python module.
+
+        The module is introspected using Griffe and then transformed into
+        a doc-forge `Module` model.
 
         Args:
-            path: The dotted path of the module to load.
+            path (str):
+                Dotted import path of the module.
 
         Returns:
-            A Module instance.
+            Module:
+                A populated `Module` instance.
         """
         self._loader.load(path)
         griffe_module = self._loader.modules_collection[path]
@@ -135,13 +183,18 @@ class GriffeLoader:
 
     def _convert_module(self, obj: Object) -> Module:
         """
-        Convert a Griffe Object (module) into a docforge Module.
+        Convert a Griffe module object into a doc-forge Module.
+
+        All public members of the module are recursively converted into
+        `DocObject` instances.
 
         Args:
-            obj: The Griffe Object representing the module.
+            obj (Object):
+                Griffe object representing the module.
 
         Returns:
-            A populated Module instance.
+            Module:
+                A populated `Module` model.
         """
         module = Module(
             path=obj.path,
@@ -158,13 +211,19 @@ class GriffeLoader:
 
     def _convert_object(self, obj: Object) -> DocObject:
         """
-        Recursively convert a Griffe Object into a DocObject hierarchy.
+        Convert a Griffe object into a doc-forge DocObject.
+
+        The conversion preserves the object's metadata such as name,
+        kind, path, signature, and docstring. Child members are processed
+        recursively.
 
         Args:
-            obj: The Griffe Object to convert.
+            obj (Object):
+                Griffe object representing a documented Python object.
 
         Returns:
-            A DocObject instance.
+            DocObject:
+                A `DocObject` instance representing the converted object.
         """
         kind = obj.kind.value
         signature = self._safe_signature(obj)
@@ -193,13 +252,15 @@ class GriffeLoader:
 
     def _safe_docstring(self, obj: Object) -> Optional[str]:
         """
-        Safely retrieve the docstring value from a Griffe object.
+        Safely extract a docstring from a Griffe object.
 
         Args:
-            obj: The Griffe Object to inspect.
+            obj (Object):
+                Griffe object to inspect.
 
         Returns:
-            The raw docstring string, or None if missing or unresolvable.
+            Optional[str]:
+                The raw docstring text if available, otherwise `None`.
         """
         try:
             return obj.docstring.value if obj.docstring else None
@@ -208,13 +269,15 @@ class GriffeLoader:
 
     def _safe_signature(self, obj: Object) -> Optional[str]:
         """
-        Safely retrieve the signature string from a Griffe object.
+        Safely extract the signature of a Griffe object.
 
         Args:
-            obj: The Griffe Object to inspect.
+            obj (Object):
+                Griffe object to inspect.
 
         Returns:
-            The string representation of the signature, or None.
+            Optional[str]:
+                String representation of the object's signature if available, otherwise `None`.
         """
         try:
             if hasattr(obj, "signature") and obj.signature:

docforge/models/__init__.py

@@ -1,17 +1,33 @@
 """
-# Model Layer
+# Summary
 
-The `docforge.models` package provides the core data structures used to represent
-Python source code in a documentation-focused hierarchy.
+Model layer for doc-forge.
 
-## Key Components
+The `docforge.models` package defines the core data structures used to
+represent Python source code as a structured documentation model.
 
-- **Project**: The root container for all documented modules.
-- **Module**: Represents a Python module or package, containing members.
-- **DocObject**: A recursive structure for classes, functions, and attributes.
+---
 
-These classes are designed to be renderer-agnostic, allowing the same internal
-representation to be transformed into various output formats (currently MkDocs).
+# Overview
+
+The model layer forms the central intermediate representation used throughout
+doc-forge. Python modules and objects discovered during introspection are
+converted into a hierarchy of documentation models that can later be rendered
+into different documentation formats.
+
+Key components:
+
+- **Project** – Root container representing an entire documented codebase.
+- **Module** – Representation of a Python module or package containing
+  documented members.
+- **DocObject** – Recursive structure representing Python objects such as
+  classes, functions, methods, and attributes.
+
+These models are intentionally **renderer-agnostic**, allowing the same
+documentation structure to be transformed into multiple output formats
+(e.g., MkDocs, MCP, or other renderers).
+
+---
 """
 
 from .project import Project

docforge/models/module.py

@@ -1,7 +1,12 @@
 """
-This module defines the Module class, which represents a Python module or package
-in the doc-forge documentation models. It acts as a container for top-level
-documented objects.
+# Summary
+
+Documentation model representing a Python module or package.
+
+This module defines the `Module` class used in the doc-forge documentation
+model. A `Module` acts as a container for top-level documented objects
+(classes, functions, variables, and other members) discovered during
+introspection.
 """
 
 from typing import Dict, Iterable, Optional
@@ -11,12 +16,21 @@ from docforge.models.object import DocObject
 
 class Module:
     """
-    Represents a documented Python module or package.
+    Representation of a documented Python module or package.
+
+    A `Module` stores metadata about the module itself and maintains a
+    collection of top-level documentation objects discovered during
+    introspection.
 
     Attributes:
-        path: Dotted import path of the module.
-        docstring: Module-level docstring content.
-        members: Dictionary mapping object names to their DocObject representations.
+        path (str):
+            Dotted import path of the module.
+
+        docstring (Optional[str]):
+            Module-level documentation string, if present.
+
+        members (Dict[str, DocObject]):
+            Mapping of object names to their corresponding `DocObject` representations.
     """
 
     def __init__(
@@ -25,11 +39,14 @@ class Module:
         docstring: Optional[str] = None,
     ) -> None:
         """
-        Initialize a new Module.
+        Initialize a Module instance.
 
         Args:
-            path: The dotted path of the module.
-            docstring: The module's docstring, if any.
+            path (str):
+                Dotted import path identifying the module.
+
+            docstring (Optional[str]):
+                Module-level documentation text, if available.
         """
         self.path = path
         self.docstring = docstring
@@ -40,27 +57,35 @@ class Module:
         Add a documented object to the module.
 
         Args:
-            obj: The object to add.
+            obj (DocObject):
+                Documentation object to register as a top-level member of the module.
         """
         self.members[obj.name] = obj
 
     def get_object(self, name: str) -> DocObject:
         """
-        Retrieve a member object by name.
+        Retrieve a documented object by name.
 
         Args:
-            name: The name of the object.
+            name (str):
+                Name of the object to retrieve.
 
         Returns:
-            The requested DocObject.
+            DocObject:
+                The corresponding `DocObject` instance.
+
+        Raises:
+            KeyError:
+                If no object with the given name exists.
         """
         return self.members[name]
 
     def get_all_objects(self) -> Iterable[DocObject]:
         """
-        Get all top-level objects in the module.
+        Return all top-level documentation objects in the module.
 
         Returns:
-            An iterable of DocObject instances.
+            Iterable[DocObject]:
+                An iterable of `DocObject` instances representing the module's public members.
         """
         return self.members.values()

docforge/models/object.py

@@ -1,7 +1,12 @@
 """
-This module defines the DocObject class, the fundamental recursive unit of the
-doc-forge documentation models. A DocObject represents a single Python entity
-(class, function, method, or attribute) and its nested members.
+# Summary
+
+Documentation model representing individual Python objects.
+
+This module defines the `DocObject` class, the fundamental recursive unit of
+the doc-forge documentation model. Each `DocObject` represents a Python
+entity such as a class, function, method, or attribute, and may contain nested
+members that form a hierarchical documentation structure.
 """
 
 from typing import Dict, Iterable, Optional
@@ -9,15 +14,30 @@ from typing import Dict, Iterable, Optional
 
 class DocObject:
     """
-    Represents a documented Python object (class, function, method, etc.).
+    Representation of a documented Python object.
+
+    A `DocObject` models a single Python entity discovered during
+    introspection. Objects may contain nested members, allowing the structure
+    of modules, classes, and other containers to be represented recursively.
 
     Attributes:
-        name: Local name of the object.
-        kind: Type of object (e.g., 'class', 'function', 'attribute').
-        path: Full dotted import path to the object.
-        signature: Callable signature, if applicable.
-        docstring: Raw docstring content extracted from the source.
-        members: Dictionary mapping member names to their DocObject representations.
+        name (str):
+            Local name of the object.
+
+        kind (str):
+            Type of object (for example `class`, `function`, `method`, or `attribute`).
+
+        path (str):
+            Fully qualified dotted path to the object.
+
+        signature (Optional[str]):
+            Callable signature if the object represents a callable.
+
+        docstring (Optional[str]):
+            Raw docstring text extracted from the source code.
+
+        members (Dict[str, DocObject]):
+            Mapping of member names to child `DocObject` instances.
     """
 
     def __init__(
@@ -29,48 +49,67 @@ class DocObject:
         docstring: Optional[str] = None,
     ) -> None:
         """
-        Initialize a new DocObject.
+        Initialize a DocObject instance.
 
         Args:
-            name: The local name of the object.
-            kind: The kind of object (e.g., 'class', 'function').
-            path: The full dotted path to the object.
-            signature: The object's signature (for callable objects).
-            docstring: The object's docstring, if any.
+            name (str):
+                Local name of the object.
+
+            kind (str):
+                Object type identifier (for example `class` or `function`).
+
+            path (str):
+                Fully qualified dotted path of the object.
+
+            signature (Optional[str]):
+                Callable signature if applicable.
+
+            docstring (Optional[str]):
+                Documentation string associated with the object.
         """
         self.name = name
         self.kind = kind
         self.path = path
         self.signature = signature
         self.docstring = docstring
-        self.members: Dict[str, 'DocObject'] = {}
+        self.members: Dict[str, "DocObject"] = {}
 
-    def add_member(self, obj: 'DocObject') -> None:
+    def add_member(self, obj: "DocObject") -> None:
         """
-        Add a child member to this object (e.g., a method to a class).
+        Add a child documentation object.
+
+        This is typically used when attaching methods to classes or
+        nested objects to their parent containers.
 
         Args:
-            obj: The child DocObject to add.
+            obj: Documentation object to add as a member.
         """
         self.members[obj.name] = obj
 
-    def get_member(self, name: str) -> 'DocObject':
+    def get_member(self, name: str) -> "DocObject":
         """
-        Retrieve a child member by name.
+        Retrieve a member object by name.
 
         Args:
-            name: The name of the member.
+            name (str):
+                Name of the member to retrieve.
 
         Returns:
-            The requested DocObject.
+            DocObject:
+                The corresponding `DocObject` instance.
+
+        Raises:
+            KeyError:
+                If the member does not exist.
         """
         return self.members[name]
 
-    def get_all_members(self) -> Iterable['DocObject']:
+    def get_all_members(self) -> Iterable["DocObject"]:
         """
-        Get all members of this object.
+        Return all child members of the object.
 
         Returns:
-            An iterable of child DocObject instances.
+            Iterable[DocObject]:
+                An iterable of `DocObject` instances representing nested members.
         """
         return self.members.values()

docforge/models/project.py

@@ -1,6 +1,11 @@
 """
-This module defines the Project class, the top-level container for a documented
-project. It aggregates multiple Module instances into a single named entity.
+# Summary
+
+Documentation model representing a project.
+
+This module defines the `Project` class, the top-level container used by
+doc-forge to represent a documented codebase. A `Project` aggregates multiple
+modules and provides access to them through a unified interface.
 """
 
 from typing import Dict, Iterable
@@ -10,29 +15,37 @@ from docforge.models.module import Module
 
 class Project:
     """
-    Represents a documentation project, serving as a container for modules.
+    Representation of a documentation project.
+
+    A `Project` serves as the root container for all modules discovered during
+    introspection. Each module is stored by its dotted import path.
 
     Attributes:
-        name: Name of the project.
-        modules: Dictionary mapping module paths to Module instances.
+        name (str):
+            Name of the project.
+
+        modules (Dict[str, Module]):
+            Mapping of module paths to `Module` instances.
     """
 
     def __init__(self, name: str) -> None:
         """
-        Initialize a new Project.
+        Initialize a Project instance.
 
         Args:
-            name: The name of the project.
+            name (str):
+                Name used to identify the documentation project.
         """
         self.name = name
         self.modules: Dict[str, Module] = {}
 
     def add_module(self, module: Module) -> None:
         """
-        Add a module to the project.
+        Register a module in the project.
 
         Args:
-            module: The module to add.
+            module (Module):
+                Module instance to add to the project.
         """
         self.modules[module.path] = module
 
@@ -41,27 +54,35 @@ class Project:
         Retrieve a module by its dotted path.
 
         Args:
-            path: The dotted path of the module (e.g., 'pkg.mod').
+            path (str):
+                Fully qualified dotted module path (for example `pkg.module`).
 
         Returns:
-            The requested Module.
+            Module:
+                The corresponding `Module` instance.
+
+        Raises:
+            KeyError:
+                If the module does not exist in the project.
         """
         return self.modules[path]
 
     def get_all_modules(self) -> Iterable[Module]:
         """
-        Get all modules in the project.
+        Return all modules contained in the project.
 
         Returns:
-            An iterable of Module objects.
+            Iterable[Module]:
+                An iterable of `Module` instances.
         """
         return self.modules.values()
 
     def get_module_list(self) -> list[str]:
         """
-        Get the list of all module dotted paths.
+        Return the list of module import paths.
 
         Returns:
-            A list of module paths.
+            list[str]:
+                A list containing the dotted paths of all modules in the project.
         """
-        return list(self.modules.keys())
+        return list(self.modules.keys())

docforge/nav/__init__.py

@@ -1,17 +1,26 @@
 """
-# Navigation Layer
+Navigation layer for doc-forge.
 
-The `docforge.nav` package manages the mapping between the logical documentation
-structure and the physical files on disk.
+The ``docforge.nav`` package manages the relationship between the logical
+documentation structure defined by the user and the physical documentation
+files generated on disk.
 
-## Workflow
+---
 
-1.  **Spec Definition**: Users define navigation intent in `docforge.nav.yml`.
-2.  **Resolution**: `resolve_nav` matches patterns in the spec to generated `.md` files.
-3.  **Emission**: `MkDocsNavEmitter` produces the final YAML structure for `mkdocs.yml`.
+Workflow
+--------
 
-This abstraction allows doc-forge to support complex grouping and ordering
-independently of the source code's physical layout.
+1. **Specification** – Users define navigation intent in ``docforge.nav.yml``.
+2. **Resolution** – ``resolve_nav`` expands patterns and matches them against
+   generated Markdown files.
+3. **Emission** – ``MkDocsNavEmitter`` converts the resolved structure into
+   the YAML navigation format required by ``mkdocs.yml``.
+
+This layer separates documentation organization from the underlying source
+code layout, enabling flexible grouping, ordering, and navigation structures
+independent of module hierarchy.
+
+---
 """
 
 from .spec import NavSpec, load_nav_spec

docforge/nav/mkdocs.py

@@ -1,7 +1,9 @@
 """
-This module provides the MkDocsNavEmitter, which converts a ResolvedNav instance
-into the specific YAML-ready list structure expected by the MkDocs 'nav'
-configuration.
+MkDocs navigation emitter.
+
+This module provides the ``MkDocsNavEmitter`` class, which converts a
+``ResolvedNav`` instance into the navigation structure required by the
+MkDocs ``nav`` configuration.
 """
 
 from pathlib import Path
@@ -12,19 +14,24 @@ from docforge.nav.resolver import ResolvedNav
 
 class MkDocsNavEmitter:
     """
-    Emitter responsible for transforming a ResolvedNav into an MkDocs-compatible
-    navigation structure.
+    Emit MkDocs navigation structures from resolved navigation data.
+
+    The emitter transforms a ``ResolvedNav`` object into the YAML-compatible
+    list structure expected by the MkDocs ``nav`` configuration field.
     """
 
     def emit(self, nav: ResolvedNav) -> List[Dict[str, Any]]:
         """
-        Generate a list of navigation entries for mkdocs.yml.
+        Generate a navigation structure for ``mkdocs.yml``.
 
         Args:
-            nav: The resolved navigation data.
+            nav: Resolved navigation data describing documentation groups
+                and their associated Markdown files.
 
         Returns:
-            A list of dictionary mappings representing the MkDocs navigation.
+            A list of dictionaries representing the MkDocs navigation layout.
+            Each dictionary maps a navigation label to a page or a list of
+            pages.
         """
         result: List[Dict[str, Any]] = []
 
@@ -45,16 +52,18 @@ class MkDocsNavEmitter:
 
     def _to_relative(self, path: Path, docs_root: Path | None) -> str:
         """
-        Convert a filesystem path to a path relative to the documentation root.
-        This handles both absolute and relative filesystem paths, ensuring the
-        output is compatible with MkDocs navigation requirements.
+        Convert a filesystem path into a documentation-relative path.
+
+        This method normalizes paths so they can be used in MkDocs navigation.
+        It handles both absolute and relative filesystem paths and ensures the
+        resulting path is relative to the documentation root.
 
         Args:
-            path: The path to convert.
-            docs_root: The root directory for documentation.
+            path: Filesystem path to convert.
+            docs_root: Root directory of the documentation sources.
 
         Returns:
-            A string representing the relative POSIX-style path.
+            POSIX-style path relative to the documentation root.
         """
         if docs_root and path.is_absolute():
             try:
@@ -67,6 +76,6 @@ class MkDocsNavEmitter:
             docs_root_str = docs_root.as_posix()
             if path_str.startswith(docs_root_str + "/"):
                 return path_str[len(docs_root_str) + 1:]
-        
+
         # Fallback for other cases
         return path.as_posix().split("/docs/", 1)[-1]

docforge/nav/resolver.py

@@ -1,7 +1,8 @@
 """
-This module contains the logic for resolving a NavSpec against the physical
-filesystem. It expands globs and validates that all referenced documents
-actually exist on disk.
+Navigation resolution utilities.
+
+This module resolves a ``NavSpec`` against the filesystem by expanding glob
+patterns and validating that referenced documentation files exist.
 """
 
 from pathlib import Path
@@ -14,12 +15,15 @@ from docforge.nav.spec import NavSpec
 
 class ResolvedNav:
     """
-    Represents a navigation structure where all patterns and paths have been
-    resolved against the actual filesystem contents.
+    Resolved navigation structure.
+
+    A ``ResolvedNav`` represents navigation data after glob patterns have been
+    expanded and paths validated against the filesystem.
 
     Attributes:
-        home: Resolved relative path to the home page.
-        groups: Mapping of group titles to lists of absolute or relative Path objects.
+        home: Relative path to the documentation home page.
+        groups: Mapping of navigation group titles to lists of resolved
+            documentation file paths.
     """
 
     def __init__(
@@ -32,9 +36,9 @@ class ResolvedNav:
         Initialize a ResolvedNav instance.
 
         Args:
-            home: The relative path to the project home page.
-            groups: A mapping of group names to their resolved filesystem paths.
-            docs_root: The root documentation directory.
+            home: Relative path to the home page within the documentation root.
+            groups: Mapping of group titles to resolved documentation file paths.
+            docs_root: Root directory of the documentation source files.
         """
         self.home = home
         self.groups = groups
@@ -42,15 +46,20 @@ class ResolvedNav:
 
     def all_files(self) -> Iterable[Path]:
         """
-        Get an iterable of all resolved files in the navigation structure.
+        Iterate over all files referenced by the navigation structure.
 
         Returns:
-            An iterable of Path objects.
+            An iterable of ``Path`` objects representing documentation files.
+
+        Raises:
+            RuntimeError: If the home page is defined but the documentation
+                root is not available for resolution.
         """
         if self.home:
             if self._docs_root is None:
                 raise RuntimeError("docs_root is required to resolve home path")
             yield self._docs_root / self.home
+
         for paths in self.groups.values():
             for p in paths:
                 yield p
@@ -61,34 +70,37 @@ def resolve_nav(
     docs_root: Path,
 ) -> ResolvedNav:
     """
-    Create a ResolvedNav by processing a NavSpec against the filesystem.
-    This expands globs and validates the existence of referenced files.
+    Resolve a navigation specification against the filesystem.
+
+    The function expands glob patterns defined in a ``NavSpec`` and verifies
+    that referenced documentation files exist within the documentation root.
 
     Args:
-        spec: The navigation specification to resolve.
-        docs_root: The root directory for documentation files.
+        spec: Navigation specification describing documentation layout.
+        docs_root: Root directory containing documentation Markdown files.
 
     Returns:
-        A ResolvedNav instance.
+        A ``ResolvedNav`` instance containing validated navigation paths.
 
     Raises:
-        FileNotFoundError: If a pattern doesn't match any files or the docs_root doesn't exist.
+        FileNotFoundError: If the documentation root does not exist or a
+            navigation pattern does not match any files.
     """
     if not docs_root.exists():
         raise FileNotFoundError(docs_root)
 
     def resolve_pattern(pattern: str) -> List[Path]:
         """
-        Resolve a single glob pattern relative to the docs_root.
+        Resolve a glob pattern relative to the documentation root.
 
         Args:
-            pattern: The glob pattern to resolve.
+            pattern: Glob pattern used to match documentation files.
 
         Returns:
-            A sorted list of matching Path objects.
+            A sorted list of matching ``Path`` objects.
 
         Raises:
-            FileNotFoundError: If the pattern doesn't match any files.
+            FileNotFoundError: If the pattern does not match any files.
         """
         full = docs_root / pattern
         matches = sorted(
@@ -100,7 +112,7 @@ def resolve_nav(
 
         return matches
 
-    # Resolve home
+    # Resolve home page
     home: str | None = None
     if spec.home:
         home_path = docs_root / spec.home
@@ -108,7 +120,7 @@ def resolve_nav(
             raise FileNotFoundError(spec.home)
         home = spec.home
 
-    # Resolve groups
+    # Resolve navigation groups
     resolved_groups: Dict[str, List[Path]] = {}
 
     for group, patterns in spec.groups.items():

docforge/nav/spec.py

@@ -1,7 +1,9 @@
 """
-This module defines the NavSpec class, which represents the user's intent for
-documentation navigation as defined in a YAML specification (usually
-docforge.nav.yml).
+Navigation specification model.
+
+This module defines the ``NavSpec`` class, which represents the navigation
+structure defined by the user in the doc-forge navigation specification
+(typically ``docforge.nav.yml``).
 """
 
 from pathlib import Path
@@ -12,11 +14,16 @@ import yaml
 
 class NavSpec:
     """
-    Parsed representation of the docforge navigation specification file.
+    Parsed representation of a navigation specification.
+
+    A ``NavSpec`` describes the intended documentation navigation layout before
+    it is resolved against the filesystem.
 
     Attributes:
-        home: Path to the home document (e.g., 'index.md').
-        groups: Mapping of group titles to lists of path patterns/globs.
+        home: Relative path to the documentation home page (for example
+            ``index.md``).
+        groups: Mapping of navigation group titles to lists of file patterns
+            or glob expressions.
     """
 
     def __init__(
@@ -25,11 +32,12 @@ class NavSpec:
         groups: Dict[str, List[str]],
     ) -> None:
         """
-        Initialize a NavSpec.
+        Initialize a NavSpec instance.
 
         Args:
-            home: The path to the home document.
-            groups: A mapping of group names to lists of path patterns (globs).
+            home: Relative path to the home document.
+            groups: Mapping of group names to lists of path patterns
+                (glob expressions).
         """
         self.home = home
         self.groups = groups
@@ -37,17 +45,18 @@ class NavSpec:
     @classmethod
     def load(cls, path: Path) -> "NavSpec":
         """
-        Load a NavSpec from a YAML file.
+        Load a navigation specification from a YAML file.
 
         Args:
-            path: The filesystem path to the YAML file.
+            path: Filesystem path to the navigation specification file.
 
         Returns:
-            A NavSpec instance.
+            A ``NavSpec`` instance representing the parsed configuration.
 
         Raises:
-            FileNotFoundError: If the path does not exist.
-            ValueError: If the file content is not a valid NavSpec mapping.
+            FileNotFoundError: If the specified file does not exist.
+            ValueError: If the file contents are not a valid navigation
+                specification.
         """
         if not path.exists():
             raise FileNotFoundError(path)
@@ -78,33 +87,45 @@ class NavSpec:
 
     def all_patterns(self) -> List[str]:
         """
-        Get all path patterns referenced in the specification.
+        Return all path patterns referenced by the specification.
 
         Returns:
-            A list of all patterns (home plus all groups).
+            A list containing the home document (if defined) and all
+            group pattern entries.
         """
         patterns: List[str] = []
+
         if self.home:
             patterns.append(self.home)
+
         for items in self.groups.values():
             patterns.extend(items)
+
         return patterns
 
 
 def load_nav_spec(path: Path) -> NavSpec:
     """
-    Utility function to load a NavSpec from a file.
+    Load a navigation specification file.
+
+    This helper function reads a YAML navigation file and constructs a
+    corresponding ``NavSpec`` instance.
 
     Args:
         path: Path to the navigation specification file.
 
     Returns:
-        A loaded NavSpec instance.
+        A ``NavSpec`` instance representing the parsed specification.
+
+    Raises:
+        FileNotFoundError: If the specification file does not exist.
+        ValueError: If the YAML structure is invalid.
     """
     if not path.exists():
         raise FileNotFoundError(path)
 
     data = yaml.safe_load(path.read_text(encoding="utf-8"))
+
     if not isinstance(data, dict):
         raise ValueError("Nav spec must be a YAML mapping")
 

docforge/renderers/__init__.py

@@ -1,20 +1,34 @@
 """
-# Renderers Layer
+# Summary
 
-The `docforge.renderers` package handles the transformation of the internal
-documentation models into physical files formatted for specific documentation
-engines.
+Renderers layer for doc-forge.
 
-## Current Implementations
+The `docforge.renderers` package transforms the internal documentation
+models into files formatted for specific documentation systems.
 
-- **MkDocsRenderer**: Generates Markdown files utilizing the `mkdocstrings`
-  syntax. It automatically handles package/module hierarchy and generates
-  `index.md` files for packages.
+---
 
-## Extending
+# Overview
 
-To add a new renderer, implement the `DocRenderer` protocol defined in
-`docforge.renderers.base`.
+Renderers consume the doc-forge project model and generate output suitable
+for documentation tools or machine interfaces.
+
+Current implementations:
+
+- **MkDocsRenderer** – Produces Markdown files compatible with MkDocs and
+  the `mkdocstrings` plugin. It automatically handles package hierarchy
+  and generates `index.md` files for packages.
+- **MCPRenderer** – Emits structured JSON resources designed for consumption
+  by Model Context Protocol (MCP) clients.
+
+---
+
+# Extending
+
+New renderers can be added by implementing the `DocRenderer` protocol
+defined in `docforge.renderers.base`.
+
+---
 """
 
 from .mkdocs_renderer import MkDocsRenderer

docforge/renderers/base.py

@@ -1,7 +1,11 @@
 """
-This module defines the base interfaces and configuration containers for
-doc-forge renderers. All renderer implementations should adhere to the
-DocRenderer protocol.
+# Summary
+
+Renderer base interfaces and configuration models.
+
+This module defines the base protocol and configuration container used by
+doc-forge renderers. Concrete renderer implementations should implement the
+`DocRenderer` protocol.
 """
 
 from pathlib import Path
@@ -14,12 +18,28 @@ class RendererConfig:
     """
     Configuration container for documentation renderers.
 
-    Args:
-        out_dir: The directory where documentation files should be written.
-        project: The introspected project models to be rendered.
+    A `RendererConfig` instance groups together the project model and the
+    output directory used during rendering.
+
+    Attributes:
+        out_dir (Path):
+            Directory where generated documentation files will be written.
+
+        project (Project):
+            Documentation project model to be rendered.
     """
 
     def __init__(self, out_dir: Path, project: Project) -> None:
+        """
+        Initialize a RendererConfig instance.
+
+        Args:
+            out_dir (Path):
+                Target directory where documentation files should be written.
+
+            project (Project):
+                Introspected project model to render.
+        """
         self.out_dir = out_dir
         self.project = project
 
@@ -27,6 +47,9 @@ class RendererConfig:
 class DocRenderer(Protocol):
     """
     Protocol defining the interface for documentation renderers.
+
+    Implementations of this protocol are responsible for transforming a
+    `Project` model into renderer-specific documentation sources.
     """
 
     name: str
@@ -37,10 +60,13 @@ class DocRenderer(Protocol):
         out_dir: Path,
     ) -> None:
         """
-        Generate renderer-specific source files for the given project.
+        Generate renderer-specific documentation sources.
 
         Args:
-            project: The project models containing modules and objects.
-            out_dir: Target directory for the generated files.
+            project (Project):
+                Project model containing modules and documentation objects.
+
+            out_dir (Path):
+                Directory where generated documentation sources should be written.
         """
         ...

docforge/renderers/mcp_renderer.py

@@ -1,3 +1,12 @@
+"""
+# Summary
+
+MCP renderer implementation.
+
+This module defines the `MCPRenderer` class, which generates documentation
+resources compatible with the Model Context Protocol (MCP).
+"""
+
 import json
 from pathlib import Path
 from typing import Dict, List
@@ -7,14 +16,28 @@ from docforge.models import Project, Module, DocObject
 
 class MCPRenderer:
     """
-    Renderer that emits MCP-native JSON resources from docforge models.
+    Renderer that generates MCP-compatible documentation resources.
+
+    This renderer converts doc-forge project models into structured JSON
+    resources suitable for consumption by systems implementing the Model
+    Context Protocol (MCP).
     """
 
     name = "mcp"
 
     def generate_sources(self, project: Project, out_dir: Path) -> None:
         """
-        Generate MCP-compatible JSON resources and navigation for the project.
+        Generate MCP documentation resources for a project.
+
+        The renderer serializes each module into a JSON resource and produces
+        supporting metadata files such as `nav.json` and `index.json`.
+
+        Args:
+            project (Project):
+                Documentation project model to render.
+
+            out_dir (Path):
+                Directory where MCP resources will be written.
         """
         modules_dir = out_dir / "modules"
         modules_dir.mkdir(parents=True, exist_ok=True)
@@ -50,7 +73,14 @@ class MCPRenderer:
 
     def _write_module(self, module: Module, modules_dir: Path) -> None:
         """
-        Serialize a module into an MCP JSON resource.
+        Serialize a module into an MCP resource file.
+
+        Args:
+            module (Module):
+                Module instance to serialize.
+
+            modules_dir (Path):
+                Directory where module JSON files are stored.
         """
         payload = {
             "module": module.path,
@@ -63,7 +93,15 @@ class MCPRenderer:
 
     def _render_module(self, module: Module) -> Dict:
         """
-        Render a Module into MCP-friendly structured data.
+        Convert a Module model into MCP-compatible structured data.
+
+        Args:
+            module (Module):
+                Module instance to convert.
+
+        Returns:
+            Dict:
+                Dictionary representing the module and its documented objects.
         """
         data: Dict = {
             "path": module.path,
@@ -78,7 +116,15 @@ class MCPRenderer:
 
     def _render_object(self, obj: DocObject) -> Dict:
         """
-        Recursively render a DocObject into structured MCP data.
+        Recursively convert a DocObject into structured MCP data.
+
+        Args:
+            obj (DocObject):
+                Documentation object to convert.
+
+        Returns:
+            Dict:
+                Dictionary describing the object and any nested members.
         """
         data: Dict = {
             "name": obj.name,
@@ -99,4 +145,15 @@ class MCPRenderer:
 
     @staticmethod
     def _json(data: Dict) -> str:
+        """
+        Serialize data to formatted JSON.
+
+        Args:
+            data (Dict):
+                Dictionary to serialize.
+
+        Returns:
+            str:
+                JSON string formatted with indentation and UTF-8 compatibility.
+        """
         return json.dumps(data, indent=2, ensure_ascii=False)

docforge/renderers/mkdocs_renderer.py

@@ -1,91 +1,305 @@
 """
-This module implements the MkDocsRenderer, which generates Markdown source files
-compatible with the MkDocs 'material' theme and 'mkdocstrings' extension.
+# Summary
+
+MkDocs renderer implementation.
+
+This module defines the `MkDocsRenderer` class, which generates Markdown
+documentation sources compatible with MkDocs Material and the mkdocstrings
+plugin.
+
+The renderer ensures a consistent documentation structure by:
+
+- Creating a root `index.md` if one does not exist
+- Generating package index pages automatically
+- Linking child modules within parent package pages
+- Optionally generating `README.md` from the root package docstring
 """
 
 from pathlib import Path
-
-from docforge.models import Project
+from docforge.models import Project, Module
 
 
 class MkDocsRenderer:
     """
-    Renderer that generates Markdown source files formatted for the MkDocs
-    'mkdocstrings' plugin.
+    Renderer that produces Markdown documentation for MkDocs.
+
+    Generated pages use mkdocstrings directives to reference Python modules,
+    allowing MkDocs to render API documentation dynamically.
     """
 
     name = "mkdocs"
 
-    def generate_sources(self, project: Project, out_dir: Path) -> None:
+    # -------------------------
+    # Public API
+    # -------------------------
+
+    def generate_sources(
+        self,
+        project: Project,
+        out_dir: Path,
+        module_is_source: bool | None = None,
+    ) -> None:
         """
-        Produce a set of Markdown files in the output directory based on the
-        provided Project models.
+        Generate Markdown documentation files for a project.
+
+        This method renders a documentation structure from the provided
+        project model and writes the resulting Markdown files to the
+        specified output directory.
 
         Args:
-            project: The project models to render.
-            out_dir: Target directory for documentation files.
+            project (Project):
+                Project model containing modules to document.
+
+            out_dir (Path):
+                Directory where generated Markdown files will be written.
+
+            module_is_source (bool, optional):
+                If True, treat the specified module as the documentation root
+                rather than nesting it inside a folder.
         """
+        out_dir.mkdir(parents=True, exist_ok=True)
+        self._ensure_root_index(project, out_dir)
+
         modules = list(project.get_all_modules())
         paths = {m.path for m in modules}
 
-        # Package detection (level-agnostic)
+        # Detect packages (modules with children)
         packages = {
             p for p in paths
             if any(other.startswith(p + ".") for other in paths)
         }
 
         for module in modules:
-            self._write_module(module, packages, out_dir)
+            self._write_module(
+                module,
+                packages,
+                out_dir,
+                module_is_source,
+            )
+
+    def generate_readme(
+        self,
+        project: Project,
+        docs_dir: Path,
+        module_is_source: bool | None = None,
+    ) -> None:
+        """
+        Generate a `README.md` file from the root module docstring.
+
+        Behavior:
+
+        - If `module_is_source` is True, `README.md` is written to the project
+          root directory.
+        - If False, README generation is currently not implemented.
+
+        Args:
+            project (Project):
+                Project model containing documentation metadata.
+
+            docs_dir (Path):
+                Directory containing generated documentation sources.
+
+            module_is_source (bool, optional):
+                Whether the module is treated as the project source root.
+        """
+
+        if not module_is_source:
+            # Future: support README generation per module
+            return
+
+        readme_path = docs_dir.parent / "README.md"
+
+        root_module = None
+        for module in project.get_all_modules():
+            if module.path == project.name:
+                root_module = module
+                break
+
+        if root_module is None:
+            return
+
+        doc = ""
+
+        if root_module.docstring:
+            doc = getattr(
+                root_module.docstring,
+                "value",
+                str(root_module.docstring),
+            )
+
+        content = (
+            f"# {project.name}\n\n"
+            f"{doc.strip()}\n"
+        )
+
+        if not readme_path.exists() or readme_path.read_text(encoding="utf-8") != content:
+            readme_path.write_text(
+                content,
+                encoding="utf-8",
+            )
 
     # -------------------------
     # Internal helpers
     # -------------------------
-    def _write_module(self, module, packages: set[str], out_dir: Path) -> None:
+
+    def _find_root_module(self, project: Project) -> Module | None:
         """
-        Write a single module's documentation file. Packages are written as
-        'index.md' inside their respective directories.
+        Locate the root module corresponding to the project name.
 
         Args:
-            module: The module to write.
-            packages: A set of module paths that are identified as packages.
-            out_dir: The base output directory.
+            project (Project):
+                Project model to inspect.
+
+        Returns:
+            Optional[Module]:
+                The root `Module` if found, otherwise `None`.
         """
+        for module in project.get_all_modules():
+            if module.path == project.name:
+                return module
+        return None
+
+    def _write_module(
+        self,
+        module: Module,
+        packages: set[str],
+        out_dir: Path,
+        module_is_source: bool | None = None,
+    ) -> None:
+        """
+        Write documentation for a single module.
+
+        Package modules are rendered as `index.md` files inside their
+        corresponding directories, while leaf modules are written as
+        standalone Markdown pages.
+
+        Args:
+            module (Module):
+                Module to render.
+
+            packages (set[str]):
+                Set of module paths identified as packages.
+
+            out_dir (Path):
+                Base directory for generated documentation files.
+
+            module_is_source (bool, optional):
+                Whether the module acts as the documentation root directory.
+        """
+
         parts = module.path.split(".")
 
+        if module_is_source:
+            module_name, parts = parts[0], parts[1:]
+        else:
+            module_name, parts = parts[0], parts
+
         if module.path in packages:
-            # package → index.md
             dir_path = out_dir.joinpath(*parts)
             dir_path.mkdir(parents=True, exist_ok=True)
 
             md_path = dir_path / "index.md"
-            title = parts[-1].replace("_", " ").title()
+            link_target = f"{parts[-1]}/" if parts else None
         else:
-            # leaf module → <name>.md
             dir_path = out_dir.joinpath(*parts[:-1])
             dir_path.mkdir(parents=True, exist_ok=True)
 
             md_path = dir_path / f"{parts[-1]}.md"
-            title = parts[-1].replace("_", " ").title()
+            link_target = f"{parts[-1]}.md" if parts else None
 
+        title = parts[-1].replace("_", " ").title() if parts else module_name
         content = self._render_markdown(title, module.path)
 
-        if md_path.exists() and md_path.read_text(encoding="utf-8") == content:
-            return
+        if not md_path.exists() or md_path.read_text(encoding="utf-8") != content:
+            md_path.write_text(content, encoding="utf-8")
 
-        md_path.write_text(content, encoding="utf-8")
+        if not module_is_source:
+            self._ensure_parent_index(parts, out_dir, link_target, title)
 
     def _render_markdown(self, title: str, module_path: str) -> str:
         """
-        Generate the Markdown content for a module file.
+        Generate Markdown content for a module documentation page.
 
         Args:
-            title: The display title for the page.
-            module_path: The dotted path of the module to document.
+            title (str):
+                Page title displayed in the documentation.
+
+            module_path (str):
+                Dotted import path of the module.
 
         Returns:
-            A string containing the Markdown source.
+            str:
+                Markdown source containing a mkdocstrings directive.
         """
         return (
             f"# {title}\n\n"
             f"::: {module_path}\n"
         )
+
+    def _ensure_root_index(
+        self,
+        project: Project,
+        out_dir: Path,
+    ) -> None:
+        """
+        Ensure that the root `index.md` page exists.
+
+        Args:
+            project (Project):
+                Project model used for the page title.
+
+            out_dir (Path):
+                Documentation output directory.
+        """
+        root_index = out_dir / "index.md"
+
+        if not root_index.exists():
+            root_index.write_text(
+                f"# {project.name}\n\n"
+                "## Modules\n\n",
+                encoding="utf-8",
+            )
+
+    def _ensure_parent_index(
+        self,
+        parts: list[str],
+        out_dir: Path,
+        link_target: str,
+        title: str,
+    ) -> None:
+        """
+        Ensure that parent package index files exist and contain links to
+        child modules.
+
+        Args:
+            parts (list[str]):
+                Module path components.
+
+            out_dir (Path):
+                Documentation output directory.
+
+            link_target (str):
+                Link target used in the parent index.
+
+            title (str):
+                Display title for the link.
+        """
+        if len(parts) == 1:
+            parent_index = out_dir / "index.md"
+        else:
+            parent_dir = out_dir.joinpath(*parts[:-1])
+            parent_dir.mkdir(parents=True, exist_ok=True)
+            parent_index = parent_dir / "index.md"
+
+            if not parent_index.exists():
+                parent_title = parts[-2].replace("_", " ").title()
+                parent_index.write_text(
+                    f"# {parent_title}\n\n",
+                    encoding="utf-8",
+                )
+
+        content = parent_index.read_text(encoding="utf-8")
+
+        link = f"- [{title}]({link_target})\n"
+        if link not in content:
+            parent_index.write_text(content + link, encoding="utf-8")

docforge/renderers/mkdocs_renderer.pyi

@@ -1,17 +1,34 @@
 from pathlib import Path
-from typing import Set
-
 from docforge.models import Project, Module
 
 
 class MkDocsRenderer:
     name: str
 
-    def generate_sources(self, project: Project, out_dir: Path) -> None: ...
+    def generate_sources(
+        self,
+        project: Project,
+        out_dir: Path,
+        module_is_source: bool | None = None,
+    ) -> None: ...
+
+    def generate_readme(
+        self,
+        project: Project,
+        docs_dir: Path,
+        module_is_source: bool | None = None,
+    ) -> None:
+
     def _write_module(
         self,
         module: Module,
-        packages: Set[str],
+        packages: set[str],
         out_dir: Path,
+        module_is_source: bool | None = None,
     ) -> None: ...
+
     def _render_markdown(self, title: str, module_path: str) -> str: ...
+
+    def _ensure_root_index(self, project, out_dir) -> None: ...
+
+    def _ensure_parent_index(self, parts, out_dir, link_target, title) -> None: ...

docforge/servers/__init__.py

@@ -1,5 +1,17 @@
+"""
+# Summary
+
+Server layer for doc-forge.
+
+This module exposes server implementations used to provide live access
+to generated documentation resources. Currently, it includes the MCP
+documentation server.
+
+---
+"""
+
 from .mcp_server import MCPServer
 
 __all__ = [
     "MCPServer",
-]
+]

docforge/servers/mcp_server.py

@@ -1,3 +1,12 @@
+"""
+# Summary
+
+MCP server implementation.
+
+This module defines the `MCPServer` class, which serves pre-generated
+documentation bundles through the Model Context Protocol (MCP).
+"""
+
 from __future__ import annotations
 
 import json
@@ -9,16 +18,23 @@ from mcp.server.fastmcp import FastMCP
 
 class MCPServer:
     """
-    MCP server for serving a pre-built MCP documentation bundle.
+    MCP server for serving a pre-generated documentation bundle.
+
+    The server exposes documentation resources and diagnostic tools through
+    MCP endpoints backed by JSON files generated by the MCP renderer.
     """
 
     def __init__(self, mcp_root: Path, name: str) -> None:
         """
-        Initialize the MCPServer.
+        Initialize the MCP server.
 
         Args:
-            mcp_root: Path to the directory containing pre-built MCP JSON resources.
-            name: Name of the MCP server.
+            mcp_root (Path):
+                Directory containing the generated MCP documentation bundle
+                (for example `index.json`, `nav.json`, and `modules/`).
+
+            name (str):
+                Identifier used for the MCP server instance.
         """
         self.mcp_root = mcp_root
         self.app = FastMCP(name)
@@ -32,19 +48,26 @@ class MCPServer:
 
     def _read_json(self, path: Path) -> Any:
         """
-        Read and parse a JSON file, returning diagnostic errors if missing.
+        Load and parse a JSON file.
+
+        If the file does not exist, a structured error response is returned
+        instead of raising an exception.
 
         Args:
-            path: Path to the JSON file.
+            path (Path):
+                Path to the JSON file to read.
 
         Returns:
-            The parsed JSON data or an error dictionary.
+            Any:
+                Parsed JSON data if the file exists, otherwise an error dictionary
+                describing the missing resource.
         """
         if not path.exists():
             return {
                 "error": "not_found",
                 "path": str(path),
             }
+
         return json.loads(path.read_text(encoding="utf-8"))
 
     # ------------------------------------------------------------------
@@ -53,8 +76,16 @@ class MCPServer:
 
     def _register_resources(self) -> None:
         """
-        Register MCP resources for index, nav, and individual modules.
+        Register MCP resource endpoints.
+
+        The server exposes documentation resources through the following
+        endpoints:
+
+        - `docs://index` – Project metadata
+        - `docs://nav` – Navigation structure
+        - `docs://modules/{module}` – Individual module documentation
         """
+
         @self.app.resource("docs://index")
         def index():
             return self._read_json(self.mcp_root / "index.json")
@@ -70,26 +101,36 @@ class MCPServer:
             )
 
     # ------------------------------------------------------------------
-    # MCP tools (optional / diagnostic)
+    # MCP tools
     # ------------------------------------------------------------------
 
     def _register_tools(self) -> None:
         """
-        Register high-level MCP tools for diagnostics.
+        Register optional MCP diagnostic tools.
+
+        These tools provide lightweight endpoints useful for verifying that
+        the MCP server is operational.
         """
+
         @self.app.tool()
         def ping() -> str:
+            """Return a simple health check response."""
             return "pong"
 
     # ------------------------------------------------------------------
     # Server lifecycle
     # ------------------------------------------------------------------
 
-    def run(self, transport: Literal["stdio", "sse", "streamable-http"] = "streamable-http") -> None:
+    def run(
+        self,
+        transport: Literal["stdio", "sse", "streamable-http"] = "streamable-http",
+    ) -> None:
         """
         Start the MCP server.
 
         Args:
-            transport: MCP transport (default: streamable-http)
+            transport (Literal["stdio", "sse", "streamable-http"]):
+                Transport mechanism used by the MCP server. Supported options
+                include `stdio`, `sse`, and `streamable-http`.
         """
         self.app.run(transport=transport)

docforge/templates/mkdocs.sample.yml

@@ -4,16 +4,30 @@ theme:
     - scheme: slate
       primary: deep purple
       accent: cyan
+
   font:
     text: Inter
     code: JetBrains Mono
+
   features:
-    - navigation.tabs
+    # Navigation
+    - navigation.sections
     - navigation.expand
     - navigation.top
     - navigation.instant
+    - navigation.tracking
+    - navigation.indexes
+
+    # Content
     - content.code.copy
     - content.code.annotate
+    - content.tabs.link
+    - content.action.edit
+
+    # Search UX
+    - search.highlight
+    - search.share
+    - search.suggest
 
 plugins:
   - search
@@ -31,3 +45,34 @@ plugins:
             annotations_path: brief
             show_root_heading: true
             group_by_category: true
+            show_category_heading: true
+            show_object_full_path: false
+            show_symbol_type_heading: true
+
+markdown_extensions:
+  - pymdownx.superfences
+  - pymdownx.inlinehilite
+  - pymdownx.snippets
+
+  - admonition
+  - pymdownx.details
+
+  - pymdownx.superfences
+  - pymdownx.highlight:
+      linenums: true
+      anchor_linenums: true
+      line_spans: __span
+      pygments_lang_class: true
+
+  - pymdownx.tabbed:
+      alternate_style: true
+
+  - pymdownx.tasklist:
+      custom_checkbox: true
+
+  - tables
+  - footnotes
+
+  - pymdownx.caret
+  - pymdownx.tilde
+  - pymdownx.mark

docs/cli/commands.md

@@ -0,0 +1,3 @@
+# Commands
+
+::: docforge.cli.commands

docs/cli/mcp_utils.md

@@ -0,0 +1,3 @@
+# Mcp Utils
+
+::: docforge.cli.mcp_utils

docs/cli/mkdocs_utils.md

@@ -0,0 +1,3 @@
+# Mkdocs Utils
+
+::: docforge.cli.mkdocs_utils

docs/docforge/cli/mkdocs.md

@@ -1,3 +0,0 @@
-# Mkdocs
-
-::: docforge.cli.mkdocs

docs/index.md

@@ -1,3 +1,3 @@
-# Docforge
+# docforge
 
 ::: docforge

docs/servers/index.md

@@ -0,0 +1,3 @@
+# Servers
+
+::: docforge.servers

docs/servers/mcp_server.md

@@ -0,0 +1,3 @@
+# Mcp Server
+
+::: docforge.servers.mcp_server

mcp_docs/index.json

@@ -1,6 +1,6 @@
 {
   "project": "docforge",
   "type": "docforge-model",
-  "modules_count": 20,
+  "modules_count": 22,
   "source": "docforge"
 }

mcp_docs/modules/docforge.cli.commands.json

@@ -0,0 +1,377 @@
+{
+  "module": "docforge.cli.commands",
+  "content": {
+    "path": "docforge.cli.commands",
+    "docstring": "# Summary\n\nCommand definitions for the doc-forge CLI.\n\nProvides the CLI structure using Click, including build, serve, and tree commands.",
+    "objects": {
+      "click": {
+        "name": "click",
+        "kind": "alias",
+        "path": "docforge.cli.commands.click",
+        "signature": "<bound method Alias.signature of Alias('click', 'click')>",
+        "docstring": null
+      },
+      "Path": {
+        "name": "Path",
+        "kind": "alias",
+        "path": "docforge.cli.commands.Path",
+        "signature": "<bound method Alias.signature of Alias('Path', 'pathlib.Path')>",
+        "docstring": null
+      },
+      "Sequence": {
+        "name": "Sequence",
+        "kind": "alias",
+        "path": "docforge.cli.commands.Sequence",
+        "signature": "<bound method Alias.signature of Alias('Sequence', 'typing.Sequence')>",
+        "docstring": null
+      },
+      "Optional": {
+        "name": "Optional",
+        "kind": "alias",
+        "path": "docforge.cli.commands.Optional",
+        "signature": "<bound method Alias.signature of Alias('Optional', 'typing.Optional')>",
+        "docstring": null
+      },
+      "GriffeLoader": {
+        "name": "GriffeLoader",
+        "kind": "class",
+        "path": "docforge.cli.commands.GriffeLoader",
+        "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.loaders.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.",
+        "members": {
+          "load_project": {
+            "name": "load_project",
+            "kind": "function",
+            "path": "docforge.cli.commands.GriffeLoader.load_project",
+            "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_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."
+          }
+        }
+      },
+      "mkdocs_utils": {
+        "name": "mkdocs_utils",
+        "kind": "module",
+        "path": "docforge.cli.commands.mkdocs_utils",
+        "signature": "<bound method Alias.signature of Alias('mkdocs_utils', 'docforge.cli.mkdocs_utils')>",
+        "docstring": "# Summary\n\nUtilities for working with MkDocs in the doc-forge CLI.",
+        "members": {
+          "Path": {
+            "name": "Path",
+            "kind": "alias",
+            "path": "docforge.cli.commands.mkdocs_utils.Path",
+            "signature": "<bound method Alias.signature of Alias('Path', 'docforge.cli.mkdocs_utils.Path')>",
+            "docstring": null
+          },
+          "resources": {
+            "name": "resources",
+            "kind": "alias",
+            "path": "docforge.cli.commands.mkdocs_utils.resources",
+            "signature": "<bound method Alias.signature of Alias('resources', 'docforge.cli.mkdocs_utils.resources')>",
+            "docstring": null
+          },
+          "click": {
+            "name": "click",
+            "kind": "alias",
+            "path": "docforge.cli.commands.mkdocs_utils.click",
+            "signature": "<bound method Alias.signature of Alias('click', 'docforge.cli.mkdocs_utils.click')>",
+            "docstring": null
+          },
+          "yaml": {
+            "name": "yaml",
+            "kind": "alias",
+            "path": "docforge.cli.commands.mkdocs_utils.yaml",
+            "signature": "<bound method Alias.signature of Alias('yaml', 'docforge.cli.mkdocs_utils.yaml')>",
+            "docstring": null
+          },
+          "GriffeLoader": {
+            "name": "GriffeLoader",
+            "kind": "class",
+            "path": "docforge.cli.commands.mkdocs_utils.GriffeLoader",
+            "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.cli.mkdocs_utils.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.",
+            "members": {
+              "load_project": {
+                "name": "load_project",
+                "kind": "function",
+                "path": "docforge.cli.commands.mkdocs_utils.GriffeLoader.load_project",
+                "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_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."
+              }
+            }
+          },
+          "discover_module_paths": {
+            "name": "discover_module_paths",
+            "kind": "function",
+            "path": "docforge.cli.commands.mkdocs_utils.discover_module_paths",
+            "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.cli.mkdocs_utils.discover_module_paths')>",
+            "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, optional):\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.cli.commands.mkdocs_utils.MkDocsRenderer",
+            "signature": "<bound method Alias.signature of Alias('MkDocsRenderer', 'docforge.cli.mkdocs_utils.MkDocsRenderer')>",
+            "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": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.name')>",
+                "docstring": null
+              },
+              "generate_sources": {
+                "name": "generate_sources",
+                "kind": "function",
+                "path": "docforge.cli.commands.mkdocs_utils.MkDocsRenderer.generate_sources",
+                "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_sources')>",
+                "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, optional):\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": "<bound method Alias.signature of Alias('generate_readme', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_readme')>",
+                "docstring": "Generate a `README.md` file from the root module docstring.\n\nBehavior:\n\n- If `module_is_source` is True, `README.md` is written to the project\n  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, optional):\n        Whether the module is treated as the project source root."
+              }
+            }
+          },
+          "load_nav_spec": {
+            "name": "load_nav_spec",
+            "kind": "function",
+            "path": "docforge.cli.commands.mkdocs_utils.load_nav_spec",
+            "signature": "<bound method Alias.signature of Alias('load_nav_spec', 'docforge.cli.mkdocs_utils.load_nav_spec')>",
+            "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 to the navigation specification file.\n\nReturns:\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": "<bound method Alias.signature of Alias('resolve_nav', 'docforge.cli.mkdocs_utils.resolve_nav')>",
+            "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: Navigation specification describing documentation layout.\n    docs_root: Root directory containing documentation Markdown files.\n\nReturns:\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.cli.commands.mkdocs_utils.MkDocsNavEmitter",
+            "signature": "<bound method Alias.signature of Alias('MkDocsNavEmitter', 'docforge.cli.mkdocs_utils.MkDocsNavEmitter')>",
+            "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": "<bound method Alias.signature of Alias('emit', 'docforge.nav.mkdocs.MkDocsNavEmitter.emit')>",
+                "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav: Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\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."
+              }
+            }
+          },
+          "generate_sources": {
+            "name": "generate_sources",
+            "kind": "function",
+            "path": "docforge.cli.commands.mkdocs_utils.generate_sources",
+            "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.cli.mkdocs_utils.generate_sources')>",
+            "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 (Optional[str]):\n        Optional override for the project name used in documentation metadata.\n\n    module_is_source (Optional[bool]):\n        If True, treat the specified module directory as the project root\n        rather than a nested module."
+          },
+          "generate_config": {
+            "name": "generate_config",
+            "kind": "function",
+            "path": "docforge.cli.commands.mkdocs_utils.generate_config",
+            "signature": "<bound method Alias.signature of Alias('generate_config', 'docforge.cli.mkdocs_utils.generate_config')>",
+            "docstring": "Generate an `mkdocs.yml` configuration file.\n\nThe configuration is created by combining a template configuration\nwith a navigation structure derived from the docforge navigation\nspecification.\n\nArgs:\n    docs_dir (Path):\n        Directory containing generated documentation Markdown files.\n\n    nav_file (Path):\n        Path to the `docforge.nav.yml` navigation specification.\n\n    template (Optional[Path]):\n        Optional path to a custom MkDocs configuration template. If not\n        provided, a built-in template will be used.\n\n    out (Path):\n        Destination path where the generated `mkdocs.yml` file will be written.\n\n    site_name (str):\n        Display name for the generated documentation site.\n\nRaises:\n    click.FileError:\n        If the navigation specification or template file cannot be found."
+          },
+          "build": {
+            "name": "build",
+            "kind": "function",
+            "path": "docforge.cli.commands.mkdocs_utils.build",
+            "signature": "<bound method Alias.signature of Alias('build', 'docforge.cli.mkdocs_utils.build')>",
+            "docstring": "Build the MkDocs documentation site.\n\nThis function loads the MkDocs configuration and runs the MkDocs\nbuild command to generate the final static documentation site.\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."
+          },
+          "serve": {
+            "name": "serve",
+            "kind": "function",
+            "path": "docforge.cli.commands.mkdocs_utils.serve",
+            "signature": "<bound method Alias.signature of Alias('serve', 'docforge.cli.mkdocs_utils.serve')>",
+            "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."
+          }
+        }
+      },
+      "mcp_utils": {
+        "name": "mcp_utils",
+        "kind": "module",
+        "path": "docforge.cli.commands.mcp_utils",
+        "signature": "<bound method Alias.signature of Alias('mcp_utils', 'docforge.cli.mcp_utils')>",
+        "docstring": "# Summary\n\nUtilities for working with MCP in the doc-forge CLI.",
+        "members": {
+          "Path": {
+            "name": "Path",
+            "kind": "alias",
+            "path": "docforge.cli.commands.mcp_utils.Path",
+            "signature": "<bound method Alias.signature of Alias('Path', 'docforge.cli.mcp_utils.Path')>",
+            "docstring": null
+          },
+          "click": {
+            "name": "click",
+            "kind": "alias",
+            "path": "docforge.cli.commands.mcp_utils.click",
+            "signature": "<bound method Alias.signature of Alias('click', 'docforge.cli.mcp_utils.click')>",
+            "docstring": null
+          },
+          "GriffeLoader": {
+            "name": "GriffeLoader",
+            "kind": "class",
+            "path": "docforge.cli.commands.mcp_utils.GriffeLoader",
+            "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.cli.mcp_utils.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.",
+            "members": {
+              "load_project": {
+                "name": "load_project",
+                "kind": "function",
+                "path": "docforge.cli.commands.mcp_utils.GriffeLoader.load_project",
+                "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_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."
+              }
+            }
+          },
+          "discover_module_paths": {
+            "name": "discover_module_paths",
+            "kind": "function",
+            "path": "docforge.cli.commands.mcp_utils.discover_module_paths",
+            "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.cli.mcp_utils.discover_module_paths')>",
+            "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, optional):\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": "<bound method Alias.signature of Alias('MCPRenderer', 'docforge.cli.mcp_utils.MCPRenderer')>",
+            "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": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mcp_renderer.MCPRenderer.name')>",
+                "docstring": null
+              },
+              "generate_sources": {
+                "name": "generate_sources",
+                "kind": "function",
+                "path": "docforge.cli.commands.mcp_utils.MCPRenderer.generate_sources",
+                "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mcp_renderer.MCPRenderer.generate_sources')>",
+                "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": "<bound method Alias.signature of Alias('MCPServer', 'docforge.cli.mcp_utils.MCPServer')>",
+            "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.",
+            "members": {
+              "mcp_root": {
+                "name": "mcp_root",
+                "kind": "attribute",
+                "path": "docforge.cli.commands.mcp_utils.MCPServer.mcp_root",
+                "signature": "<bound method Alias.signature of Alias('mcp_root', 'docforge.servers.mcp_server.MCPServer.mcp_root')>",
+                "docstring": null
+              },
+              "app": {
+                "name": "app",
+                "kind": "attribute",
+                "path": "docforge.cli.commands.mcp_utils.MCPServer.app",
+                "signature": "<bound method Alias.signature of Alias('app', 'docforge.servers.mcp_server.MCPServer.app')>",
+                "docstring": null
+              },
+              "run": {
+                "name": "run",
+                "kind": "function",
+                "path": "docforge.cli.commands.mcp_utils.MCPServer.run",
+                "signature": "<bound method Alias.signature of Alias('run', 'docforge.servers.mcp_server.MCPServer.run')>",
+                "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": "<bound method Alias.signature of Alias('generate_resources', 'docforge.cli.mcp_utils.generate_resources')>",
+            "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 (Optional[str]):\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": "<bound method Alias.signature of Alias('serve', 'docforge.cli.mcp_utils.serve')>",
+            "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."
+          }
+        }
+      },
+      "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": "<bound method Function.signature of Function('build', 28, 136)>",
+        "docstring": "Build documentation artifacts.\n\nThis command performs the full documentation build pipeline:\n\n1. Introspects the Python project using Griffe\n2. Generates renderer-specific documentation sources\n3. Optionally builds the final documentation output\n\nDepending on the selected options, the build can target:\n\n- MkDocs static documentation sites\n- MCP structured documentation resources\n\nArgs:\n    mcp (bool):\n        Enable MCP documentation generation.\n\n    mkdocs (bool):\n        Enable MkDocs documentation generation.\n\n    module_is_source (bool):\n        Treat the specified module directory as the project root.\n\n    module (Optional[str]):\n        Python module import path to document.\n\n    project_name (Optional[str]):\n        Optional override for the project name.\n\n    site_name (Optional[str]):\n        Display name for the MkDocs site.\n\n    docs_dir (Path):\n        Directory where Markdown documentation sources will be generated.\n\n    nav_file (Path):\n        Path to the navigation specification file.\n\n    template (Optional[Path]):\n        Optional custom MkDocs configuration template.\n\n    mkdocs_yml (Path):\n        Output path for the generated MkDocs configuration.\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": "<bound method Function.signature of Function('serve', 139, 190)>",
+        "docstring": "Serve generated documentation locally.\n\nDepending on the selected mode, this command starts either:\n\n- A MkDocs development server for browsing documentation\n- An MCP server exposing structured documentation resources\n\nArgs:\n    mcp (bool):\n        Serve documentation using the MCP server.\n\n    mkdocs (bool):\n        Serve the MkDocs development site.\n\n    module (Optional[str]):\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": "<bound method Function.signature of Function('tree', 193, 229)>",
+        "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 (Optional[str]):\n        Optional name to display as the project root."
+      },
+      "Group": {
+        "name": "Group",
+        "kind": "alias",
+        "path": "docforge.cli.commands.Group",
+        "signature": "<bound method Alias.signature of Alias('Group', 'click.core.Group')>",
+        "docstring": null
+      },
+      "Any": {
+        "name": "Any",
+        "kind": "alias",
+        "path": "docforge.cli.commands.Any",
+        "signature": "<bound method Alias.signature of Alias('Any', 'typing.Any')>",
+        "docstring": null
+      }
+    }
+  }
+}

mcp_docs/modules/docforge.cli.json

@@ -2,276 +2,680 @@
   "module": "docforge.cli",
   "content": {
     "path": "docforge.cli",
-    "docstring": "# CLI Layer\n\nThe `docforge.cli` package provides the command-line interface for interacting\nwith doc-forge.\n\n## Available Commands\n\n- **tree**: Visualize the introspected project structure.\n- **generate**: Create Markdown source files from Python code.\n- **mkdocs**: Generate the primary `mkdocs.yml` configuration.\n- **build**: Build the final documentation site.\n- **serve**: Launch a local development server with live-reloading.",
+    "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---",
     "objects": {
       "main": {
         "name": "main",
         "kind": "module",
         "path": "docforge.cli.main",
         "signature": null,
-        "docstring": "Main entry point for the doc-forge CLI. This module defines the core command\ngroup and the 'tree', 'generate', 'build', and 'serve' commands.",
+        "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": "<bound method Alias.signature of Alias('cli', 'docforge.cli.commands.cli')>",
+            "docstring": null
+          },
+          "main": {
+            "name": "main",
+            "kind": "function",
+            "path": "docforge.cli.main.main",
+            "signature": "<bound method Function.signature of Function('main', 13, 21)>",
+            "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."
+          }
+        }
+      },
+      "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.",
+        "members": {
+          "click": {
+            "name": "click",
+            "kind": "alias",
+            "path": "docforge.cli.commands.click",
+            "signature": "<bound method Alias.signature of Alias('click', 'click')>",
+            "docstring": null
+          },
           "Path": {
             "name": "Path",
             "kind": "alias",
-            "path": "docforge.cli.main.Path",
+            "path": "docforge.cli.commands.Path",
             "signature": "<bound method Alias.signature of Alias('Path', 'pathlib.Path')>",
             "docstring": null
           },
           "Sequence": {
             "name": "Sequence",
             "kind": "alias",
-            "path": "docforge.cli.main.Sequence",
+            "path": "docforge.cli.commands.Sequence",
             "signature": "<bound method Alias.signature of Alias('Sequence', 'typing.Sequence')>",
             "docstring": null
           },
           "Optional": {
             "name": "Optional",
             "kind": "alias",
-            "path": "docforge.cli.main.Optional",
+            "path": "docforge.cli.commands.Optional",
             "signature": "<bound method Alias.signature of Alias('Optional', 'typing.Optional')>",
             "docstring": null
           },
+          "GriffeLoader": {
+            "name": "GriffeLoader",
+            "kind": "class",
+            "path": "docforge.cli.commands.GriffeLoader",
+            "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.loaders.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.",
+            "members": {
+              "load_project": {
+                "name": "load_project",
+                "kind": "function",
+                "path": "docforge.cli.commands.GriffeLoader.load_project",
+                "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_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."
+              }
+            }
+          },
+          "mkdocs_utils": {
+            "name": "mkdocs_utils",
+            "kind": "module",
+            "path": "docforge.cli.commands.mkdocs_utils",
+            "signature": "<bound method Alias.signature of Alias('mkdocs_utils', 'docforge.cli.mkdocs_utils')>",
+            "docstring": "# Summary\n\nUtilities for working with MkDocs in the doc-forge CLI.",
+            "members": {
+              "Path": {
+                "name": "Path",
+                "kind": "alias",
+                "path": "docforge.cli.commands.mkdocs_utils.Path",
+                "signature": "<bound method Alias.signature of Alias('Path', 'docforge.cli.mkdocs_utils.Path')>",
+                "docstring": null
+              },
+              "resources": {
+                "name": "resources",
+                "kind": "alias",
+                "path": "docforge.cli.commands.mkdocs_utils.resources",
+                "signature": "<bound method Alias.signature of Alias('resources', 'docforge.cli.mkdocs_utils.resources')>",
+                "docstring": null
+              },
+              "click": {
+                "name": "click",
+                "kind": "alias",
+                "path": "docforge.cli.commands.mkdocs_utils.click",
+                "signature": "<bound method Alias.signature of Alias('click', 'docforge.cli.mkdocs_utils.click')>",
+                "docstring": null
+              },
+              "yaml": {
+                "name": "yaml",
+                "kind": "alias",
+                "path": "docforge.cli.commands.mkdocs_utils.yaml",
+                "signature": "<bound method Alias.signature of Alias('yaml', 'docforge.cli.mkdocs_utils.yaml')>",
+                "docstring": null
+              },
+              "GriffeLoader": {
+                "name": "GriffeLoader",
+                "kind": "class",
+                "path": "docforge.cli.commands.mkdocs_utils.GriffeLoader",
+                "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.cli.mkdocs_utils.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.",
+                "members": {
+                  "load_project": {
+                    "name": "load_project",
+                    "kind": "function",
+                    "path": "docforge.cli.commands.mkdocs_utils.GriffeLoader.load_project",
+                    "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_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."
+                  }
+                }
+              },
+              "discover_module_paths": {
+                "name": "discover_module_paths",
+                "kind": "function",
+                "path": "docforge.cli.commands.mkdocs_utils.discover_module_paths",
+                "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.cli.mkdocs_utils.discover_module_paths')>",
+                "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, optional):\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.cli.commands.mkdocs_utils.MkDocsRenderer",
+                "signature": "<bound method Alias.signature of Alias('MkDocsRenderer', 'docforge.cli.mkdocs_utils.MkDocsRenderer')>",
+                "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": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.name')>",
+                    "docstring": null
+                  },
+                  "generate_sources": {
+                    "name": "generate_sources",
+                    "kind": "function",
+                    "path": "docforge.cli.commands.mkdocs_utils.MkDocsRenderer.generate_sources",
+                    "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_sources')>",
+                    "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, optional):\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": "<bound method Alias.signature of Alias('generate_readme', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_readme')>",
+                    "docstring": "Generate a `README.md` file from the root module docstring.\n\nBehavior:\n\n- If `module_is_source` is True, `README.md` is written to the project\n  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, optional):\n        Whether the module is treated as the project source root."
+                  }
+                }
+              },
+              "load_nav_spec": {
+                "name": "load_nav_spec",
+                "kind": "function",
+                "path": "docforge.cli.commands.mkdocs_utils.load_nav_spec",
+                "signature": "<bound method Alias.signature of Alias('load_nav_spec', 'docforge.cli.mkdocs_utils.load_nav_spec')>",
+                "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 to the navigation specification file.\n\nReturns:\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": "<bound method Alias.signature of Alias('resolve_nav', 'docforge.cli.mkdocs_utils.resolve_nav')>",
+                "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: Navigation specification describing documentation layout.\n    docs_root: Root directory containing documentation Markdown files.\n\nReturns:\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.cli.commands.mkdocs_utils.MkDocsNavEmitter",
+                "signature": "<bound method Alias.signature of Alias('MkDocsNavEmitter', 'docforge.cli.mkdocs_utils.MkDocsNavEmitter')>",
+                "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": "<bound method Alias.signature of Alias('emit', 'docforge.nav.mkdocs.MkDocsNavEmitter.emit')>",
+                    "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav: Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\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."
+                  }
+                }
+              },
+              "generate_sources": {
+                "name": "generate_sources",
+                "kind": "function",
+                "path": "docforge.cli.commands.mkdocs_utils.generate_sources",
+                "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.cli.mkdocs_utils.generate_sources')>",
+                "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 (Optional[str]):\n        Optional override for the project name used in documentation metadata.\n\n    module_is_source (Optional[bool]):\n        If True, treat the specified module directory as the project root\n        rather than a nested module."
+              },
+              "generate_config": {
+                "name": "generate_config",
+                "kind": "function",
+                "path": "docforge.cli.commands.mkdocs_utils.generate_config",
+                "signature": "<bound method Alias.signature of Alias('generate_config', 'docforge.cli.mkdocs_utils.generate_config')>",
+                "docstring": "Generate an `mkdocs.yml` configuration file.\n\nThe configuration is created by combining a template configuration\nwith a navigation structure derived from the docforge navigation\nspecification.\n\nArgs:\n    docs_dir (Path):\n        Directory containing generated documentation Markdown files.\n\n    nav_file (Path):\n        Path to the `docforge.nav.yml` navigation specification.\n\n    template (Optional[Path]):\n        Optional path to a custom MkDocs configuration template. If not\n        provided, a built-in template will be used.\n\n    out (Path):\n        Destination path where the generated `mkdocs.yml` file will be written.\n\n    site_name (str):\n        Display name for the generated documentation site.\n\nRaises:\n    click.FileError:\n        If the navigation specification or template file cannot be found."
+              },
+              "build": {
+                "name": "build",
+                "kind": "function",
+                "path": "docforge.cli.commands.mkdocs_utils.build",
+                "signature": "<bound method Alias.signature of Alias('build', 'docforge.cli.mkdocs_utils.build')>",
+                "docstring": "Build the MkDocs documentation site.\n\nThis function loads the MkDocs configuration and runs the MkDocs\nbuild command to generate the final static documentation site.\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."
+              },
+              "serve": {
+                "name": "serve",
+                "kind": "function",
+                "path": "docforge.cli.commands.mkdocs_utils.serve",
+                "signature": "<bound method Alias.signature of Alias('serve', 'docforge.cli.mkdocs_utils.serve')>",
+                "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."
+              }
+            }
+          },
+          "mcp_utils": {
+            "name": "mcp_utils",
+            "kind": "module",
+            "path": "docforge.cli.commands.mcp_utils",
+            "signature": "<bound method Alias.signature of Alias('mcp_utils', 'docforge.cli.mcp_utils')>",
+            "docstring": "# Summary\n\nUtilities for working with MCP in the doc-forge CLI.",
+            "members": {
+              "Path": {
+                "name": "Path",
+                "kind": "alias",
+                "path": "docforge.cli.commands.mcp_utils.Path",
+                "signature": "<bound method Alias.signature of Alias('Path', 'docforge.cli.mcp_utils.Path')>",
+                "docstring": null
+              },
+              "click": {
+                "name": "click",
+                "kind": "alias",
+                "path": "docforge.cli.commands.mcp_utils.click",
+                "signature": "<bound method Alias.signature of Alias('click', 'docforge.cli.mcp_utils.click')>",
+                "docstring": null
+              },
+              "GriffeLoader": {
+                "name": "GriffeLoader",
+                "kind": "class",
+                "path": "docforge.cli.commands.mcp_utils.GriffeLoader",
+                "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.cli.mcp_utils.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.",
+                "members": {
+                  "load_project": {
+                    "name": "load_project",
+                    "kind": "function",
+                    "path": "docforge.cli.commands.mcp_utils.GriffeLoader.load_project",
+                    "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_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."
+                  }
+                }
+              },
+              "discover_module_paths": {
+                "name": "discover_module_paths",
+                "kind": "function",
+                "path": "docforge.cli.commands.mcp_utils.discover_module_paths",
+                "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.cli.mcp_utils.discover_module_paths')>",
+                "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, optional):\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": "<bound method Alias.signature of Alias('MCPRenderer', 'docforge.cli.mcp_utils.MCPRenderer')>",
+                "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": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mcp_renderer.MCPRenderer.name')>",
+                    "docstring": null
+                  },
+                  "generate_sources": {
+                    "name": "generate_sources",
+                    "kind": "function",
+                    "path": "docforge.cli.commands.mcp_utils.MCPRenderer.generate_sources",
+                    "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mcp_renderer.MCPRenderer.generate_sources')>",
+                    "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": "<bound method Alias.signature of Alias('MCPServer', 'docforge.cli.mcp_utils.MCPServer')>",
+                "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.",
+                "members": {
+                  "mcp_root": {
+                    "name": "mcp_root",
+                    "kind": "attribute",
+                    "path": "docforge.cli.commands.mcp_utils.MCPServer.mcp_root",
+                    "signature": "<bound method Alias.signature of Alias('mcp_root', 'docforge.servers.mcp_server.MCPServer.mcp_root')>",
+                    "docstring": null
+                  },
+                  "app": {
+                    "name": "app",
+                    "kind": "attribute",
+                    "path": "docforge.cli.commands.mcp_utils.MCPServer.app",
+                    "signature": "<bound method Alias.signature of Alias('app', 'docforge.servers.mcp_server.MCPServer.app')>",
+                    "docstring": null
+                  },
+                  "run": {
+                    "name": "run",
+                    "kind": "function",
+                    "path": "docforge.cli.commands.mcp_utils.MCPServer.run",
+                    "signature": "<bound method Alias.signature of Alias('run', 'docforge.servers.mcp_server.MCPServer.run')>",
+                    "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": "<bound method Alias.signature of Alias('generate_resources', 'docforge.cli.mcp_utils.generate_resources')>",
+                "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 (Optional[str]):\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": "<bound method Alias.signature of Alias('serve', 'docforge.cli.mcp_utils.serve')>",
+                "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."
+              }
+            }
+          },
+          "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": "<bound method Function.signature of Function('build', 28, 136)>",
+            "docstring": "Build documentation artifacts.\n\nThis command performs the full documentation build pipeline:\n\n1. Introspects the Python project using Griffe\n2. Generates renderer-specific documentation sources\n3. Optionally builds the final documentation output\n\nDepending on the selected options, the build can target:\n\n- MkDocs static documentation sites\n- MCP structured documentation resources\n\nArgs:\n    mcp (bool):\n        Enable MCP documentation generation.\n\n    mkdocs (bool):\n        Enable MkDocs documentation generation.\n\n    module_is_source (bool):\n        Treat the specified module directory as the project root.\n\n    module (Optional[str]):\n        Python module import path to document.\n\n    project_name (Optional[str]):\n        Optional override for the project name.\n\n    site_name (Optional[str]):\n        Display name for the MkDocs site.\n\n    docs_dir (Path):\n        Directory where Markdown documentation sources will be generated.\n\n    nav_file (Path):\n        Path to the navigation specification file.\n\n    template (Optional[Path]):\n        Optional custom MkDocs configuration template.\n\n    mkdocs_yml (Path):\n        Output path for the generated MkDocs configuration.\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": "<bound method Function.signature of Function('serve', 139, 190)>",
+            "docstring": "Serve generated documentation locally.\n\nDepending on the selected mode, this command starts either:\n\n- A MkDocs development server for browsing documentation\n- An MCP server exposing structured documentation resources\n\nArgs:\n    mcp (bool):\n        Serve documentation using the MCP server.\n\n    mkdocs (bool):\n        Serve the MkDocs development site.\n\n    module (Optional[str]):\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": "<bound method Function.signature of Function('tree', 193, 229)>",
+            "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 (Optional[str]):\n        Optional name to display as the project root."
+          },
+          "Group": {
+            "name": "Group",
+            "kind": "alias",
+            "path": "docforge.cli.commands.Group",
+            "signature": "<bound method Alias.signature of Alias('Group', 'click.core.Group')>",
+            "docstring": null
+          },
+          "Any": {
+            "name": "Any",
+            "kind": "alias",
+            "path": "docforge.cli.commands.Any",
+            "signature": "<bound method Alias.signature of Alias('Any', 'typing.Any')>",
+            "docstring": null
+          }
+        }
+      },
+      "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.",
+        "members": {
+          "Path": {
+            "name": "Path",
+            "kind": "alias",
+            "path": "docforge.cli.mcp_utils.Path",
+            "signature": "<bound method Alias.signature of Alias('Path', 'pathlib.Path')>",
+            "docstring": null
+          },
           "click": {
             "name": "click",
             "kind": "alias",
-            "path": "docforge.cli.main.click",
+            "path": "docforge.cli.mcp_utils.click",
             "signature": "<bound method Alias.signature of Alias('click', 'click')>",
             "docstring": null
           },
           "GriffeLoader": {
             "name": "GriffeLoader",
             "kind": "class",
-            "path": "docforge.cli.main.GriffeLoader",
+            "path": "docforge.cli.mcp_utils.GriffeLoader",
             "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.loaders.GriffeLoader')>",
-            "docstring": "Loads Python modules and extracts documentation using the Griffe introspection engine.",
+            "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.",
             "members": {
               "load_project": {
                 "name": "load_project",
                 "kind": "function",
-                "path": "docforge.cli.main.GriffeLoader.load_project",
+                "path": "docforge.cli.mcp_utils.GriffeLoader.load_project",
                 "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_project')>",
-                "docstring": "Load multiple modules and combine them into a single Project models.\n\nArgs:\n    module_paths: A list of dotted paths to the modules to load.\n    project_name: Optional name for the project. Defaults to the first module name.\n    skip_import_errors: If True, modules that fail to import will be skipped.\n\nReturns:\n    A Project instance containing the loaded modules."
+                "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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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.main.GriffeLoader.load_module",
+                "path": "docforge.cli.mcp_utils.GriffeLoader.load_module",
                 "signature": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_module')>",
-                "docstring": "Load a single module and convert its introspection data into the docforge models.\n\nArgs:\n    path: The dotted path of the module to load.\n\nReturns:\n    A Module instance."
+                "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."
               }
             }
           },
           "discover_module_paths": {
             "name": "discover_module_paths",
             "kind": "function",
-            "path": "docforge.cli.main.discover_module_paths",
+            "path": "docforge.cli.mcp_utils.discover_module_paths",
             "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.loaders.discover_module_paths')>",
-            "docstring": "Discover all Python modules under a package via filesystem traversal.\n\nRules:\n- Directory with __init__.py is treated as a package.\n- Any .py file is treated as a module.\n- All paths are converted to dotted module paths.\n\nArgs:\n    module_name: The name of the package to discover.\n    project_root: The root directory of the project. Defaults to current working directory.\n\nReturns:\n    A sorted list of dotted module paths."
-          },
-          "MkDocsRenderer": {
-            "name": "MkDocsRenderer",
-            "kind": "class",
-            "path": "docforge.cli.main.MkDocsRenderer",
-            "signature": "<bound method Alias.signature of Alias('MkDocsRenderer', 'docforge.renderers.MkDocsRenderer')>",
-            "docstring": "Renderer that generates Markdown source files formatted for the MkDocs\n'mkdocstrings' plugin.",
-            "members": {
-              "name": {
-                "name": "name",
-                "kind": "attribute",
-                "path": "docforge.cli.main.MkDocsRenderer.name",
-                "signature": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.name')>",
-                "docstring": null
-              },
-              "generate_sources": {
-                "name": "generate_sources",
-                "kind": "function",
-                "path": "docforge.cli.main.MkDocsRenderer.generate_sources",
-                "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_sources')>",
-                "docstring": "Produce a set of Markdown files in the output directory based on the\nprovided Project models.\n\nArgs:\n    project: The project models to render.\n    out_dir: Target directory for documentation files."
-              }
-            }
+            "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, optional):\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.main.MCPRenderer",
+            "path": "docforge.cli.mcp_utils.MCPRenderer",
             "signature": "<bound method Alias.signature of Alias('MCPRenderer', 'docforge.renderers.MCPRenderer')>",
-            "docstring": "Renderer that emits MCP-native JSON resources from docforge models.",
+            "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.main.MCPRenderer.name",
+                "path": "docforge.cli.mcp_utils.MCPRenderer.name",
                 "signature": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mcp_renderer.MCPRenderer.name')>",
                 "docstring": null
               },
               "generate_sources": {
                 "name": "generate_sources",
                 "kind": "function",
-                "path": "docforge.cli.main.MCPRenderer.generate_sources",
+                "path": "docforge.cli.mcp_utils.MCPRenderer.generate_sources",
                 "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mcp_renderer.MCPRenderer.generate_sources')>",
-                "docstring": "Generate MCP-compatible JSON resources and navigation for the project."
+                "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_cmd": {
-            "name": "mkdocs_cmd",
-            "kind": "function",
-            "path": "docforge.cli.main.mkdocs_cmd",
-            "signature": "<bound method Alias.signature of Alias('mkdocs_cmd', 'docforge.cli.mkdocs.mkdocs_cmd')>",
-            "docstring": "Generate an mkdocs.yml configuration file by combining a template with\nthe navigation structure resolved from a docforge.nav.yml file.\n\nArgs:\n    docs_dir: Path to the directory containing documentation Markdown files.\n    nav_file: Path to the docforge.nav.yml specification.\n    template: Optional path to an mkdocs.yml template.\n    out: Path where the final mkdocs.yml will be written.\n    site_name: The name of the documentation site."
+          "MCPServer": {
+            "name": "MCPServer",
+            "kind": "class",
+            "path": "docforge.cli.mcp_utils.MCPServer",
+            "signature": "<bound method Alias.signature of Alias('MCPServer', 'docforge.servers.MCPServer')>",
+            "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.",
+            "members": {
+              "mcp_root": {
+                "name": "mcp_root",
+                "kind": "attribute",
+                "path": "docforge.cli.mcp_utils.MCPServer.mcp_root",
+                "signature": "<bound method Alias.signature of Alias('mcp_root', 'docforge.servers.mcp_server.MCPServer.mcp_root')>",
+                "docstring": null
+              },
+              "app": {
+                "name": "app",
+                "kind": "attribute",
+                "path": "docforge.cli.mcp_utils.MCPServer.app",
+                "signature": "<bound method Alias.signature of Alias('app', 'docforge.servers.mcp_server.MCPServer.app')>",
+                "docstring": null
+              },
+              "run": {
+                "name": "run",
+                "kind": "function",
+                "path": "docforge.cli.mcp_utils.MCPServer.run",
+                "signature": "<bound method Alias.signature of Alias('run', 'docforge.servers.mcp_server.MCPServer.run')>",
+                "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`."
+              }
+            }
           },
-          "cli": {
-            "name": "cli",
+          "generate_resources": {
+            "name": "generate_resources",
             "kind": "function",
-            "path": "docforge.cli.main.cli",
-            "signature": "<bound method Function.signature of Function('cli', 16, 22)>",
-            "docstring": "doc-forge CLI: A tool for introspecting Python projects and generating\ndocumentation."
-          },
-          "tree": {
-            "name": "tree",
-            "kind": "function",
-            "path": "docforge.cli.main.tree",
-            "signature": "<bound method Function.signature of Function('tree', 31, 62)>",
-            "docstring": "Visualize the project structure including modules and their members.\n\nArgs:\n    modules: List of module paths to introspect.\n    project_name: Optional project name override."
-          },
-          "generate": {
-            "name": "generate",
-            "kind": "function",
-            "path": "docforge.cli.main.generate",
-            "signature": "<bound method Function.signature of Function('generate', 82, 122)>",
-            "docstring": "Generate Markdown source files for the specified module.\n\nArgs:\n    module: The primary module path to document.\n    project_name: Optional project name override.\n    docs_dir: Directory where documentation sources will be written."
-          },
-          "generate_mcp": {
-            "name": "generate_mcp",
-            "kind": "function",
-            "path": "docforge.cli.main.generate_mcp",
-            "signature": "<bound method Function.signature of Function('generate_mcp', 129, 168)>",
-            "docstring": "Generate MCP-compatible documentation resources for the specified module.\n\nArgs:\n    module: The primary module path to document.\n    project_name: Optional project name override.\n    out_dir: Directory where MCP resources will be written."
-          },
-          "build": {
-            "name": "build",
-            "kind": "function",
-            "path": "docforge.cli.main.build",
-            "signature": "<bound method Function.signature of Function('build', 175, 196)>",
-            "docstring": "Build the documentation site using MkDocs.\n\nArgs:\n    mkdocs_yml: Path to the mkdocs.yml configuration file."
-          },
-          "serve_mcp": {
-            "name": "serve_mcp",
-            "kind": "function",
-            "path": "docforge.cli.main.serve_mcp",
-            "signature": "<bound method Function.signature of Function('serve_mcp', 203, 230)>",
-            "docstring": "Serve MCP documentation from the local mcp_docs directory."
+            "path": "docforge.cli.mcp_utils.generate_resources",
+            "signature": "<bound method Function.signature of Function('generate_resources', 14, 40)>",
+            "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 (Optional[str]):\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.main.serve",
-            "signature": "<bound method Function.signature of Function('serve', 237, 260)>",
-            "docstring": "Serve the documentation site with live-reload using MkDocs.\n\nArgs:\n    mkdocs_yml: Path to the mkdocs.yml configuration file."
-          },
-          "main": {
-            "name": "main",
-            "kind": "function",
-            "path": "docforge.cli.main.main",
-            "signature": "<bound method Function.signature of Function('main', 267, 271)>",
-            "docstring": "CLI Entry point. Boots the click application."
+            "path": "docforge.cli.mcp_utils.serve",
+            "signature": "<bound method Function.signature of Function('serve', 43, 80)>",
+            "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": {
-        "name": "mkdocs",
+      "mkdocs_utils": {
+        "name": "mkdocs_utils",
         "kind": "module",
-        "path": "docforge.cli.mkdocs",
+        "path": "docforge.cli.mkdocs_utils",
         "signature": null,
-        "docstring": "This module contains the 'mkdocs' CLI command, which orchestrates the generation\nof the main mkdocs.yml configuration file.",
+        "docstring": "# Summary\n\nUtilities for working with MkDocs in the doc-forge CLI.",
         "members": {
           "Path": {
             "name": "Path",
             "kind": "alias",
-            "path": "docforge.cli.mkdocs.Path",
+            "path": "docforge.cli.mkdocs_utils.Path",
             "signature": "<bound method Alias.signature of Alias('Path', 'pathlib.Path')>",
             "docstring": null
           },
           "resources": {
             "name": "resources",
             "kind": "alias",
-            "path": "docforge.cli.mkdocs.resources",
+            "path": "docforge.cli.mkdocs_utils.resources",
             "signature": "<bound method Alias.signature of Alias('resources', 'importlib.resources')>",
             "docstring": null
           },
           "click": {
             "name": "click",
             "kind": "alias",
-            "path": "docforge.cli.mkdocs.click",
+            "path": "docforge.cli.mkdocs_utils.click",
             "signature": "<bound method Alias.signature of Alias('click', 'click')>",
             "docstring": null
           },
           "yaml": {
             "name": "yaml",
             "kind": "alias",
-            "path": "docforge.cli.mkdocs.yaml",
+            "path": "docforge.cli.mkdocs_utils.yaml",
             "signature": "<bound method Alias.signature of Alias('yaml', 'yaml')>",
             "docstring": null
           },
+          "GriffeLoader": {
+            "name": "GriffeLoader",
+            "kind": "class",
+            "path": "docforge.cli.mkdocs_utils.GriffeLoader",
+            "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.loaders.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.",
+            "members": {
+              "load_project": {
+                "name": "load_project",
+                "kind": "function",
+                "path": "docforge.cli.mkdocs_utils.GriffeLoader.load_project",
+                "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_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."
+              }
+            }
+          },
+          "discover_module_paths": {
+            "name": "discover_module_paths",
+            "kind": "function",
+            "path": "docforge.cli.mkdocs_utils.discover_module_paths",
+            "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.loaders.discover_module_paths')>",
+            "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, optional):\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.cli.mkdocs_utils.MkDocsRenderer",
+            "signature": "<bound method Alias.signature of Alias('MkDocsRenderer', 'docforge.renderers.MkDocsRenderer')>",
+            "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": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.name')>",
+                "docstring": null
+              },
+              "generate_sources": {
+                "name": "generate_sources",
+                "kind": "function",
+                "path": "docforge.cli.mkdocs_utils.MkDocsRenderer.generate_sources",
+                "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_sources')>",
+                "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, optional):\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": "<bound method Alias.signature of Alias('generate_readme', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_readme')>",
+                "docstring": "Generate a `README.md` file from the root module docstring.\n\nBehavior:\n\n- If `module_is_source` is True, `README.md` is written to the project\n  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, optional):\n        Whether the module is treated as the project source root."
+              }
+            }
+          },
           "load_nav_spec": {
             "name": "load_nav_spec",
             "kind": "function",
-            "path": "docforge.cli.mkdocs.load_nav_spec",
+            "path": "docforge.cli.mkdocs_utils.load_nav_spec",
             "signature": "<bound method Alias.signature of Alias('load_nav_spec', 'docforge.nav.load_nav_spec')>",
-            "docstring": "Utility function to load a NavSpec from a file.\n\nArgs:\n    path: Path to the navigation specification file.\n\nReturns:\n    A loaded NavSpec instance."
+            "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 to the navigation specification file.\n\nReturns:\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.resolve_nav",
+            "path": "docforge.cli.mkdocs_utils.resolve_nav",
             "signature": "<bound method Alias.signature of Alias('resolve_nav', 'docforge.nav.resolve_nav')>",
-            "docstring": "Create a ResolvedNav by processing a NavSpec against the filesystem.\nThis expands globs and validates the existence of referenced files.\n\nArgs:\n    spec: The navigation specification to resolve.\n    docs_root: The root directory for documentation files.\n\nReturns:\n    A ResolvedNav instance.\n\nRaises:\n    FileNotFoundError: If a pattern doesn't match any files or the docs_root doesn't exist."
+            "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: Navigation specification describing documentation layout.\n    docs_root: Root directory containing documentation Markdown files.\n\nReturns:\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.cli.mkdocs.MkDocsNavEmitter",
+            "path": "docforge.cli.mkdocs_utils.MkDocsNavEmitter",
             "signature": "<bound method Alias.signature of Alias('MkDocsNavEmitter', 'docforge.nav.MkDocsNavEmitter')>",
-            "docstring": "Emitter responsible for transforming a ResolvedNav into an MkDocs-compatible\nnavigation structure.",
+            "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.MkDocsNavEmitter.emit",
+                "path": "docforge.cli.mkdocs_utils.MkDocsNavEmitter.emit",
                 "signature": "<bound method Alias.signature of Alias('emit', 'docforge.nav.mkdocs.MkDocsNavEmitter.emit')>",
-                "docstring": "Generate a list of navigation entries for mkdocs.yml.\n\nArgs:\n    nav: The resolved navigation data.\n\nReturns:\n    A list of dictionary mappings representing the MkDocs navigation."
+                "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav: Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\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."
               }
             }
           },
-          "mkdocs_cmd": {
-            "name": "mkdocs_cmd",
+          "generate_sources": {
+            "name": "generate_sources",
             "kind": "function",
-            "path": "docforge.cli.mkdocs.mkdocs_cmd",
-            "signature": "<bound method Function.signature of Function('mkdocs_cmd', 42, 116)>",
-            "docstring": "Generate an mkdocs.yml configuration file by combining a template with\nthe navigation structure resolved from a docforge.nav.yml file.\n\nArgs:\n    docs_dir: Path to the directory containing documentation Markdown files.\n    nav_file: Path to the docforge.nav.yml specification.\n    template: Optional path to an mkdocs.yml template.\n    out: Path where the final mkdocs.yml will be written.\n    site_name: The name of the documentation site."
+            "path": "docforge.cli.mkdocs_utils.generate_sources",
+            "signature": "<bound method Function.signature of Function('generate_sources', 16, 59)>",
+            "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 (Optional[str]):\n        Optional override for the project name used in documentation metadata.\n\n    module_is_source (Optional[bool]):\n        If True, treat the specified module directory as the project root\n        rather than a nested module."
           },
-          "Any": {
-            "name": "Any",
-            "kind": "alias",
-            "path": "docforge.cli.mkdocs.Any",
-            "signature": "<bound method Alias.signature of Alias('Any', 'typing.Any')>",
-            "docstring": null
+          "generate_config": {
+            "name": "generate_config",
+            "kind": "function",
+            "path": "docforge.cli.mkdocs_utils.generate_config",
+            "signature": "<bound method Function.signature of Function('generate_config', 62, 120)>",
+            "docstring": "Generate an `mkdocs.yml` configuration file.\n\nThe configuration is created by combining a template configuration\nwith a navigation structure derived from the docforge navigation\nspecification.\n\nArgs:\n    docs_dir (Path):\n        Directory containing generated documentation Markdown files.\n\n    nav_file (Path):\n        Path to the `docforge.nav.yml` navigation specification.\n\n    template (Optional[Path]):\n        Optional path to a custom MkDocs configuration template. If not\n        provided, a built-in template will be used.\n\n    out (Path):\n        Destination path where the generated `mkdocs.yml` file will be written.\n\n    site_name (str):\n        Display name for the generated documentation site.\n\nRaises:\n    click.FileError:\n        If the navigation specification or template file cannot be found."
           },
-          "Dict": {
-            "name": "Dict",
-            "kind": "alias",
-            "path": "docforge.cli.mkdocs.Dict",
-            "signature": "<bound method Alias.signature of Alias('Dict', 'typing.Dict')>",
-            "docstring": null
+          "build": {
+            "name": "build",
+            "kind": "function",
+            "path": "docforge.cli.mkdocs_utils.build",
+            "signature": "<bound method Function.signature of Function('build', 123, 144)>",
+            "docstring": "Build the MkDocs documentation site.\n\nThis function loads the MkDocs configuration and runs the MkDocs\nbuild command to generate the final static documentation site.\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."
           },
-          "Optional": {
-            "name": "Optional",
-            "kind": "alias",
-            "path": "docforge.cli.mkdocs.Optional",
-            "signature": "<bound method Alias.signature of Alias('Optional', 'typing.Optional')>",
-            "docstring": null
+          "serve": {
+            "name": "serve",
+            "kind": "function",
+            "path": "docforge.cli.mkdocs_utils.serve",
+            "signature": "<bound method Function.signature of Function('serve', 147, 166)>",
+            "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."
           }
         }
       }

mcp_docs/modules/docforge.cli.main.json

@@ -2,174 +2,21 @@
   "module": "docforge.cli.main",
   "content": {
     "path": "docforge.cli.main",
-    "docstring": "Main entry point for the doc-forge CLI. This module defines the core command\ngroup and the 'tree', 'generate', 'build', and 'serve' commands.",
+    "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`.",
     "objects": {
-      "Path": {
-        "name": "Path",
-        "kind": "alias",
-        "path": "docforge.cli.main.Path",
-        "signature": "<bound method Alias.signature of Alias('Path', 'pathlib.Path')>",
-        "docstring": null
-      },
-      "Sequence": {
-        "name": "Sequence",
-        "kind": "alias",
-        "path": "docforge.cli.main.Sequence",
-        "signature": "<bound method Alias.signature of Alias('Sequence', 'typing.Sequence')>",
-        "docstring": null
-      },
-      "Optional": {
-        "name": "Optional",
-        "kind": "alias",
-        "path": "docforge.cli.main.Optional",
-        "signature": "<bound method Alias.signature of Alias('Optional', 'typing.Optional')>",
-        "docstring": null
-      },
-      "click": {
-        "name": "click",
-        "kind": "alias",
-        "path": "docforge.cli.main.click",
-        "signature": "<bound method Alias.signature of Alias('click', 'click')>",
-        "docstring": null
-      },
-      "GriffeLoader": {
-        "name": "GriffeLoader",
-        "kind": "class",
-        "path": "docforge.cli.main.GriffeLoader",
-        "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.loaders.GriffeLoader')>",
-        "docstring": "Loads Python modules and extracts documentation using the Griffe introspection engine.",
-        "members": {
-          "load_project": {
-            "name": "load_project",
-            "kind": "function",
-            "path": "docforge.cli.main.GriffeLoader.load_project",
-            "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_project')>",
-            "docstring": "Load multiple modules and combine them into a single Project models.\n\nArgs:\n    module_paths: A list of dotted paths to the modules to load.\n    project_name: Optional name for the project. Defaults to the first module name.\n    skip_import_errors: If True, modules that fail to import will be skipped.\n\nReturns:\n    A Project instance containing the loaded modules."
-          },
-          "load_module": {
-            "name": "load_module",
-            "kind": "function",
-            "path": "docforge.cli.main.GriffeLoader.load_module",
-            "signature": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_module')>",
-            "docstring": "Load a single module and convert its introspection data into the docforge models.\n\nArgs:\n    path: The dotted path of the module to load.\n\nReturns:\n    A Module instance."
-          }
-        }
-      },
-      "discover_module_paths": {
-        "name": "discover_module_paths",
-        "kind": "function",
-        "path": "docforge.cli.main.discover_module_paths",
-        "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.loaders.discover_module_paths')>",
-        "docstring": "Discover all Python modules under a package via filesystem traversal.\n\nRules:\n- Directory with __init__.py is treated as a package.\n- Any .py file is treated as a module.\n- All paths are converted to dotted module paths.\n\nArgs:\n    module_name: The name of the package to discover.\n    project_root: The root directory of the project. Defaults to current working directory.\n\nReturns:\n    A sorted list of dotted module paths."
-      },
-      "MkDocsRenderer": {
-        "name": "MkDocsRenderer",
-        "kind": "class",
-        "path": "docforge.cli.main.MkDocsRenderer",
-        "signature": "<bound method Alias.signature of Alias('MkDocsRenderer', 'docforge.renderers.MkDocsRenderer')>",
-        "docstring": "Renderer that generates Markdown source files formatted for the MkDocs\n'mkdocstrings' plugin.",
-        "members": {
-          "name": {
-            "name": "name",
-            "kind": "attribute",
-            "path": "docforge.cli.main.MkDocsRenderer.name",
-            "signature": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.name')>",
-            "docstring": null
-          },
-          "generate_sources": {
-            "name": "generate_sources",
-            "kind": "function",
-            "path": "docforge.cli.main.MkDocsRenderer.generate_sources",
-            "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_sources')>",
-            "docstring": "Produce a set of Markdown files in the output directory based on the\nprovided Project models.\n\nArgs:\n    project: The project models to render.\n    out_dir: Target directory for documentation files."
-          }
-        }
-      },
-      "MCPRenderer": {
-        "name": "MCPRenderer",
-        "kind": "class",
-        "path": "docforge.cli.main.MCPRenderer",
-        "signature": "<bound method Alias.signature of Alias('MCPRenderer', 'docforge.renderers.MCPRenderer')>",
-        "docstring": "Renderer that emits MCP-native JSON resources from docforge models.",
-        "members": {
-          "name": {
-            "name": "name",
-            "kind": "attribute",
-            "path": "docforge.cli.main.MCPRenderer.name",
-            "signature": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mcp_renderer.MCPRenderer.name')>",
-            "docstring": null
-          },
-          "generate_sources": {
-            "name": "generate_sources",
-            "kind": "function",
-            "path": "docforge.cli.main.MCPRenderer.generate_sources",
-            "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mcp_renderer.MCPRenderer.generate_sources')>",
-            "docstring": "Generate MCP-compatible JSON resources and navigation for the project."
-          }
-        }
-      },
-      "mkdocs_cmd": {
-        "name": "mkdocs_cmd",
-        "kind": "function",
-        "path": "docforge.cli.main.mkdocs_cmd",
-        "signature": "<bound method Alias.signature of Alias('mkdocs_cmd', 'docforge.cli.mkdocs.mkdocs_cmd')>",
-        "docstring": "Generate an mkdocs.yml configuration file by combining a template with\nthe navigation structure resolved from a docforge.nav.yml file.\n\nArgs:\n    docs_dir: Path to the directory containing documentation Markdown files.\n    nav_file: Path to the docforge.nav.yml specification.\n    template: Optional path to an mkdocs.yml template.\n    out: Path where the final mkdocs.yml will be written.\n    site_name: The name of the documentation site."
-      },
       "cli": {
         "name": "cli",
-        "kind": "function",
+        "kind": "attribute",
         "path": "docforge.cli.main.cli",
-        "signature": "<bound method Function.signature of Function('cli', 16, 22)>",
-        "docstring": "doc-forge CLI: A tool for introspecting Python projects and generating\ndocumentation."
-      },
-      "tree": {
-        "name": "tree",
-        "kind": "function",
-        "path": "docforge.cli.main.tree",
-        "signature": "<bound method Function.signature of Function('tree', 31, 62)>",
-        "docstring": "Visualize the project structure including modules and their members.\n\nArgs:\n    modules: List of module paths to introspect.\n    project_name: Optional project name override."
-      },
-      "generate": {
-        "name": "generate",
-        "kind": "function",
-        "path": "docforge.cli.main.generate",
-        "signature": "<bound method Function.signature of Function('generate', 82, 122)>",
-        "docstring": "Generate Markdown source files for the specified module.\n\nArgs:\n    module: The primary module path to document.\n    project_name: Optional project name override.\n    docs_dir: Directory where documentation sources will be written."
-      },
-      "generate_mcp": {
-        "name": "generate_mcp",
-        "kind": "function",
-        "path": "docforge.cli.main.generate_mcp",
-        "signature": "<bound method Function.signature of Function('generate_mcp', 129, 168)>",
-        "docstring": "Generate MCP-compatible documentation resources for the specified module.\n\nArgs:\n    module: The primary module path to document.\n    project_name: Optional project name override.\n    out_dir: Directory where MCP resources will be written."
-      },
-      "build": {
-        "name": "build",
-        "kind": "function",
-        "path": "docforge.cli.main.build",
-        "signature": "<bound method Function.signature of Function('build', 175, 196)>",
-        "docstring": "Build the documentation site using MkDocs.\n\nArgs:\n    mkdocs_yml: Path to the mkdocs.yml configuration file."
-      },
-      "serve_mcp": {
-        "name": "serve_mcp",
-        "kind": "function",
-        "path": "docforge.cli.main.serve_mcp",
-        "signature": "<bound method Function.signature of Function('serve_mcp', 203, 230)>",
-        "docstring": "Serve MCP documentation from the local mcp_docs directory."
-      },
-      "serve": {
-        "name": "serve",
-        "kind": "function",
-        "path": "docforge.cli.main.serve",
-        "signature": "<bound method Function.signature of Function('serve', 237, 260)>",
-        "docstring": "Serve the documentation site with live-reload using MkDocs.\n\nArgs:\n    mkdocs_yml: Path to the mkdocs.yml configuration file."
+        "signature": "<bound method Alias.signature of Alias('cli', 'docforge.cli.commands.cli')>",
+        "docstring": null
       },
       "main": {
         "name": "main",
         "kind": "function",
         "path": "docforge.cli.main.main",
-        "signature": "<bound method Function.signature of Function('main', 267, 271)>",
-        "docstring": "CLI Entry point. Boots the click application."
+        "signature": "<bound method Function.signature of Function('main', 13, 21)>",
+        "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."
       }
     }
   }

mcp_docs/modules/docforge.cli.mcp_utils.json

@@ -0,0 +1,120 @@
+{
+  "module": "docforge.cli.mcp_utils",
+  "content": {
+    "path": "docforge.cli.mcp_utils",
+    "docstring": "# Summary\n\nUtilities for working with MCP in the doc-forge CLI.",
+    "objects": {
+      "Path": {
+        "name": "Path",
+        "kind": "alias",
+        "path": "docforge.cli.mcp_utils.Path",
+        "signature": "<bound method Alias.signature of Alias('Path', 'pathlib.Path')>",
+        "docstring": null
+      },
+      "click": {
+        "name": "click",
+        "kind": "alias",
+        "path": "docforge.cli.mcp_utils.click",
+        "signature": "<bound method Alias.signature of Alias('click', 'click')>",
+        "docstring": null
+      },
+      "GriffeLoader": {
+        "name": "GriffeLoader",
+        "kind": "class",
+        "path": "docforge.cli.mcp_utils.GriffeLoader",
+        "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.loaders.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.",
+        "members": {
+          "load_project": {
+            "name": "load_project",
+            "kind": "function",
+            "path": "docforge.cli.mcp_utils.GriffeLoader.load_project",
+            "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_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."
+          }
+        }
+      },
+      "discover_module_paths": {
+        "name": "discover_module_paths",
+        "kind": "function",
+        "path": "docforge.cli.mcp_utils.discover_module_paths",
+        "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.loaders.discover_module_paths')>",
+        "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, optional):\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": "<bound method Alias.signature of Alias('MCPRenderer', 'docforge.renderers.MCPRenderer')>",
+        "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": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mcp_renderer.MCPRenderer.name')>",
+            "docstring": null
+          },
+          "generate_sources": {
+            "name": "generate_sources",
+            "kind": "function",
+            "path": "docforge.cli.mcp_utils.MCPRenderer.generate_sources",
+            "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mcp_renderer.MCPRenderer.generate_sources')>",
+            "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": "<bound method Alias.signature of Alias('MCPServer', 'docforge.servers.MCPServer')>",
+        "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.",
+        "members": {
+          "mcp_root": {
+            "name": "mcp_root",
+            "kind": "attribute",
+            "path": "docforge.cli.mcp_utils.MCPServer.mcp_root",
+            "signature": "<bound method Alias.signature of Alias('mcp_root', 'docforge.servers.mcp_server.MCPServer.mcp_root')>",
+            "docstring": null
+          },
+          "app": {
+            "name": "app",
+            "kind": "attribute",
+            "path": "docforge.cli.mcp_utils.MCPServer.app",
+            "signature": "<bound method Alias.signature of Alias('app', 'docforge.servers.mcp_server.MCPServer.app')>",
+            "docstring": null
+          },
+          "run": {
+            "name": "run",
+            "kind": "function",
+            "path": "docforge.cli.mcp_utils.MCPServer.run",
+            "signature": "<bound method Alias.signature of Alias('run', 'docforge.servers.mcp_server.MCPServer.run')>",
+            "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": "<bound method Function.signature of Function('generate_resources', 14, 40)>",
+        "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 (Optional[str]):\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": "<bound method Function.signature of Function('serve', 43, 80)>",
+        "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."
+      }
+    }
+  }
+}

mcp_docs/modules/docforge.cli.mkdocs.json

@@ -1,95 +0,0 @@
-{
-  "module": "docforge.cli.mkdocs",
-  "content": {
-    "path": "docforge.cli.mkdocs",
-    "docstring": "This module contains the 'mkdocs' CLI command, which orchestrates the generation\nof the main mkdocs.yml configuration file.",
-    "objects": {
-      "Path": {
-        "name": "Path",
-        "kind": "alias",
-        "path": "docforge.cli.mkdocs.Path",
-        "signature": "<bound method Alias.signature of Alias('Path', 'pathlib.Path')>",
-        "docstring": null
-      },
-      "resources": {
-        "name": "resources",
-        "kind": "alias",
-        "path": "docforge.cli.mkdocs.resources",
-        "signature": "<bound method Alias.signature of Alias('resources', 'importlib.resources')>",
-        "docstring": null
-      },
-      "click": {
-        "name": "click",
-        "kind": "alias",
-        "path": "docforge.cli.mkdocs.click",
-        "signature": "<bound method Alias.signature of Alias('click', 'click')>",
-        "docstring": null
-      },
-      "yaml": {
-        "name": "yaml",
-        "kind": "alias",
-        "path": "docforge.cli.mkdocs.yaml",
-        "signature": "<bound method Alias.signature of Alias('yaml', 'yaml')>",
-        "docstring": null
-      },
-      "load_nav_spec": {
-        "name": "load_nav_spec",
-        "kind": "function",
-        "path": "docforge.cli.mkdocs.load_nav_spec",
-        "signature": "<bound method Alias.signature of Alias('load_nav_spec', 'docforge.nav.load_nav_spec')>",
-        "docstring": "Utility function to load a NavSpec from a file.\n\nArgs:\n    path: Path to the navigation specification file.\n\nReturns:\n    A loaded NavSpec instance."
-      },
-      "resolve_nav": {
-        "name": "resolve_nav",
-        "kind": "function",
-        "path": "docforge.cli.mkdocs.resolve_nav",
-        "signature": "<bound method Alias.signature of Alias('resolve_nav', 'docforge.nav.resolve_nav')>",
-        "docstring": "Create a ResolvedNav by processing a NavSpec against the filesystem.\nThis expands globs and validates the existence of referenced files.\n\nArgs:\n    spec: The navigation specification to resolve.\n    docs_root: The root directory for documentation files.\n\nReturns:\n    A ResolvedNav instance.\n\nRaises:\n    FileNotFoundError: If a pattern doesn't match any files or the docs_root doesn't exist."
-      },
-      "MkDocsNavEmitter": {
-        "name": "MkDocsNavEmitter",
-        "kind": "class",
-        "path": "docforge.cli.mkdocs.MkDocsNavEmitter",
-        "signature": "<bound method Alias.signature of Alias('MkDocsNavEmitter', 'docforge.nav.MkDocsNavEmitter')>",
-        "docstring": "Emitter responsible for transforming a ResolvedNav into an MkDocs-compatible\nnavigation structure.",
-        "members": {
-          "emit": {
-            "name": "emit",
-            "kind": "function",
-            "path": "docforge.cli.mkdocs.MkDocsNavEmitter.emit",
-            "signature": "<bound method Alias.signature of Alias('emit', 'docforge.nav.mkdocs.MkDocsNavEmitter.emit')>",
-            "docstring": "Generate a list of navigation entries for mkdocs.yml.\n\nArgs:\n    nav: The resolved navigation data.\n\nReturns:\n    A list of dictionary mappings representing the MkDocs navigation."
-          }
-        }
-      },
-      "mkdocs_cmd": {
-        "name": "mkdocs_cmd",
-        "kind": "function",
-        "path": "docforge.cli.mkdocs.mkdocs_cmd",
-        "signature": "<bound method Function.signature of Function('mkdocs_cmd', 42, 116)>",
-        "docstring": "Generate an mkdocs.yml configuration file by combining a template with\nthe navigation structure resolved from a docforge.nav.yml file.\n\nArgs:\n    docs_dir: Path to the directory containing documentation Markdown files.\n    nav_file: Path to the docforge.nav.yml specification.\n    template: Optional path to an mkdocs.yml template.\n    out: Path where the final mkdocs.yml will be written.\n    site_name: The name of the documentation site."
-      },
-      "Any": {
-        "name": "Any",
-        "kind": "alias",
-        "path": "docforge.cli.mkdocs.Any",
-        "signature": "<bound method Alias.signature of Alias('Any', 'typing.Any')>",
-        "docstring": null
-      },
-      "Dict": {
-        "name": "Dict",
-        "kind": "alias",
-        "path": "docforge.cli.mkdocs.Dict",
-        "signature": "<bound method Alias.signature of Alias('Dict', 'typing.Dict')>",
-        "docstring": null
-      },
-      "Optional": {
-        "name": "Optional",
-        "kind": "alias",
-        "path": "docforge.cli.mkdocs.Optional",
-        "signature": "<bound method Alias.signature of Alias('Optional', 'typing.Optional')>",
-        "docstring": null
-      }
-    }
-  }
-}

mcp_docs/modules/docforge.cli.mkdocs_utils.json

@@ -0,0 +1,155 @@
+{
+  "module": "docforge.cli.mkdocs_utils",
+  "content": {
+    "path": "docforge.cli.mkdocs_utils",
+    "docstring": "# Summary\n\nUtilities for working with MkDocs in the doc-forge CLI.",
+    "objects": {
+      "Path": {
+        "name": "Path",
+        "kind": "alias",
+        "path": "docforge.cli.mkdocs_utils.Path",
+        "signature": "<bound method Alias.signature of Alias('Path', 'pathlib.Path')>",
+        "docstring": null
+      },
+      "resources": {
+        "name": "resources",
+        "kind": "alias",
+        "path": "docforge.cli.mkdocs_utils.resources",
+        "signature": "<bound method Alias.signature of Alias('resources', 'importlib.resources')>",
+        "docstring": null
+      },
+      "click": {
+        "name": "click",
+        "kind": "alias",
+        "path": "docforge.cli.mkdocs_utils.click",
+        "signature": "<bound method Alias.signature of Alias('click', 'click')>",
+        "docstring": null
+      },
+      "yaml": {
+        "name": "yaml",
+        "kind": "alias",
+        "path": "docforge.cli.mkdocs_utils.yaml",
+        "signature": "<bound method Alias.signature of Alias('yaml', 'yaml')>",
+        "docstring": null
+      },
+      "GriffeLoader": {
+        "name": "GriffeLoader",
+        "kind": "class",
+        "path": "docforge.cli.mkdocs_utils.GriffeLoader",
+        "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.loaders.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.",
+        "members": {
+          "load_project": {
+            "name": "load_project",
+            "kind": "function",
+            "path": "docforge.cli.mkdocs_utils.GriffeLoader.load_project",
+            "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_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."
+          }
+        }
+      },
+      "discover_module_paths": {
+        "name": "discover_module_paths",
+        "kind": "function",
+        "path": "docforge.cli.mkdocs_utils.discover_module_paths",
+        "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.loaders.discover_module_paths')>",
+        "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, optional):\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.cli.mkdocs_utils.MkDocsRenderer",
+        "signature": "<bound method Alias.signature of Alias('MkDocsRenderer', 'docforge.renderers.MkDocsRenderer')>",
+        "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": "<bound method Alias.signature of Alias('name', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.name')>",
+            "docstring": null
+          },
+          "generate_sources": {
+            "name": "generate_sources",
+            "kind": "function",
+            "path": "docforge.cli.mkdocs_utils.MkDocsRenderer.generate_sources",
+            "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_sources')>",
+            "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, optional):\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": "<bound method Alias.signature of Alias('generate_readme', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_readme')>",
+            "docstring": "Generate a `README.md` file from the root module docstring.\n\nBehavior:\n\n- If `module_is_source` is True, `README.md` is written to the project\n  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, optional):\n        Whether the module is treated as the project source root."
+          }
+        }
+      },
+      "load_nav_spec": {
+        "name": "load_nav_spec",
+        "kind": "function",
+        "path": "docforge.cli.mkdocs_utils.load_nav_spec",
+        "signature": "<bound method Alias.signature of Alias('load_nav_spec', 'docforge.nav.load_nav_spec')>",
+        "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 to the navigation specification file.\n\nReturns:\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": "<bound method Alias.signature of Alias('resolve_nav', 'docforge.nav.resolve_nav')>",
+        "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: Navigation specification describing documentation layout.\n    docs_root: Root directory containing documentation Markdown files.\n\nReturns:\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.cli.mkdocs_utils.MkDocsNavEmitter",
+        "signature": "<bound method Alias.signature of Alias('MkDocsNavEmitter', 'docforge.nav.MkDocsNavEmitter')>",
+        "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": "<bound method Alias.signature of Alias('emit', 'docforge.nav.mkdocs.MkDocsNavEmitter.emit')>",
+            "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav: Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\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."
+          }
+        }
+      },
+      "generate_sources": {
+        "name": "generate_sources",
+        "kind": "function",
+        "path": "docforge.cli.mkdocs_utils.generate_sources",
+        "signature": "<bound method Function.signature of Function('generate_sources', 16, 59)>",
+        "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 (Optional[str]):\n        Optional override for the project name used in documentation metadata.\n\n    module_is_source (Optional[bool]):\n        If True, treat the specified module directory as the project root\n        rather than a nested module."
+      },
+      "generate_config": {
+        "name": "generate_config",
+        "kind": "function",
+        "path": "docforge.cli.mkdocs_utils.generate_config",
+        "signature": "<bound method Function.signature of Function('generate_config', 62, 120)>",
+        "docstring": "Generate an `mkdocs.yml` configuration file.\n\nThe configuration is created by combining a template configuration\nwith a navigation structure derived from the docforge navigation\nspecification.\n\nArgs:\n    docs_dir (Path):\n        Directory containing generated documentation Markdown files.\n\n    nav_file (Path):\n        Path to the `docforge.nav.yml` navigation specification.\n\n    template (Optional[Path]):\n        Optional path to a custom MkDocs configuration template. If not\n        provided, a built-in template will be used.\n\n    out (Path):\n        Destination path where the generated `mkdocs.yml` file will be written.\n\n    site_name (str):\n        Display name for the generated documentation site.\n\nRaises:\n    click.FileError:\n        If the navigation specification or template file cannot be found."
+      },
+      "build": {
+        "name": "build",
+        "kind": "function",
+        "path": "docforge.cli.mkdocs_utils.build",
+        "signature": "<bound method Function.signature of Function('build', 123, 144)>",
+        "docstring": "Build the MkDocs documentation site.\n\nThis function loads the MkDocs configuration and runs the MkDocs\nbuild command to generate the final static documentation site.\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."
+      },
+      "serve": {
+        "name": "serve",
+        "kind": "function",
+        "path": "docforge.cli.mkdocs_utils.serve",
+        "signature": "<bound method Function.signature of Function('serve', 147, 166)>",
+        "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."
+      }
+    }
+  }
+}

mcp_docs/modules/docforge.loaders.griffe_loader.json

@@ -2,7 +2,7 @@
   "module": "docforge.loaders.griffe_loader",
   "content": {
     "path": "docforge.loaders.griffe_loader",
-    "docstring": "This module provides the GriffeLoader, which uses the 'griffe' library to\nintrospect Python source code and populate the doc-forge Project models.",
+    "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.",
     "objects": {
       "logging": {
         "name": "logging",
@@ -65,7 +65,7 @@
         "kind": "class",
         "path": "docforge.loaders.griffe_loader.Module",
         "signature": "<bound method Alias.signature of Alias('Module', 'docforge.models.Module')>",
-        "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+        "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 (Optional[str]):\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",
@@ -93,21 +93,21 @@
             "kind": "function",
             "path": "docforge.loaders.griffe_loader.Module.add_object",
             "signature": "<bound method Alias.signature of Alias('add_object', 'docforge.models.module.Module.add_object')>",
-            "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+            "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": "<bound method Alias.signature of Alias('get_object', 'docforge.models.module.Module.get_object')>",
-            "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested 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.loaders.griffe_loader.Module.get_all_objects",
             "signature": "<bound method Alias.signature of Alias('get_all_objects', 'docforge.models.module.Module.get_all_objects')>",
-            "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+            "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."
           }
         }
       },
@@ -116,7 +116,7 @@
         "kind": "class",
         "path": "docforge.loaders.griffe_loader.Project",
         "signature": "<bound method Alias.signature of Alias('Project', 'docforge.models.Project')>",
-        "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+        "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",
@@ -137,28 +137,28 @@
             "kind": "function",
             "path": "docforge.loaders.griffe_loader.Project.add_module",
             "signature": "<bound method Alias.signature of Alias('add_module', 'docforge.models.project.Project.add_module')>",
-            "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+            "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": "<bound method Alias.signature of Alias('get_module', 'docforge.models.project.Project.get_module')>",
-            "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested 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.loaders.griffe_loader.Project.get_all_modules",
             "signature": "<bound method Alias.signature of Alias('get_all_modules', 'docforge.models.project.Project.get_all_modules')>",
-            "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+            "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": "<bound method Alias.signature of Alias('get_module_list', 'docforge.models.project.Project.get_module_list')>",
-            "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+            "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."
           }
         }
       },
@@ -167,7 +167,7 @@
         "kind": "class",
         "path": "docforge.loaders.griffe_loader.DocObject",
         "signature": "<bound method Alias.signature of Alias('DocObject', 'docforge.models.DocObject')>",
-        "docstring": "Represents a documented Python object (class, function, method, etc.).\n\nAttributes:\n    name: Local name of the object.\n    kind: Type of object (e.g., 'class', 'function', 'attribute').\n    path: Full dotted import path to the object.\n    signature: Callable signature, if applicable.\n    docstring: Raw docstring content extracted from the source.\n    members: Dictionary mapping member names to their DocObject representations.",
+        "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 (Optional[str]):\n        Callable signature if the object represents a callable.\n\n    docstring (Optional[str]):\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",
@@ -216,21 +216,21 @@
             "kind": "function",
             "path": "docforge.loaders.griffe_loader.DocObject.add_member",
             "signature": "<bound method Alias.signature of Alias('add_member', 'docforge.models.object.DocObject.add_member')>",
-            "docstring": "Add a child member to this object (e.g., a method to a class).\n\nArgs:\n    obj: The child DocObject to add."
+            "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: Documentation object to add as a member."
           },
           "get_member": {
             "name": "get_member",
             "kind": "function",
             "path": "docforge.loaders.griffe_loader.DocObject.get_member",
             "signature": "<bound method Alias.signature of Alias('get_member', 'docforge.models.object.DocObject.get_member')>",
-            "docstring": "Retrieve a child member by name.\n\nArgs:\n    name: The name of the member.\n\nReturns:\n    The requested 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.loaders.griffe_loader.DocObject.get_all_members",
             "signature": "<bound method Alias.signature of Alias('get_all_members', 'docforge.models.object.DocObject.get_all_members')>",
-            "docstring": "Get all members of this object.\n\nReturns:\n    An iterable of child DocObject instances."
+            "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
           }
         }
       },
@@ -245,29 +245,29 @@
         "name": "discover_module_paths",
         "kind": "function",
         "path": "docforge.loaders.griffe_loader.discover_module_paths",
-        "signature": "<bound method Function.signature of Function('discover_module_paths', 23, 62)>",
-        "docstring": "Discover all Python modules under a package via filesystem traversal.\n\nRules:\n- Directory with __init__.py is treated as a package.\n- Any .py file is treated as a module.\n- All paths are converted to dotted module paths.\n\nArgs:\n    module_name: The name of the package to discover.\n    project_root: The root directory of the project. Defaults to current working directory.\n\nReturns:\n    A sorted list of dotted module paths."
+        "signature": "<bound method Function.signature of Function('discover_module_paths', 28, 80)>",
+        "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, optional):\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": "<bound method Class.signature of Class('GriffeLoader', 65, 224)>",
-        "docstring": "Loads Python modules and extracts documentation using the Griffe introspection engine.",
+        "signature": "<bound method Class.signature of Class('GriffeLoader', 83, 287)>",
+        "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.",
         "members": {
           "load_project": {
             "name": "load_project",
             "kind": "function",
             "path": "docforge.loaders.griffe_loader.GriffeLoader.load_project",
-            "signature": "<bound method Function.signature of Function('load_project', 79, 115)>",
-            "docstring": "Load multiple modules and combine them into a single Project models.\n\nArgs:\n    module_paths: A list of dotted paths to the modules to load.\n    project_name: Optional name for the project. Defaults to the first module name.\n    skip_import_errors: If True, modules that fail to import will be skipped.\n\nReturns:\n    A Project instance containing the loaded modules."
+            "signature": "<bound method Function.signature of Function('load_project', 104, 158)>",
+            "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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Function.signature of Function('load_module', 117, 130)>",
-            "docstring": "Load a single module and convert its introspection data into the docforge models.\n\nArgs:\n    path: The dotted path of the module to load.\n\nReturns:\n    A Module instance."
+            "signature": "<bound method Function.signature of Function('load_module', 160, 178)>",
+            "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."
           }
         }
       }

mcp_docs/modules/docforge.loaders.json

@@ -2,28 +2,28 @@
   "module": "docforge.loaders",
   "content": {
     "path": "docforge.loaders",
-    "docstring": "# Loader Layer\n\nThe `docforge.loaders` package is responsible for discovering Python source files\nand extracting their documentation using static analysis.\n\n## Core Features\n\n- **Discovery**: Automatically find all modules and packages in a project\n  directory.\n- **Introspection**: Uses `griffe` to parse docstrings, signatures, and\n  hierarchical relationships without executing the code.\n- **Filtering**: Automatically excludes private members (prefixed with `_`) to\n  ensure clean public documentation.",
+    "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---",
     "objects": {
       "GriffeLoader": {
         "name": "GriffeLoader",
         "kind": "class",
         "path": "docforge.loaders.GriffeLoader",
         "signature": "<bound method Alias.signature of Alias('GriffeLoader', 'docforge.loaders.griffe_loader.GriffeLoader')>",
-        "docstring": "Loads Python modules and extracts documentation using the Griffe introspection engine.",
+        "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.",
         "members": {
           "load_project": {
             "name": "load_project",
             "kind": "function",
             "path": "docforge.loaders.GriffeLoader.load_project",
             "signature": "<bound method Alias.signature of Alias('load_project', 'docforge.loaders.griffe_loader.GriffeLoader.load_project')>",
-            "docstring": "Load multiple modules and combine them into a single Project models.\n\nArgs:\n    module_paths: A list of dotted paths to the modules to load.\n    project_name: Optional name for the project. Defaults to the first module name.\n    skip_import_errors: If True, modules that fail to import will be skipped.\n\nReturns:\n    A Project instance containing the loaded modules."
+            "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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Alias.signature of Alias('load_module', 'docforge.loaders.griffe_loader.GriffeLoader.load_module')>",
-            "docstring": "Load a single module and convert its introspection data into the docforge models.\n\nArgs:\n    path: The dotted path of the module to load.\n\nReturns:\n    A Module instance."
+            "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."
           }
         }
       },
@@ -32,14 +32,14 @@
         "kind": "function",
         "path": "docforge.loaders.discover_module_paths",
         "signature": "<bound method Alias.signature of Alias('discover_module_paths', 'docforge.loaders.griffe_loader.discover_module_paths')>",
-        "docstring": "Discover all Python modules under a package via filesystem traversal.\n\nRules:\n- Directory with __init__.py is treated as a package.\n- Any .py file is treated as a module.\n- All paths are converted to dotted module paths.\n\nArgs:\n    module_name: The name of the package to discover.\n    project_root: The root directory of the project. Defaults to current working directory.\n\nReturns:\n    A sorted list of dotted module paths."
+        "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, optional):\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": "This module provides the GriffeLoader, which uses the 'griffe' library to\nintrospect Python source code and populate the doc-forge Project models.",
+        "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.",
         "members": {
           "logging": {
             "name": "logging",
@@ -102,7 +102,7 @@
             "kind": "class",
             "path": "docforge.loaders.griffe_loader.Module",
             "signature": "<bound method Alias.signature of Alias('Module', 'docforge.models.Module')>",
-            "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+            "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 (Optional[str]):\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",
@@ -130,21 +130,21 @@
                 "kind": "function",
                 "path": "docforge.loaders.griffe_loader.Module.add_object",
                 "signature": "<bound method Alias.signature of Alias('add_object', 'docforge.models.module.Module.add_object')>",
-                "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+                "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": "<bound method Alias.signature of Alias('get_object', 'docforge.models.module.Module.get_object')>",
-                "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested 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.loaders.griffe_loader.Module.get_all_objects",
                 "signature": "<bound method Alias.signature of Alias('get_all_objects', 'docforge.models.module.Module.get_all_objects')>",
-                "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+                "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."
               }
             }
           },
@@ -153,7 +153,7 @@
             "kind": "class",
             "path": "docforge.loaders.griffe_loader.Project",
             "signature": "<bound method Alias.signature of Alias('Project', 'docforge.models.Project')>",
-            "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+            "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",
@@ -174,28 +174,28 @@
                 "kind": "function",
                 "path": "docforge.loaders.griffe_loader.Project.add_module",
                 "signature": "<bound method Alias.signature of Alias('add_module', 'docforge.models.project.Project.add_module')>",
-                "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+                "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": "<bound method Alias.signature of Alias('get_module', 'docforge.models.project.Project.get_module')>",
-                "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested 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.loaders.griffe_loader.Project.get_all_modules",
                 "signature": "<bound method Alias.signature of Alias('get_all_modules', 'docforge.models.project.Project.get_all_modules')>",
-                "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+                "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": "<bound method Alias.signature of Alias('get_module_list', 'docforge.models.project.Project.get_module_list')>",
-                "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+                "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."
               }
             }
           },
@@ -204,7 +204,7 @@
             "kind": "class",
             "path": "docforge.loaders.griffe_loader.DocObject",
             "signature": "<bound method Alias.signature of Alias('DocObject', 'docforge.models.DocObject')>",
-            "docstring": "Represents a documented Python object (class, function, method, etc.).\n\nAttributes:\n    name: Local name of the object.\n    kind: Type of object (e.g., 'class', 'function', 'attribute').\n    path: Full dotted import path to the object.\n    signature: Callable signature, if applicable.\n    docstring: Raw docstring content extracted from the source.\n    members: Dictionary mapping member names to their DocObject representations.",
+            "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 (Optional[str]):\n        Callable signature if the object represents a callable.\n\n    docstring (Optional[str]):\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",
@@ -253,21 +253,21 @@
                 "kind": "function",
                 "path": "docforge.loaders.griffe_loader.DocObject.add_member",
                 "signature": "<bound method Alias.signature of Alias('add_member', 'docforge.models.object.DocObject.add_member')>",
-                "docstring": "Add a child member to this object (e.g., a method to a class).\n\nArgs:\n    obj: The child DocObject to add."
+                "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: Documentation object to add as a member."
               },
               "get_member": {
                 "name": "get_member",
                 "kind": "function",
                 "path": "docforge.loaders.griffe_loader.DocObject.get_member",
                 "signature": "<bound method Alias.signature of Alias('get_member', 'docforge.models.object.DocObject.get_member')>",
-                "docstring": "Retrieve a child member by name.\n\nArgs:\n    name: The name of the member.\n\nReturns:\n    The requested 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.loaders.griffe_loader.DocObject.get_all_members",
                 "signature": "<bound method Alias.signature of Alias('get_all_members', 'docforge.models.object.DocObject.get_all_members')>",
-                "docstring": "Get all members of this object.\n\nReturns:\n    An iterable of child DocObject instances."
+                "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
               }
             }
           },
@@ -282,29 +282,29 @@
             "name": "discover_module_paths",
             "kind": "function",
             "path": "docforge.loaders.griffe_loader.discover_module_paths",
-            "signature": "<bound method Function.signature of Function('discover_module_paths', 23, 62)>",
-            "docstring": "Discover all Python modules under a package via filesystem traversal.\n\nRules:\n- Directory with __init__.py is treated as a package.\n- Any .py file is treated as a module.\n- All paths are converted to dotted module paths.\n\nArgs:\n    module_name: The name of the package to discover.\n    project_root: The root directory of the project. Defaults to current working directory.\n\nReturns:\n    A sorted list of dotted module paths."
+            "signature": "<bound method Function.signature of Function('discover_module_paths', 28, 80)>",
+            "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, optional):\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": "<bound method Class.signature of Class('GriffeLoader', 65, 224)>",
-            "docstring": "Loads Python modules and extracts documentation using the Griffe introspection engine.",
+            "signature": "<bound method Class.signature of Class('GriffeLoader', 83, 287)>",
+            "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.",
             "members": {
               "load_project": {
                 "name": "load_project",
                 "kind": "function",
                 "path": "docforge.loaders.griffe_loader.GriffeLoader.load_project",
-                "signature": "<bound method Function.signature of Function('load_project', 79, 115)>",
-                "docstring": "Load multiple modules and combine them into a single Project models.\n\nArgs:\n    module_paths: A list of dotted paths to the modules to load.\n    project_name: Optional name for the project. Defaults to the first module name.\n    skip_import_errors: If True, modules that fail to import will be skipped.\n\nReturns:\n    A Project instance containing the loaded modules."
+                "signature": "<bound method Function.signature of Function('load_project', 104, 158)>",
+                "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, optional):\n        Optional override for the project name. Defaults to the top-level\n        name of the first module.\n\n    skip_import_errors (bool, optional):\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": "<bound method Function.signature of Function('load_module', 117, 130)>",
-                "docstring": "Load a single module and convert its introspection data into the docforge models.\n\nArgs:\n    path: The dotted path of the module to load.\n\nReturns:\n    A Module instance."
+                "signature": "<bound method Function.signature of Function('load_module', 160, 178)>",
+                "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."
               }
             }
           }

mcp_docs/modules/docforge.models.json

@@ -2,14 +2,14 @@
   "module": "docforge.models",
   "content": {
     "path": "docforge.models",
-    "docstring": "# Model Layer\n\nThe `docforge.models` package provides the core data structures used to represent\nPython source code in a documentation-focused hierarchy.\n\n## Key Components\n\n- **Project**: The root container for all documented modules.\n- **Module**: Represents a Python module or package, containing members.\n- **DocObject**: A recursive structure for classes, functions, and attributes.\n\nThese classes are designed to be renderer-agnostic, allowing the same internal\nrepresentation to be transformed into various output formats (currently MkDocs).",
+    "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---",
     "objects": {
       "Project": {
         "name": "Project",
         "kind": "class",
         "path": "docforge.models.Project",
         "signature": "<bound method Alias.signature of Alias('Project', 'docforge.models.project.Project')>",
-        "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+        "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",
@@ -30,28 +30,28 @@
             "kind": "function",
             "path": "docforge.models.Project.add_module",
             "signature": "<bound method Alias.signature of Alias('add_module', 'docforge.models.project.Project.add_module')>",
-            "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+            "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": "<bound method Alias.signature of Alias('get_module', 'docforge.models.project.Project.get_module')>",
-            "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested 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.get_all_modules",
             "signature": "<bound method Alias.signature of Alias('get_all_modules', 'docforge.models.project.Project.get_all_modules')>",
-            "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+            "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": "<bound method Alias.signature of Alias('get_module_list', 'docforge.models.project.Project.get_module_list')>",
-            "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+            "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."
           }
         }
       },
@@ -60,7 +60,7 @@
         "kind": "class",
         "path": "docforge.models.Module",
         "signature": "<bound method Alias.signature of Alias('Module', 'docforge.models.module.Module')>",
-        "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+        "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 (Optional[str]):\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",
@@ -88,21 +88,21 @@
             "kind": "function",
             "path": "docforge.models.Module.add_object",
             "signature": "<bound method Alias.signature of Alias('add_object', 'docforge.models.module.Module.add_object')>",
-            "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+            "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": "<bound method Alias.signature of Alias('get_object', 'docforge.models.module.Module.get_object')>",
-            "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested 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.get_all_objects",
             "signature": "<bound method Alias.signature of Alias('get_all_objects', 'docforge.models.module.Module.get_all_objects')>",
-            "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+            "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."
           }
         }
       },
@@ -111,7 +111,7 @@
         "kind": "class",
         "path": "docforge.models.DocObject",
         "signature": "<bound method Alias.signature of Alias('DocObject', 'docforge.models.object.DocObject')>",
-        "docstring": "Represents a documented Python object (class, function, method, etc.).\n\nAttributes:\n    name: Local name of the object.\n    kind: Type of object (e.g., 'class', 'function', 'attribute').\n    path: Full dotted import path to the object.\n    signature: Callable signature, if applicable.\n    docstring: Raw docstring content extracted from the source.\n    members: Dictionary mapping member names to their DocObject representations.",
+        "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 (Optional[str]):\n        Callable signature if the object represents a callable.\n\n    docstring (Optional[str]):\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",
@@ -160,21 +160,21 @@
             "kind": "function",
             "path": "docforge.models.DocObject.add_member",
             "signature": "<bound method Alias.signature of Alias('add_member', 'docforge.models.object.DocObject.add_member')>",
-            "docstring": "Add a child member to this object (e.g., a method to a class).\n\nArgs:\n    obj: The child DocObject to add."
+            "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: Documentation object to add as a member."
           },
           "get_member": {
             "name": "get_member",
             "kind": "function",
             "path": "docforge.models.DocObject.get_member",
             "signature": "<bound method Alias.signature of Alias('get_member', 'docforge.models.object.DocObject.get_member')>",
-            "docstring": "Retrieve a child member by name.\n\nArgs:\n    name: The name of the member.\n\nReturns:\n    The requested 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.DocObject.get_all_members",
             "signature": "<bound method Alias.signature of Alias('get_all_members', 'docforge.models.object.DocObject.get_all_members')>",
-            "docstring": "Get all members of this object.\n\nReturns:\n    An iterable of child DocObject instances."
+            "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
           }
         }
       },
@@ -183,7 +183,7 @@
         "kind": "module",
         "path": "docforge.models.module",
         "signature": null,
-        "docstring": "This module defines the Module class, which represents a Python module or package\nin the doc-forge documentation models. It acts as a container for top-level\ndocumented objects.",
+        "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.",
         "members": {
           "Dict": {
             "name": "Dict",
@@ -211,7 +211,7 @@
             "kind": "class",
             "path": "docforge.models.module.DocObject",
             "signature": "<bound method Alias.signature of Alias('DocObject', 'docforge.models.object.DocObject')>",
-            "docstring": "Represents a documented Python object (class, function, method, etc.).\n\nAttributes:\n    name: Local name of the object.\n    kind: Type of object (e.g., 'class', 'function', 'attribute').\n    path: Full dotted import path to the object.\n    signature: Callable signature, if applicable.\n    docstring: Raw docstring content extracted from the source.\n    members: Dictionary mapping member names to their DocObject representations.",
+            "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 (Optional[str]):\n        Callable signature if the object represents a callable.\n\n    docstring (Optional[str]):\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",
@@ -260,21 +260,21 @@
                 "kind": "function",
                 "path": "docforge.models.module.DocObject.add_member",
                 "signature": "<bound method Alias.signature of Alias('add_member', 'docforge.models.object.DocObject.add_member')>",
-                "docstring": "Add a child member to this object (e.g., a method to a class).\n\nArgs:\n    obj: The child DocObject to add."
+                "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: Documentation object to add as a member."
               },
               "get_member": {
                 "name": "get_member",
                 "kind": "function",
                 "path": "docforge.models.module.DocObject.get_member",
                 "signature": "<bound method Alias.signature of Alias('get_member', 'docforge.models.object.DocObject.get_member')>",
-                "docstring": "Retrieve a child member by name.\n\nArgs:\n    name: The name of the member.\n\nReturns:\n    The requested 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.module.DocObject.get_all_members",
                 "signature": "<bound method Alias.signature of Alias('get_all_members', 'docforge.models.object.DocObject.get_all_members')>",
-                "docstring": "Get all members of this object.\n\nReturns:\n    An iterable of child DocObject instances."
+                "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
               }
             }
           },
@@ -282,8 +282,8 @@
             "name": "Module",
             "kind": "class",
             "path": "docforge.models.module.Module",
-            "signature": "<bound method Class.signature of Class('Module', 12, 66)>",
-            "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+            "signature": "<bound method Class.signature of Class('Module', 17, 91)>",
+            "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 (Optional[str]):\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",
@@ -310,22 +310,22 @@
                 "name": "add_object",
                 "kind": "function",
                 "path": "docforge.models.module.Module.add_object",
-                "signature": "<bound method Function.signature of Function('add_object', 38, 45)>",
-                "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+                "signature": "<bound method Function.signature of Function('add_object', 55, 63)>",
+                "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": "<bound method Function.signature of Function('get_object', 47, 57)>",
-                "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested DocObject."
+                "signature": "<bound method Function.signature of Function('get_object', 65, 81)>",
+                "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": "<bound method Function.signature of Function('get_all_objects', 59, 66)>",
-                "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+                "signature": "<bound method Function.signature of Function('get_all_objects', 83, 91)>",
+                "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."
               }
             }
           }
@@ -336,7 +336,7 @@
         "kind": "module",
         "path": "docforge.models.object",
         "signature": null,
-        "docstring": "This module defines the DocObject class, the fundamental recursive unit of the\ndoc-forge documentation models. A DocObject represents a single Python entity\n(class, function, method, or attribute) and its nested members.",
+        "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.",
         "members": {
           "Dict": {
             "name": "Dict",
@@ -363,8 +363,8 @@
             "name": "DocObject",
             "kind": "class",
             "path": "docforge.models.object.DocObject",
-            "signature": "<bound method Class.signature of Class('DocObject', 10, 76)>",
-            "docstring": "Represents a documented Python object (class, function, method, etc.).\n\nAttributes:\n    name: Local name of the object.\n    kind: Type of object (e.g., 'class', 'function', 'attribute').\n    path: Full dotted import path to the object.\n    signature: Callable signature, if applicable.\n    docstring: Raw docstring content extracted from the source.\n    members: Dictionary mapping member names to their DocObject representations.",
+            "signature": "<bound method Class.signature of Class('DocObject', 15, 115)>",
+            "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 (Optional[str]):\n        Callable signature if the object represents a callable.\n\n    docstring (Optional[str]):\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",
@@ -412,22 +412,22 @@
                 "name": "add_member",
                 "kind": "function",
                 "path": "docforge.models.object.DocObject.add_member",
-                "signature": "<bound method Function.signature of Function('add_member', 48, 55)>",
-                "docstring": "Add a child member to this object (e.g., a method to a class).\n\nArgs:\n    obj: The child DocObject to add."
+                "signature": "<bound method Function.signature of Function('add_member', 77, 87)>",
+                "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: Documentation object to add as a member."
               },
               "get_member": {
                 "name": "get_member",
                 "kind": "function",
                 "path": "docforge.models.object.DocObject.get_member",
-                "signature": "<bound method Function.signature of Function('get_member', 57, 67)>",
-                "docstring": "Retrieve a child member by name.\n\nArgs:\n    name: The name of the member.\n\nReturns:\n    The requested DocObject."
+                "signature": "<bound method Function.signature of Function('get_member', 89, 105)>",
+                "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": "<bound method Function.signature of Function('get_all_members', 69, 76)>",
-                "docstring": "Get all members of this object.\n\nReturns:\n    An iterable of child DocObject instances."
+                "signature": "<bound method Function.signature of Function('get_all_members', 107, 115)>",
+                "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
               }
             }
           }
@@ -438,7 +438,7 @@
         "kind": "module",
         "path": "docforge.models.project",
         "signature": null,
-        "docstring": "This module defines the Project class, the top-level container for a documented\nproject. It aggregates multiple Module instances into a single named entity.",
+        "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.",
         "members": {
           "Dict": {
             "name": "Dict",
@@ -459,7 +459,7 @@
             "kind": "class",
             "path": "docforge.models.project.Module",
             "signature": "<bound method Alias.signature of Alias('Module', 'docforge.models.module.Module')>",
-            "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+            "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 (Optional[str]):\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",
@@ -487,21 +487,21 @@
                 "kind": "function",
                 "path": "docforge.models.project.Module.add_object",
                 "signature": "<bound method Alias.signature of Alias('add_object', 'docforge.models.module.Module.add_object')>",
-                "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+                "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": "<bound method Alias.signature of Alias('get_object', 'docforge.models.module.Module.get_object')>",
-                "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested 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.project.Module.get_all_objects",
                 "signature": "<bound method Alias.signature of Alias('get_all_objects', 'docforge.models.module.Module.get_all_objects')>",
-                "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+                "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."
               }
             }
           },
@@ -509,8 +509,8 @@
             "name": "Project",
             "kind": "class",
             "path": "docforge.models.project.Project",
-            "signature": "<bound method Class.signature of Class('Project', 11, 67)>",
-            "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+            "signature": "<bound method Class.signature of Class('Project', 16, 88)>",
+            "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",
@@ -530,29 +530,29 @@
                 "name": "add_module",
                 "kind": "function",
                 "path": "docforge.models.project.Project.add_module",
-                "signature": "<bound method Function.signature of Function('add_module', 30, 37)>",
-                "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+                "signature": "<bound method Function.signature of Function('add_module', 42, 50)>",
+                "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": "<bound method Function.signature of Function('get_module', 39, 49)>",
-                "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested Module."
+                "signature": "<bound method Function.signature of Function('get_module', 52, 68)>",
+                "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": "<bound method Function.signature of Function('get_all_modules', 51, 58)>",
-                "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+                "signature": "<bound method Function.signature of Function('get_all_modules', 70, 78)>",
+                "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": "<bound method Function.signature of Function('get_module_list', 60, 67)>",
-                "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+                "signature": "<bound method Function.signature of Function('get_module_list', 80, 88)>",
+                "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."
               }
             }
           }

mcp_docs/modules/docforge.models.module.json

@@ -2,7 +2,7 @@
   "module": "docforge.models.module",
   "content": {
     "path": "docforge.models.module",
-    "docstring": "This module defines the Module class, which represents a Python module or package\nin the doc-forge documentation models. It acts as a container for top-level\ndocumented objects.",
+    "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.",
     "objects": {
       "Dict": {
         "name": "Dict",
@@ -30,7 +30,7 @@
         "kind": "class",
         "path": "docforge.models.module.DocObject",
         "signature": "<bound method Alias.signature of Alias('DocObject', 'docforge.models.object.DocObject')>",
-        "docstring": "Represents a documented Python object (class, function, method, etc.).\n\nAttributes:\n    name: Local name of the object.\n    kind: Type of object (e.g., 'class', 'function', 'attribute').\n    path: Full dotted import path to the object.\n    signature: Callable signature, if applicable.\n    docstring: Raw docstring content extracted from the source.\n    members: Dictionary mapping member names to their DocObject representations.",
+        "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 (Optional[str]):\n        Callable signature if the object represents a callable.\n\n    docstring (Optional[str]):\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",
@@ -79,21 +79,21 @@
             "kind": "function",
             "path": "docforge.models.module.DocObject.add_member",
             "signature": "<bound method Alias.signature of Alias('add_member', 'docforge.models.object.DocObject.add_member')>",
-            "docstring": "Add a child member to this object (e.g., a method to a class).\n\nArgs:\n    obj: The child DocObject to add."
+            "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: Documentation object to add as a member."
           },
           "get_member": {
             "name": "get_member",
             "kind": "function",
             "path": "docforge.models.module.DocObject.get_member",
             "signature": "<bound method Alias.signature of Alias('get_member', 'docforge.models.object.DocObject.get_member')>",
-            "docstring": "Retrieve a child member by name.\n\nArgs:\n    name: The name of the member.\n\nReturns:\n    The requested 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.module.DocObject.get_all_members",
             "signature": "<bound method Alias.signature of Alias('get_all_members', 'docforge.models.object.DocObject.get_all_members')>",
-            "docstring": "Get all members of this object.\n\nReturns:\n    An iterable of child DocObject instances."
+            "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
           }
         }
       },
@@ -101,8 +101,8 @@
         "name": "Module",
         "kind": "class",
         "path": "docforge.models.module.Module",
-        "signature": "<bound method Class.signature of Class('Module', 12, 66)>",
-        "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+        "signature": "<bound method Class.signature of Class('Module', 17, 91)>",
+        "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 (Optional[str]):\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",
@@ -129,22 +129,22 @@
             "name": "add_object",
             "kind": "function",
             "path": "docforge.models.module.Module.add_object",
-            "signature": "<bound method Function.signature of Function('add_object', 38, 45)>",
-            "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+            "signature": "<bound method Function.signature of Function('add_object', 55, 63)>",
+            "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": "<bound method Function.signature of Function('get_object', 47, 57)>",
-            "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested DocObject."
+            "signature": "<bound method Function.signature of Function('get_object', 65, 81)>",
+            "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": "<bound method Function.signature of Function('get_all_objects', 59, 66)>",
-            "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+            "signature": "<bound method Function.signature of Function('get_all_objects', 83, 91)>",
+            "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."
           }
         }
       }

mcp_docs/modules/docforge.models.object.json

@@ -2,7 +2,7 @@
   "module": "docforge.models.object",
   "content": {
     "path": "docforge.models.object",
-    "docstring": "This module defines the DocObject class, the fundamental recursive unit of the\ndoc-forge documentation models. A DocObject represents a single Python entity\n(class, function, method, or attribute) and its nested members.",
+    "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.",
     "objects": {
       "Dict": {
         "name": "Dict",
@@ -29,8 +29,8 @@
         "name": "DocObject",
         "kind": "class",
         "path": "docforge.models.object.DocObject",
-        "signature": "<bound method Class.signature of Class('DocObject', 10, 76)>",
-        "docstring": "Represents a documented Python object (class, function, method, etc.).\n\nAttributes:\n    name: Local name of the object.\n    kind: Type of object (e.g., 'class', 'function', 'attribute').\n    path: Full dotted import path to the object.\n    signature: Callable signature, if applicable.\n    docstring: Raw docstring content extracted from the source.\n    members: Dictionary mapping member names to their DocObject representations.",
+        "signature": "<bound method Class.signature of Class('DocObject', 15, 115)>",
+        "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 (Optional[str]):\n        Callable signature if the object represents a callable.\n\n    docstring (Optional[str]):\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",
@@ -78,22 +78,22 @@
             "name": "add_member",
             "kind": "function",
             "path": "docforge.models.object.DocObject.add_member",
-            "signature": "<bound method Function.signature of Function('add_member', 48, 55)>",
-            "docstring": "Add a child member to this object (e.g., a method to a class).\n\nArgs:\n    obj: The child DocObject to add."
+            "signature": "<bound method Function.signature of Function('add_member', 77, 87)>",
+            "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: Documentation object to add as a member."
           },
           "get_member": {
             "name": "get_member",
             "kind": "function",
             "path": "docforge.models.object.DocObject.get_member",
-            "signature": "<bound method Function.signature of Function('get_member', 57, 67)>",
-            "docstring": "Retrieve a child member by name.\n\nArgs:\n    name: The name of the member.\n\nReturns:\n    The requested DocObject."
+            "signature": "<bound method Function.signature of Function('get_member', 89, 105)>",
+            "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": "<bound method Function.signature of Function('get_all_members', 69, 76)>",
-            "docstring": "Get all members of this object.\n\nReturns:\n    An iterable of child DocObject instances."
+            "signature": "<bound method Function.signature of Function('get_all_members', 107, 115)>",
+            "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
           }
         }
       }

mcp_docs/modules/docforge.models.project.json

@@ -2,7 +2,7 @@
   "module": "docforge.models.project",
   "content": {
     "path": "docforge.models.project",
-    "docstring": "This module defines the Project class, the top-level container for a documented\nproject. It aggregates multiple Module instances into a single named entity.",
+    "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.",
     "objects": {
       "Dict": {
         "name": "Dict",
@@ -23,7 +23,7 @@
         "kind": "class",
         "path": "docforge.models.project.Module",
         "signature": "<bound method Alias.signature of Alias('Module', 'docforge.models.module.Module')>",
-        "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+        "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 (Optional[str]):\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",
@@ -51,21 +51,21 @@
             "kind": "function",
             "path": "docforge.models.project.Module.add_object",
             "signature": "<bound method Alias.signature of Alias('add_object', 'docforge.models.module.Module.add_object')>",
-            "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+            "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": "<bound method Alias.signature of Alias('get_object', 'docforge.models.module.Module.get_object')>",
-            "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested 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.project.Module.get_all_objects",
             "signature": "<bound method Alias.signature of Alias('get_all_objects', 'docforge.models.module.Module.get_all_objects')>",
-            "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+            "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."
           }
         }
       },
@@ -73,8 +73,8 @@
         "name": "Project",
         "kind": "class",
         "path": "docforge.models.project.Project",
-        "signature": "<bound method Class.signature of Class('Project', 11, 67)>",
-        "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+        "signature": "<bound method Class.signature of Class('Project', 16, 88)>",
+        "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",
@@ -94,29 +94,29 @@
             "name": "add_module",
             "kind": "function",
             "path": "docforge.models.project.Project.add_module",
-            "signature": "<bound method Function.signature of Function('add_module', 30, 37)>",
-            "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+            "signature": "<bound method Function.signature of Function('add_module', 42, 50)>",
+            "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": "<bound method Function.signature of Function('get_module', 39, 49)>",
-            "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested Module."
+            "signature": "<bound method Function.signature of Function('get_module', 52, 68)>",
+            "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": "<bound method Function.signature of Function('get_all_modules', 51, 58)>",
-            "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+            "signature": "<bound method Function.signature of Function('get_all_modules', 70, 78)>",
+            "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": "<bound method Function.signature of Function('get_module_list', 60, 67)>",
-            "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+            "signature": "<bound method Function.signature of Function('get_module_list', 80, 88)>",
+            "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."
           }
         }
       }

mcp_docs/modules/docforge.nav.json

@@ -2,14 +2,14 @@
   "module": "docforge.nav",
   "content": {
     "path": "docforge.nav",
-    "docstring": "# Navigation Layer\n\nThe `docforge.nav` package manages the mapping between the logical documentation\nstructure and the physical files on disk.\n\n## Workflow\n\n1.  **Spec Definition**: Users define navigation intent in `docforge.nav.yml`.\n2.  **Resolution**: `resolve_nav` matches patterns in the spec to generated `.md` files.\n3.  **Emission**: `MkDocsNavEmitter` produces the final YAML structure for `mkdocs.yml`.\n\nThis abstraction allows doc-forge to support complex grouping and ordering\nindependently of the source code's physical layout.",
+    "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---",
     "objects": {
       "NavSpec": {
         "name": "NavSpec",
         "kind": "class",
         "path": "docforge.nav.NavSpec",
         "signature": "<bound method Alias.signature of Alias('NavSpec', 'docforge.nav.spec.NavSpec')>",
-        "docstring": "Parsed representation of the docforge navigation specification file.\n\nAttributes:\n    home: Path to the home document (e.g., 'index.md').\n    groups: Mapping of group titles to lists of path patterns/globs.",
+        "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.",
         "members": {
           "home": {
             "name": "home",
@@ -30,14 +30,14 @@
             "kind": "function",
             "path": "docforge.nav.NavSpec.load",
             "signature": "<bound method Alias.signature of Alias('load', 'docforge.nav.spec.NavSpec.load')>",
-            "docstring": "Load a NavSpec from a YAML file.\n\nArgs:\n    path: The filesystem path to the YAML file.\n\nReturns:\n    A NavSpec instance.\n\nRaises:\n    FileNotFoundError: If the path does not exist.\n    ValueError: If the file content is not a valid NavSpec mapping."
+            "docstring": "Load a navigation specification from a YAML file.\n\nArgs:\n    path: Filesystem path to the navigation specification file.\n\nReturns:\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": "<bound method Alias.signature of Alias('all_patterns', 'docforge.nav.spec.NavSpec.all_patterns')>",
-            "docstring": "Get all path patterns referenced in the specification.\n\nReturns:\n    A list of all patterns (home plus all groups)."
+            "docstring": "Return all path patterns referenced by the specification.\n\nReturns:\n    A list containing the home document (if defined) and all\n    group pattern entries."
           }
         }
       },
@@ -46,14 +46,14 @@
         "kind": "function",
         "path": "docforge.nav.load_nav_spec",
         "signature": "<bound method Alias.signature of Alias('load_nav_spec', 'docforge.nav.spec.load_nav_spec')>",
-        "docstring": "Utility function to load a NavSpec from a file.\n\nArgs:\n    path: Path to the navigation specification file.\n\nReturns:\n    A loaded NavSpec instance."
+        "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 to the navigation specification file.\n\nReturns:\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": "<bound method Alias.signature of Alias('ResolvedNav', 'docforge.nav.resolver.ResolvedNav')>",
-        "docstring": "Represents a navigation structure where all patterns and paths have been\nresolved against the actual filesystem contents.\n\nAttributes:\n    home: Resolved relative path to the home page.\n    groups: Mapping of group titles to lists of absolute or relative Path objects.",
+        "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",
@@ -74,7 +74,7 @@
             "kind": "function",
             "path": "docforge.nav.ResolvedNav.all_files",
             "signature": "<bound method Alias.signature of Alias('all_files', 'docforge.nav.resolver.ResolvedNav.all_files')>",
-            "docstring": "Get an iterable of all resolved files in the navigation structure.\n\nReturns:\n    An iterable of Path objects."
+            "docstring": "Iterate over all files referenced by the navigation structure.\n\nReturns:\n    An iterable of ``Path`` objects representing documentation files.\n\nRaises:\n    RuntimeError: If the home page is defined but the documentation\n        root is not available for resolution."
           }
         }
       },
@@ -83,21 +83,21 @@
         "kind": "function",
         "path": "docforge.nav.resolve_nav",
         "signature": "<bound method Alias.signature of Alias('resolve_nav', 'docforge.nav.resolver.resolve_nav')>",
-        "docstring": "Create a ResolvedNav by processing a NavSpec against the filesystem.\nThis expands globs and validates the existence of referenced files.\n\nArgs:\n    spec: The navigation specification to resolve.\n    docs_root: The root directory for documentation files.\n\nReturns:\n    A ResolvedNav instance.\n\nRaises:\n    FileNotFoundError: If a pattern doesn't match any files or the docs_root doesn't exist."
+        "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: Navigation specification describing documentation layout.\n    docs_root: Root directory containing documentation Markdown files.\n\nReturns:\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": "<bound method Alias.signature of Alias('MkDocsNavEmitter', 'docforge.nav.mkdocs.MkDocsNavEmitter')>",
-        "docstring": "Emitter responsible for transforming a ResolvedNav into an MkDocs-compatible\nnavigation structure.",
+        "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": "<bound method Alias.signature of Alias('emit', 'docforge.nav.mkdocs.MkDocsNavEmitter.emit')>",
-            "docstring": "Generate a list of navigation entries for mkdocs.yml.\n\nArgs:\n    nav: The resolved navigation data.\n\nReturns:\n    A list of dictionary mappings representing the MkDocs navigation."
+            "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav: Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\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."
           }
         }
       },
@@ -106,7 +106,7 @@
         "kind": "module",
         "path": "docforge.nav.mkdocs",
         "signature": null,
-        "docstring": "This module provides the MkDocsNavEmitter, which converts a ResolvedNav instance\ninto the specific YAML-ready list structure expected by the MkDocs 'nav'\nconfiguration.",
+        "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.",
         "members": {
           "Path": {
             "name": "Path",
@@ -141,7 +141,7 @@
             "kind": "class",
             "path": "docforge.nav.mkdocs.ResolvedNav",
             "signature": "<bound method Alias.signature of Alias('ResolvedNav', 'docforge.nav.resolver.ResolvedNav')>",
-            "docstring": "Represents a navigation structure where all patterns and paths have been\nresolved against the actual filesystem contents.\n\nAttributes:\n    home: Resolved relative path to the home page.\n    groups: Mapping of group titles to lists of absolute or relative Path objects.",
+            "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",
@@ -162,7 +162,7 @@
                 "kind": "function",
                 "path": "docforge.nav.mkdocs.ResolvedNav.all_files",
                 "signature": "<bound method Alias.signature of Alias('all_files', 'docforge.nav.resolver.ResolvedNav.all_files')>",
-                "docstring": "Get an iterable of all resolved files in the navigation structure.\n\nReturns:\n    An iterable of Path objects."
+                "docstring": "Iterate over all files referenced by the navigation structure.\n\nReturns:\n    An iterable of ``Path`` objects representing documentation files.\n\nRaises:\n    RuntimeError: If the home page is defined but the documentation\n        root is not available for resolution."
               }
             }
           },
@@ -170,15 +170,15 @@
             "name": "MkDocsNavEmitter",
             "kind": "class",
             "path": "docforge.nav.mkdocs.MkDocsNavEmitter",
-            "signature": "<bound method Class.signature of Class('MkDocsNavEmitter', 13, 72)>",
-            "docstring": "Emitter responsible for transforming a ResolvedNav into an MkDocs-compatible\nnavigation structure.",
+            "signature": "<bound method Class.signature of Class('MkDocsNavEmitter', 15, 81)>",
+            "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": "<bound method Function.signature of Function('emit', 19, 44)>",
-                "docstring": "Generate a list of navigation entries for mkdocs.yml.\n\nArgs:\n    nav: The resolved navigation data.\n\nReturns:\n    A list of dictionary mappings representing the MkDocs navigation."
+                "signature": "<bound method Function.signature of Function('emit', 23, 51)>",
+                "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav: Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\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."
               }
             }
           }
@@ -189,7 +189,7 @@
         "kind": "module",
         "path": "docforge.nav.resolver",
         "signature": null,
-        "docstring": "This module contains the logic for resolving a NavSpec against the physical\nfilesystem. It expands globs and validates that all referenced documents\nactually exist on disk.",
+        "docstring": "Navigation resolution utilities.\n\nThis module resolves a ``NavSpec`` against the filesystem by expanding glob\npatterns and validating that referenced documentation files exist.",
         "members": {
           "Path": {
             "name": "Path",
@@ -231,7 +231,7 @@
             "kind": "class",
             "path": "docforge.nav.resolver.NavSpec",
             "signature": "<bound method Alias.signature of Alias('NavSpec', 'docforge.nav.spec.NavSpec')>",
-            "docstring": "Parsed representation of the docforge navigation specification file.\n\nAttributes:\n    home: Path to the home document (e.g., 'index.md').\n    groups: Mapping of group titles to lists of path patterns/globs.",
+            "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.",
             "members": {
               "home": {
                 "name": "home",
@@ -252,14 +252,14 @@
                 "kind": "function",
                 "path": "docforge.nav.resolver.NavSpec.load",
                 "signature": "<bound method Alias.signature of Alias('load', 'docforge.nav.spec.NavSpec.load')>",
-                "docstring": "Load a NavSpec from a YAML file.\n\nArgs:\n    path: The filesystem path to the YAML file.\n\nReturns:\n    A NavSpec instance.\n\nRaises:\n    FileNotFoundError: If the path does not exist.\n    ValueError: If the file content is not a valid NavSpec mapping."
+                "docstring": "Load a navigation specification from a YAML file.\n\nArgs:\n    path: Filesystem path to the navigation specification file.\n\nReturns:\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": "<bound method Alias.signature of Alias('all_patterns', 'docforge.nav.spec.NavSpec.all_patterns')>",
-                "docstring": "Get all path patterns referenced in the specification.\n\nReturns:\n    A list of all patterns (home plus all groups)."
+                "docstring": "Return all path patterns referenced by the specification.\n\nReturns:\n    A list containing the home document (if defined) and all\n    group pattern entries."
               }
             }
           },
@@ -267,8 +267,8 @@
             "name": "ResolvedNav",
             "kind": "class",
             "path": "docforge.nav.resolver.ResolvedNav",
-            "signature": "<bound method Class.signature of Class('ResolvedNav', 15, 56)>",
-            "docstring": "Represents a navigation structure where all patterns and paths have been\nresolved against the actual filesystem contents.\n\nAttributes:\n    home: Resolved relative path to the home page.\n    groups: Mapping of group titles to lists of absolute or relative Path objects.",
+            "signature": "<bound method Class.signature of Class('ResolvedNav', 16, 65)>",
+            "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",
@@ -288,8 +288,8 @@
                 "name": "all_files",
                 "kind": "function",
                 "path": "docforge.nav.resolver.ResolvedNav.all_files",
-                "signature": "<bound method Function.signature of Function('all_files', 43, 56)>",
-                "docstring": "Get an iterable of all resolved files in the navigation structure.\n\nReturns:\n    An iterable of Path objects."
+                "signature": "<bound method Function.signature of Function('all_files', 47, 65)>",
+                "docstring": "Iterate over all files referenced by the navigation structure.\n\nReturns:\n    An iterable of ``Path`` objects representing documentation files.\n\nRaises:\n    RuntimeError: If the home page is defined but the documentation\n        root is not available for resolution."
               }
             }
           },
@@ -297,8 +297,8 @@
             "name": "resolve_nav",
             "kind": "function",
             "path": "docforge.nav.resolver.resolve_nav",
-            "signature": "<bound method Function.signature of Function('resolve_nav', 59, 124)>",
-            "docstring": "Create a ResolvedNav by processing a NavSpec against the filesystem.\nThis expands globs and validates the existence of referenced files.\n\nArgs:\n    spec: The navigation specification to resolve.\n    docs_root: The root directory for documentation files.\n\nReturns:\n    A ResolvedNav instance.\n\nRaises:\n    FileNotFoundError: If a pattern doesn't match any files or the docs_root doesn't exist."
+            "signature": "<bound method Function.signature of Function('resolve_nav', 68, 136)>",
+            "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: Navigation specification describing documentation layout.\n    docs_root: Root directory containing documentation Markdown files.\n\nReturns:\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."
           },
           "Optional": {
             "name": "Optional",
@@ -314,7 +314,7 @@
         "kind": "module",
         "path": "docforge.nav.spec",
         "signature": null,
-        "docstring": "This module defines the NavSpec class, which represents the user's intent for\ndocumentation navigation as defined in a YAML specification (usually\ndocforge.nav.yml).",
+        "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``).",
         "members": {
           "Path": {
             "name": "Path",
@@ -355,8 +355,8 @@
             "name": "NavSpec",
             "kind": "class",
             "path": "docforge.nav.spec.NavSpec",
-            "signature": "<bound method Class.signature of Class('NavSpec', 13, 91)>",
-            "docstring": "Parsed representation of the docforge navigation specification file.\n\nAttributes:\n    home: Path to the home document (e.g., 'index.md').\n    groups: Mapping of group titles to lists of path patterns/globs.",
+            "signature": "<bound method Class.signature of Class('NavSpec', 15, 104)>",
+            "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.",
             "members": {
               "home": {
                 "name": "home",
@@ -376,15 +376,15 @@
                 "name": "load",
                 "kind": "function",
                 "path": "docforge.nav.spec.NavSpec.load",
-                "signature": "<bound method Function.signature of Function('load', 37, 77)>",
-                "docstring": "Load a NavSpec from a YAML file.\n\nArgs:\n    path: The filesystem path to the YAML file.\n\nReturns:\n    A NavSpec instance.\n\nRaises:\n    FileNotFoundError: If the path does not exist.\n    ValueError: If the file content is not a valid NavSpec mapping."
+                "signature": "<bound method Function.signature of Function('load', 45, 86)>",
+                "docstring": "Load a navigation specification from a YAML file.\n\nArgs:\n    path: Filesystem path to the navigation specification file.\n\nReturns:\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": "<bound method Function.signature of Function('all_patterns', 79, 91)>",
-                "docstring": "Get all path patterns referenced in the specification.\n\nReturns:\n    A list of all patterns (home plus all groups)."
+                "signature": "<bound method Function.signature of Function('all_patterns', 88, 104)>",
+                "docstring": "Return all path patterns referenced by the specification.\n\nReturns:\n    A list containing the home document (if defined) and all\n    group pattern entries."
               }
             }
           },
@@ -392,8 +392,8 @@
             "name": "load_nav_spec",
             "kind": "function",
             "path": "docforge.nav.spec.load_nav_spec",
-            "signature": "<bound method Function.signature of Function('load_nav_spec', 94, 114)>",
-            "docstring": "Utility function to load a NavSpec from a file.\n\nArgs:\n    path: Path to the navigation specification file.\n\nReturns:\n    A loaded NavSpec instance."
+            "signature": "<bound method Function.signature of Function('load_nav_spec', 107, 135)>",
+            "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 to the navigation specification file.\n\nReturns:\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."
           }
         }
       }

mcp_docs/modules/docforge.nav.mkdocs.json

@@ -2,7 +2,7 @@
   "module": "docforge.nav.mkdocs",
   "content": {
     "path": "docforge.nav.mkdocs",
-    "docstring": "This module provides the MkDocsNavEmitter, which converts a ResolvedNav instance\ninto the specific YAML-ready list structure expected by the MkDocs 'nav'\nconfiguration.",
+    "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.",
     "objects": {
       "Path": {
         "name": "Path",
@@ -37,7 +37,7 @@
         "kind": "class",
         "path": "docforge.nav.mkdocs.ResolvedNav",
         "signature": "<bound method Alias.signature of Alias('ResolvedNav', 'docforge.nav.resolver.ResolvedNav')>",
-        "docstring": "Represents a navigation structure where all patterns and paths have been\nresolved against the actual filesystem contents.\n\nAttributes:\n    home: Resolved relative path to the home page.\n    groups: Mapping of group titles to lists of absolute or relative Path objects.",
+        "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",
@@ -58,7 +58,7 @@
             "kind": "function",
             "path": "docforge.nav.mkdocs.ResolvedNav.all_files",
             "signature": "<bound method Alias.signature of Alias('all_files', 'docforge.nav.resolver.ResolvedNav.all_files')>",
-            "docstring": "Get an iterable of all resolved files in the navigation structure.\n\nReturns:\n    An iterable of Path objects."
+            "docstring": "Iterate over all files referenced by the navigation structure.\n\nReturns:\n    An iterable of ``Path`` objects representing documentation files.\n\nRaises:\n    RuntimeError: If the home page is defined but the documentation\n        root is not available for resolution."
           }
         }
       },
@@ -66,15 +66,15 @@
         "name": "MkDocsNavEmitter",
         "kind": "class",
         "path": "docforge.nav.mkdocs.MkDocsNavEmitter",
-        "signature": "<bound method Class.signature of Class('MkDocsNavEmitter', 13, 72)>",
-        "docstring": "Emitter responsible for transforming a ResolvedNav into an MkDocs-compatible\nnavigation structure.",
+        "signature": "<bound method Class.signature of Class('MkDocsNavEmitter', 15, 81)>",
+        "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": "<bound method Function.signature of Function('emit', 19, 44)>",
-            "docstring": "Generate a list of navigation entries for mkdocs.yml.\n\nArgs:\n    nav: The resolved navigation data.\n\nReturns:\n    A list of dictionary mappings representing the MkDocs navigation."
+            "signature": "<bound method Function.signature of Function('emit', 23, 51)>",
+            "docstring": "Generate a navigation structure for ``mkdocs.yml``.\n\nArgs:\n    nav: Resolved navigation data describing documentation groups\n        and their associated Markdown files.\n\nReturns:\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."
           }
         }
       }

mcp_docs/modules/docforge.nav.resolver.json

@@ -2,7 +2,7 @@
   "module": "docforge.nav.resolver",
   "content": {
     "path": "docforge.nav.resolver",
-    "docstring": "This module contains the logic for resolving a NavSpec against the physical\nfilesystem. It expands globs and validates that all referenced documents\nactually exist on disk.",
+    "docstring": "Navigation resolution utilities.\n\nThis module resolves a ``NavSpec`` against the filesystem by expanding glob\npatterns and validating that referenced documentation files exist.",
     "objects": {
       "Path": {
         "name": "Path",
@@ -44,7 +44,7 @@
         "kind": "class",
         "path": "docforge.nav.resolver.NavSpec",
         "signature": "<bound method Alias.signature of Alias('NavSpec', 'docforge.nav.spec.NavSpec')>",
-        "docstring": "Parsed representation of the docforge navigation specification file.\n\nAttributes:\n    home: Path to the home document (e.g., 'index.md').\n    groups: Mapping of group titles to lists of path patterns/globs.",
+        "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.",
         "members": {
           "home": {
             "name": "home",
@@ -65,14 +65,14 @@
             "kind": "function",
             "path": "docforge.nav.resolver.NavSpec.load",
             "signature": "<bound method Alias.signature of Alias('load', 'docforge.nav.spec.NavSpec.load')>",
-            "docstring": "Load a NavSpec from a YAML file.\n\nArgs:\n    path: The filesystem path to the YAML file.\n\nReturns:\n    A NavSpec instance.\n\nRaises:\n    FileNotFoundError: If the path does not exist.\n    ValueError: If the file content is not a valid NavSpec mapping."
+            "docstring": "Load a navigation specification from a YAML file.\n\nArgs:\n    path: Filesystem path to the navigation specification file.\n\nReturns:\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": "<bound method Alias.signature of Alias('all_patterns', 'docforge.nav.spec.NavSpec.all_patterns')>",
-            "docstring": "Get all path patterns referenced in the specification.\n\nReturns:\n    A list of all patterns (home plus all groups)."
+            "docstring": "Return all path patterns referenced by the specification.\n\nReturns:\n    A list containing the home document (if defined) and all\n    group pattern entries."
           }
         }
       },
@@ -80,8 +80,8 @@
         "name": "ResolvedNav",
         "kind": "class",
         "path": "docforge.nav.resolver.ResolvedNav",
-        "signature": "<bound method Class.signature of Class('ResolvedNav', 15, 56)>",
-        "docstring": "Represents a navigation structure where all patterns and paths have been\nresolved against the actual filesystem contents.\n\nAttributes:\n    home: Resolved relative path to the home page.\n    groups: Mapping of group titles to lists of absolute or relative Path objects.",
+        "signature": "<bound method Class.signature of Class('ResolvedNav', 16, 65)>",
+        "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",
@@ -101,8 +101,8 @@
             "name": "all_files",
             "kind": "function",
             "path": "docforge.nav.resolver.ResolvedNav.all_files",
-            "signature": "<bound method Function.signature of Function('all_files', 43, 56)>",
-            "docstring": "Get an iterable of all resolved files in the navigation structure.\n\nReturns:\n    An iterable of Path objects."
+            "signature": "<bound method Function.signature of Function('all_files', 47, 65)>",
+            "docstring": "Iterate over all files referenced by the navigation structure.\n\nReturns:\n    An iterable of ``Path`` objects representing documentation files.\n\nRaises:\n    RuntimeError: If the home page is defined but the documentation\n        root is not available for resolution."
           }
         }
       },
@@ -110,8 +110,8 @@
         "name": "resolve_nav",
         "kind": "function",
         "path": "docforge.nav.resolver.resolve_nav",
-        "signature": "<bound method Function.signature of Function('resolve_nav', 59, 124)>",
-        "docstring": "Create a ResolvedNav by processing a NavSpec against the filesystem.\nThis expands globs and validates the existence of referenced files.\n\nArgs:\n    spec: The navigation specification to resolve.\n    docs_root: The root directory for documentation files.\n\nReturns:\n    A ResolvedNav instance.\n\nRaises:\n    FileNotFoundError: If a pattern doesn't match any files or the docs_root doesn't exist."
+        "signature": "<bound method Function.signature of Function('resolve_nav', 68, 136)>",
+        "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: Navigation specification describing documentation layout.\n    docs_root: Root directory containing documentation Markdown files.\n\nReturns:\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."
       },
       "Optional": {
         "name": "Optional",

mcp_docs/modules/docforge.nav.spec.json

@@ -2,7 +2,7 @@
   "module": "docforge.nav.spec",
   "content": {
     "path": "docforge.nav.spec",
-    "docstring": "This module defines the NavSpec class, which represents the user's intent for\ndocumentation navigation as defined in a YAML specification (usually\ndocforge.nav.yml).",
+    "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``).",
     "objects": {
       "Path": {
         "name": "Path",
@@ -43,8 +43,8 @@
         "name": "NavSpec",
         "kind": "class",
         "path": "docforge.nav.spec.NavSpec",
-        "signature": "<bound method Class.signature of Class('NavSpec', 13, 91)>",
-        "docstring": "Parsed representation of the docforge navigation specification file.\n\nAttributes:\n    home: Path to the home document (e.g., 'index.md').\n    groups: Mapping of group titles to lists of path patterns/globs.",
+        "signature": "<bound method Class.signature of Class('NavSpec', 15, 104)>",
+        "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.",
         "members": {
           "home": {
             "name": "home",
@@ -64,15 +64,15 @@
             "name": "load",
             "kind": "function",
             "path": "docforge.nav.spec.NavSpec.load",
-            "signature": "<bound method Function.signature of Function('load', 37, 77)>",
-            "docstring": "Load a NavSpec from a YAML file.\n\nArgs:\n    path: The filesystem path to the YAML file.\n\nReturns:\n    A NavSpec instance.\n\nRaises:\n    FileNotFoundError: If the path does not exist.\n    ValueError: If the file content is not a valid NavSpec mapping."
+            "signature": "<bound method Function.signature of Function('load', 45, 86)>",
+            "docstring": "Load a navigation specification from a YAML file.\n\nArgs:\n    path: Filesystem path to the navigation specification file.\n\nReturns:\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": "<bound method Function.signature of Function('all_patterns', 79, 91)>",
-            "docstring": "Get all path patterns referenced in the specification.\n\nReturns:\n    A list of all patterns (home plus all groups)."
+            "signature": "<bound method Function.signature of Function('all_patterns', 88, 104)>",
+            "docstring": "Return all path patterns referenced by the specification.\n\nReturns:\n    A list containing the home document (if defined) and all\n    group pattern entries."
           }
         }
       },
@@ -80,8 +80,8 @@
         "name": "load_nav_spec",
         "kind": "function",
         "path": "docforge.nav.spec.load_nav_spec",
-        "signature": "<bound method Function.signature of Function('load_nav_spec', 94, 114)>",
-        "docstring": "Utility function to load a NavSpec from a file.\n\nArgs:\n    path: Path to the navigation specification file.\n\nReturns:\n    A loaded NavSpec instance."
+        "signature": "<bound method Function.signature of Function('load_nav_spec', 107, 135)>",
+        "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 to the navigation specification file.\n\nReturns:\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."
       }
     }
   }

mcp_docs/modules/docforge.renderers.base.json

@@ -2,7 +2,7 @@
   "module": "docforge.renderers.base",
   "content": {
     "path": "docforge.renderers.base",
-    "docstring": "This module defines the base interfaces and configuration containers for\ndoc-forge renderers. All renderer implementations should adhere to the\nDocRenderer protocol.",
+    "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.",
     "objects": {
       "Path": {
         "name": "Path",
@@ -23,7 +23,7 @@
         "kind": "class",
         "path": "docforge.renderers.base.Project",
         "signature": "<bound method Alias.signature of Alias('Project', 'docforge.models.Project')>",
-        "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+        "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",
@@ -44,28 +44,28 @@
             "kind": "function",
             "path": "docforge.renderers.base.Project.add_module",
             "signature": "<bound method Alias.signature of Alias('add_module', 'docforge.models.project.Project.add_module')>",
-            "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+            "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": "<bound method Alias.signature of Alias('get_module', 'docforge.models.project.Project.get_module')>",
-            "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested 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.renderers.base.Project.get_all_modules",
             "signature": "<bound method Alias.signature of Alias('get_all_modules', 'docforge.models.project.Project.get_all_modules')>",
-            "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+            "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": "<bound method Alias.signature of Alias('get_module_list', 'docforge.models.project.Project.get_module_list')>",
-            "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+            "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."
           }
         }
       },
@@ -73,8 +73,8 @@
         "name": "RendererConfig",
         "kind": "class",
         "path": "docforge.renderers.base.RendererConfig",
-        "signature": "<bound method Class.signature of Class('RendererConfig', 13, 24)>",
-        "docstring": "Configuration container for documentation renderers.\n\nArgs:\n    out_dir: The directory where documentation files should be written.\n    project: The introspected project models to be rendered.",
+        "signature": "<bound method Class.signature of Class('RendererConfig', 17, 44)>",
+        "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",
@@ -96,8 +96,8 @@
         "name": "DocRenderer",
         "kind": "class",
         "path": "docforge.renderers.base.DocRenderer",
-        "signature": "<bound method Class.signature of Class('DocRenderer', 27, 46)>",
-        "docstring": "Protocol defining the interface for documentation renderers.",
+        "signature": "<bound method Class.signature of Class('DocRenderer', 47, 72)>",
+        "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",
@@ -110,8 +110,8 @@
             "name": "generate_sources",
             "kind": "function",
             "path": "docforge.renderers.base.DocRenderer.generate_sources",
-            "signature": "<bound method Function.signature of Function('generate_sources', 34, 46)>",
-            "docstring": "Generate renderer-specific source files for the given project.\n\nArgs:\n    project: The project models containing modules and objects.\n    out_dir: Target directory for the generated files."
+            "signature": "<bound method Function.signature of Function('generate_sources', 57, 72)>",
+            "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_docs/modules/docforge.renderers.json

@@ -2,14 +2,14 @@
   "module": "docforge.renderers",
   "content": {
     "path": "docforge.renderers",
-    "docstring": "# Renderers Layer\n\nThe `docforge.renderers` package handles the transformation of the internal\ndocumentation models into physical files formatted for specific documentation\nengines.\n\n## Current Implementations\n\n- **MkDocsRenderer**: Generates Markdown files utilizing the `mkdocstrings`\n  syntax. It automatically handles package/module hierarchy and generates\n  `index.md` files for packages.\n\n## Extending\n\nTo add a new renderer, implement the `DocRenderer` protocol defined in\n`docforge.renderers.base`.",
+    "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---",
     "objects": {
       "MkDocsRenderer": {
         "name": "MkDocsRenderer",
         "kind": "class",
         "path": "docforge.renderers.MkDocsRenderer",
         "signature": "<bound method Alias.signature of Alias('MkDocsRenderer', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer')>",
-        "docstring": "Renderer that generates Markdown source files formatted for the MkDocs\n'mkdocstrings' plugin.",
+        "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",
@@ -23,7 +23,14 @@
             "kind": "function",
             "path": "docforge.renderers.MkDocsRenderer.generate_sources",
             "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_sources')>",
-            "docstring": "Produce a set of Markdown files in the output directory based on the\nprovided Project models.\n\nArgs:\n    project: The project models to render.\n    out_dir: Target directory for documentation files."
+            "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, optional):\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": "<bound method Alias.signature of Alias('generate_readme', 'docforge.renderers.mkdocs_renderer.MkDocsRenderer.generate_readme')>",
+            "docstring": "Generate a `README.md` file from the root module docstring.\n\nBehavior:\n\n- If `module_is_source` is True, `README.md` is written to the project\n  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, optional):\n        Whether the module is treated as the project source root."
           }
         }
       },
@@ -32,7 +39,7 @@
         "kind": "class",
         "path": "docforge.renderers.MCPRenderer",
         "signature": "<bound method Alias.signature of Alias('MCPRenderer', 'docforge.renderers.mcp_renderer.MCPRenderer')>",
-        "docstring": "Renderer that emits MCP-native JSON resources from docforge models.",
+        "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",
@@ -46,7 +53,7 @@
             "kind": "function",
             "path": "docforge.renderers.MCPRenderer.generate_sources",
             "signature": "<bound method Alias.signature of Alias('generate_sources', 'docforge.renderers.mcp_renderer.MCPRenderer.generate_sources')>",
-            "docstring": "Generate MCP-compatible JSON resources and navigation for the project."
+            "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."
           }
         }
       },
@@ -55,7 +62,7 @@
         "kind": "module",
         "path": "docforge.renderers.base",
         "signature": null,
-        "docstring": "This module defines the base interfaces and configuration containers for\ndoc-forge renderers. All renderer implementations should adhere to the\nDocRenderer protocol.",
+        "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": {
           "Path": {
             "name": "Path",
@@ -76,7 +83,7 @@
             "kind": "class",
             "path": "docforge.renderers.base.Project",
             "signature": "<bound method Alias.signature of Alias('Project', 'docforge.models.Project')>",
-            "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+            "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",
@@ -97,28 +104,28 @@
                 "kind": "function",
                 "path": "docforge.renderers.base.Project.add_module",
                 "signature": "<bound method Alias.signature of Alias('add_module', 'docforge.models.project.Project.add_module')>",
-                "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+                "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": "<bound method Alias.signature of Alias('get_module', 'docforge.models.project.Project.get_module')>",
-                "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested 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.renderers.base.Project.get_all_modules",
                 "signature": "<bound method Alias.signature of Alias('get_all_modules', 'docforge.models.project.Project.get_all_modules')>",
-                "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+                "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": "<bound method Alias.signature of Alias('get_module_list', 'docforge.models.project.Project.get_module_list')>",
-                "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+                "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."
               }
             }
           },
@@ -126,8 +133,8 @@
             "name": "RendererConfig",
             "kind": "class",
             "path": "docforge.renderers.base.RendererConfig",
-            "signature": "<bound method Class.signature of Class('RendererConfig', 13, 24)>",
-            "docstring": "Configuration container for documentation renderers.\n\nArgs:\n    out_dir: The directory where documentation files should be written.\n    project: The introspected project models to be rendered.",
+            "signature": "<bound method Class.signature of Class('RendererConfig', 17, 44)>",
+            "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",
@@ -149,8 +156,8 @@
             "name": "DocRenderer",
             "kind": "class",
             "path": "docforge.renderers.base.DocRenderer",
-            "signature": "<bound method Class.signature of Class('DocRenderer', 27, 46)>",
-            "docstring": "Protocol defining the interface for documentation renderers.",
+            "signature": "<bound method Class.signature of Class('DocRenderer', 47, 72)>",
+            "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",
@@ -163,8 +170,8 @@
                 "name": "generate_sources",
                 "kind": "function",
                 "path": "docforge.renderers.base.DocRenderer.generate_sources",
-                "signature": "<bound method Function.signature of Function('generate_sources', 34, 46)>",
-                "docstring": "Generate renderer-specific source files for the given project.\n\nArgs:\n    project: The project models containing modules and objects.\n    out_dir: Target directory for the generated files."
+                "signature": "<bound method Function.signature of Function('generate_sources', 57, 72)>",
+                "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."
               }
             }
           }
@@ -175,7 +182,7 @@
         "kind": "module",
         "path": "docforge.renderers.mcp_renderer",
         "signature": null,
-        "docstring": 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": {
           "json": {
             "name": "json",
@@ -210,7 +217,7 @@
             "kind": "class",
             "path": "docforge.renderers.mcp_renderer.Project",
             "signature": "<bound method Alias.signature of Alias('Project', 'docforge.models.Project')>",
-            "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+            "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",
@@ -231,28 +238,28 @@
                 "kind": "function",
                 "path": "docforge.renderers.mcp_renderer.Project.add_module",
                 "signature": "<bound method Alias.signature of Alias('add_module', 'docforge.models.project.Project.add_module')>",
-                "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+                "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": "<bound method Alias.signature of Alias('get_module', 'docforge.models.project.Project.get_module')>",
-                "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested 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.renderers.mcp_renderer.Project.get_all_modules",
                 "signature": "<bound method Alias.signature of Alias('get_all_modules', 'docforge.models.project.Project.get_all_modules')>",
-                "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+                "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": "<bound method Alias.signature of Alias('get_module_list', 'docforge.models.project.Project.get_module_list')>",
-                "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+                "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."
               }
             }
           },
@@ -261,7 +268,7 @@
             "kind": "class",
             "path": "docforge.renderers.mcp_renderer.Module",
             "signature": "<bound method Alias.signature of Alias('Module', 'docforge.models.Module')>",
-            "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+            "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 (Optional[str]):\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",
@@ -289,21 +296,21 @@
                 "kind": "function",
                 "path": "docforge.renderers.mcp_renderer.Module.add_object",
                 "signature": "<bound method Alias.signature of Alias('add_object', 'docforge.models.module.Module.add_object')>",
-                "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+                "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": "<bound method Alias.signature of Alias('get_object', 'docforge.models.module.Module.get_object')>",
-                "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested 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.renderers.mcp_renderer.Module.get_all_objects",
                 "signature": "<bound method Alias.signature of Alias('get_all_objects', 'docforge.models.module.Module.get_all_objects')>",
-                "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+                "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."
               }
             }
           },
@@ -312,7 +319,7 @@
             "kind": "class",
             "path": "docforge.renderers.mcp_renderer.DocObject",
             "signature": "<bound method Alias.signature of Alias('DocObject', 'docforge.models.DocObject')>",
-            "docstring": "Represents a documented Python object (class, function, method, etc.).\n\nAttributes:\n    name: Local name of the object.\n    kind: Type of object (e.g., 'class', 'function', 'attribute').\n    path: Full dotted import path to the object.\n    signature: Callable signature, if applicable.\n    docstring: Raw docstring content extracted from the source.\n    members: Dictionary mapping member names to their DocObject representations.",
+            "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 (Optional[str]):\n        Callable signature if the object represents a callable.\n\n    docstring (Optional[str]):\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",
@@ -361,21 +368,21 @@
                 "kind": "function",
                 "path": "docforge.renderers.mcp_renderer.DocObject.add_member",
                 "signature": "<bound method Alias.signature of Alias('add_member', 'docforge.models.object.DocObject.add_member')>",
-                "docstring": "Add a child member to this object (e.g., a method to a class).\n\nArgs:\n    obj: The child DocObject to add."
+                "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: Documentation object to add as a member."
               },
               "get_member": {
                 "name": "get_member",
                 "kind": "function",
                 "path": "docforge.renderers.mcp_renderer.DocObject.get_member",
                 "signature": "<bound method Alias.signature of Alias('get_member', 'docforge.models.object.DocObject.get_member')>",
-                "docstring": "Retrieve a child member by name.\n\nArgs:\n    name: The name of the member.\n\nReturns:\n    The requested 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.renderers.mcp_renderer.DocObject.get_all_members",
                 "signature": "<bound method Alias.signature of Alias('get_all_members', 'docforge.models.object.DocObject.get_all_members')>",
-                "docstring": "Get all members of this object.\n\nReturns:\n    An iterable of child DocObject instances."
+                "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
               }
             }
           },
@@ -383,8 +390,8 @@
             "name": "MCPRenderer",
             "kind": "class",
             "path": "docforge.renderers.mcp_renderer.MCPRenderer",
-            "signature": "<bound method Class.signature of Class('MCPRenderer', 8, 102)>",
-            "docstring": "Renderer that emits MCP-native JSON resources from docforge models.",
+            "signature": "<bound method Class.signature of Class('MCPRenderer', 17, 159)>",
+            "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",
@@ -397,8 +404,8 @@
                 "name": "generate_sources",
                 "kind": "function",
                 "path": "docforge.renderers.mcp_renderer.MCPRenderer.generate_sources",
-                "signature": "<bound method Function.signature of Function('generate_sources', 15, 49)>",
-                "docstring": "Generate MCP-compatible JSON resources and navigation for the project."
+                "signature": "<bound method Function.signature of Function('generate_sources', 28, 72)>",
+                "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."
               }
             }
           }
@@ -409,7 +416,7 @@
         "kind": "module",
         "path": "docforge.renderers.mkdocs_renderer",
         "signature": null,
-        "docstring": "This module implements the MkDocsRenderer, which generates Markdown source files\ncompatible with the MkDocs 'material' theme and 'mkdocstrings' extension.",
+        "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": {
           "Path": {
             "name": "Path",
@@ -423,7 +430,7 @@
             "kind": "class",
             "path": "docforge.renderers.mkdocs_renderer.Project",
             "signature": "<bound method Alias.signature of Alias('Project', 'docforge.models.Project')>",
-            "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+            "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",
@@ -444,67 +451,37 @@
                 "kind": "function",
                 "path": "docforge.renderers.mkdocs_renderer.Project.add_module",
                 "signature": "<bound method Alias.signature of Alias('add_module', 'docforge.models.project.Project.add_module')>",
-                "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+                "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": "<bound method Alias.signature of Alias('get_module', 'docforge.models.project.Project.get_module')>",
-                "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested 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.renderers.mkdocs_renderer.Project.get_all_modules",
                 "signature": "<bound method Alias.signature of Alias('get_all_modules', 'docforge.models.project.Project.get_all_modules')>",
-                "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+                "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": "<bound method Alias.signature of Alias('get_module_list', 'docforge.models.project.Project.get_module_list')>",
-                "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+                "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": "<bound method Class.signature of Class('MkDocsRenderer', 11, 91)>",
-            "docstring": "Renderer that generates Markdown source files formatted for the MkDocs\n'mkdocstrings' plugin.",
-            "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": "<bound method Function.signature of Function('generate_sources', 19, 38)>",
-                "docstring": "Produce a set of Markdown files in the output directory based on the\nprovided Project models.\n\nArgs:\n    project: The project models to render.\n    out_dir: Target directory for documentation files."
-              }
-            }
-          },
-          "Set": {
-            "name": "Set",
-            "kind": "alias",
-            "path": "docforge.renderers.mkdocs_renderer.Set",
-            "signature": "<bound method Alias.signature of Alias('Set', 'typing.Set')>",
-            "docstring": null
-          },
           "Module": {
             "name": "Module",
             "kind": "class",
             "path": "docforge.renderers.mkdocs_renderer.Module",
             "signature": "<bound method Alias.signature of Alias('Module', 'docforge.models.Module')>",
-            "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+            "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 (Optional[str]):\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",
@@ -532,21 +509,51 @@
                 "kind": "function",
                 "path": "docforge.renderers.mkdocs_renderer.Module.add_object",
                 "signature": "<bound method Alias.signature of Alias('add_object', 'docforge.models.module.Module.add_object')>",
-                "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+                "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": "<bound method Alias.signature of Alias('get_object', 'docforge.models.module.Module.get_object')>",
-                "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested 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.renderers.mkdocs_renderer.Module.get_all_objects",
                 "signature": "<bound method Alias.signature of Alias('get_all_objects', 'docforge.models.module.Module.get_all_objects')>",
-                "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+                "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."
+              }
+            }
+          },
+          "MkDocsRenderer": {
+            "name": "MkDocsRenderer",
+            "kind": "class",
+            "path": "docforge.renderers.mkdocs_renderer.MkDocsRenderer",
+            "signature": "<bound method Class.signature of Class('MkDocsRenderer', 22, 305)>",
+            "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": "<bound method Function.signature of Function('generate_sources', 36, 78)>",
+                "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, optional):\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": "<bound method Function.signature of Function('generate_readme', 80, 139)>",
+                "docstring": "Generate a `README.md` file from the root module docstring.\n\nBehavior:\n\n- If `module_is_source` is True, `README.md` is written to the project\n  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, optional):\n        Whether the module is treated as the project source root."
               }
             }
           }

mcp_docs/modules/docforge.renderers.mcp_renderer.json

@@ -2,7 +2,7 @@
   "module": "docforge.renderers.mcp_renderer",
   "content": {
     "path": "docforge.renderers.mcp_renderer",
-    "docstring": 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).",
     "objects": {
       "json": {
         "name": "json",
@@ -37,7 +37,7 @@
         "kind": "class",
         "path": "docforge.renderers.mcp_renderer.Project",
         "signature": "<bound method Alias.signature of Alias('Project', 'docforge.models.Project')>",
-        "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+        "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",
@@ -58,28 +58,28 @@
             "kind": "function",
             "path": "docforge.renderers.mcp_renderer.Project.add_module",
             "signature": "<bound method Alias.signature of Alias('add_module', 'docforge.models.project.Project.add_module')>",
-            "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+            "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": "<bound method Alias.signature of Alias('get_module', 'docforge.models.project.Project.get_module')>",
-            "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested 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.renderers.mcp_renderer.Project.get_all_modules",
             "signature": "<bound method Alias.signature of Alias('get_all_modules', 'docforge.models.project.Project.get_all_modules')>",
-            "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+            "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": "<bound method Alias.signature of Alias('get_module_list', 'docforge.models.project.Project.get_module_list')>",
-            "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+            "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."
           }
         }
       },
@@ -88,7 +88,7 @@
         "kind": "class",
         "path": "docforge.renderers.mcp_renderer.Module",
         "signature": "<bound method Alias.signature of Alias('Module', 'docforge.models.Module')>",
-        "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+        "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 (Optional[str]):\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",
@@ -116,21 +116,21 @@
             "kind": "function",
             "path": "docforge.renderers.mcp_renderer.Module.add_object",
             "signature": "<bound method Alias.signature of Alias('add_object', 'docforge.models.module.Module.add_object')>",
-            "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+            "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": "<bound method Alias.signature of Alias('get_object', 'docforge.models.module.Module.get_object')>",
-            "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested 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.renderers.mcp_renderer.Module.get_all_objects",
             "signature": "<bound method Alias.signature of Alias('get_all_objects', 'docforge.models.module.Module.get_all_objects')>",
-            "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+            "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."
           }
         }
       },
@@ -139,7 +139,7 @@
         "kind": "class",
         "path": "docforge.renderers.mcp_renderer.DocObject",
         "signature": "<bound method Alias.signature of Alias('DocObject', 'docforge.models.DocObject')>",
-        "docstring": "Represents a documented Python object (class, function, method, etc.).\n\nAttributes:\n    name: Local name of the object.\n    kind: Type of object (e.g., 'class', 'function', 'attribute').\n    path: Full dotted import path to the object.\n    signature: Callable signature, if applicable.\n    docstring: Raw docstring content extracted from the source.\n    members: Dictionary mapping member names to their DocObject representations.",
+        "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 (Optional[str]):\n        Callable signature if the object represents a callable.\n\n    docstring (Optional[str]):\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",
@@ -188,21 +188,21 @@
             "kind": "function",
             "path": "docforge.renderers.mcp_renderer.DocObject.add_member",
             "signature": "<bound method Alias.signature of Alias('add_member', 'docforge.models.object.DocObject.add_member')>",
-            "docstring": "Add a child member to this object (e.g., a method to a class).\n\nArgs:\n    obj: The child DocObject to add."
+            "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: Documentation object to add as a member."
           },
           "get_member": {
             "name": "get_member",
             "kind": "function",
             "path": "docforge.renderers.mcp_renderer.DocObject.get_member",
             "signature": "<bound method Alias.signature of Alias('get_member', 'docforge.models.object.DocObject.get_member')>",
-            "docstring": "Retrieve a child member by name.\n\nArgs:\n    name: The name of the member.\n\nReturns:\n    The requested 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.renderers.mcp_renderer.DocObject.get_all_members",
             "signature": "<bound method Alias.signature of Alias('get_all_members', 'docforge.models.object.DocObject.get_all_members')>",
-            "docstring": "Get all members of this object.\n\nReturns:\n    An iterable of child DocObject instances."
+            "docstring": "Return all child members of the object.\n\nReturns:\n    Iterable[DocObject]:\n        An iterable of `DocObject` instances representing nested members."
           }
         }
       },
@@ -210,8 +210,8 @@
         "name": "MCPRenderer",
         "kind": "class",
         "path": "docforge.renderers.mcp_renderer.MCPRenderer",
-        "signature": "<bound method Class.signature of Class('MCPRenderer', 8, 102)>",
-        "docstring": "Renderer that emits MCP-native JSON resources from docforge models.",
+        "signature": "<bound method Class.signature of Class('MCPRenderer', 17, 159)>",
+        "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",
@@ -224,8 +224,8 @@
             "name": "generate_sources",
             "kind": "function",
             "path": "docforge.renderers.mcp_renderer.MCPRenderer.generate_sources",
-            "signature": "<bound method Function.signature of Function('generate_sources', 15, 49)>",
-            "docstring": "Generate MCP-compatible JSON resources and navigation for the project."
+            "signature": "<bound method Function.signature of Function('generate_sources', 28, 72)>",
+            "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."
           }
         }
       }

mcp_docs/modules/docforge.renderers.mkdocs_renderer.json

@@ -2,7 +2,7 @@
   "module": "docforge.renderers.mkdocs_renderer",
   "content": {
     "path": "docforge.renderers.mkdocs_renderer",
-    "docstring": "This module implements the MkDocsRenderer, which generates Markdown source files\ncompatible with the MkDocs 'material' theme and 'mkdocstrings' extension.",
+    "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",
     "objects": {
       "Path": {
         "name": "Path",
@@ -16,7 +16,7 @@
         "kind": "class",
         "path": "docforge.renderers.mkdocs_renderer.Project",
         "signature": "<bound method Alias.signature of Alias('Project', 'docforge.models.Project')>",
-        "docstring": "Represents a documentation project, serving as a container for modules.\n\nAttributes:\n    name: Name of the project.\n    modules: Dictionary mapping module paths to Module instances.",
+        "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",
@@ -37,67 +37,37 @@
             "kind": "function",
             "path": "docforge.renderers.mkdocs_renderer.Project.add_module",
             "signature": "<bound method Alias.signature of Alias('add_module', 'docforge.models.project.Project.add_module')>",
-            "docstring": "Add a module to the project.\n\nArgs:\n    module: The module to add."
+            "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": "<bound method Alias.signature of Alias('get_module', 'docforge.models.project.Project.get_module')>",
-            "docstring": "Retrieve a module by its dotted path.\n\nArgs:\n    path: The dotted path of the module (e.g., 'pkg.mod').\n\nReturns:\n    The requested 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.renderers.mkdocs_renderer.Project.get_all_modules",
             "signature": "<bound method Alias.signature of Alias('get_all_modules', 'docforge.models.project.Project.get_all_modules')>",
-            "docstring": "Get all modules in the project.\n\nReturns:\n    An iterable of Module objects."
+            "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": "<bound method Alias.signature of Alias('get_module_list', 'docforge.models.project.Project.get_module_list')>",
-            "docstring": "Get the list of all module dotted paths.\n\nReturns:\n    A list of module paths."
+            "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": "<bound method Class.signature of Class('MkDocsRenderer', 11, 91)>",
-        "docstring": "Renderer that generates Markdown source files formatted for the MkDocs\n'mkdocstrings' plugin.",
-        "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": "<bound method Function.signature of Function('generate_sources', 19, 38)>",
-            "docstring": "Produce a set of Markdown files in the output directory based on the\nprovided Project models.\n\nArgs:\n    project: The project models to render.\n    out_dir: Target directory for documentation files."
-          }
-        }
-      },
-      "Set": {
-        "name": "Set",
-        "kind": "alias",
-        "path": "docforge.renderers.mkdocs_renderer.Set",
-        "signature": "<bound method Alias.signature of Alias('Set', 'typing.Set')>",
-        "docstring": null
-      },
       "Module": {
         "name": "Module",
         "kind": "class",
         "path": "docforge.renderers.mkdocs_renderer.Module",
         "signature": "<bound method Alias.signature of Alias('Module', 'docforge.models.Module')>",
-        "docstring": "Represents a documented Python module or package.\n\nAttributes:\n    path: Dotted import path of the module.\n    docstring: Module-level docstring content.\n    members: Dictionary mapping object names to their DocObject representations.",
+        "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 (Optional[str]):\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",
@@ -125,21 +95,51 @@
             "kind": "function",
             "path": "docforge.renderers.mkdocs_renderer.Module.add_object",
             "signature": "<bound method Alias.signature of Alias('add_object', 'docforge.models.module.Module.add_object')>",
-            "docstring": "Add a documented object to the module.\n\nArgs:\n    obj: The object to add."
+            "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": "<bound method Alias.signature of Alias('get_object', 'docforge.models.module.Module.get_object')>",
-            "docstring": "Retrieve a member object by name.\n\nArgs:\n    name: The name of the object.\n\nReturns:\n    The requested 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.renderers.mkdocs_renderer.Module.get_all_objects",
             "signature": "<bound method Alias.signature of Alias('get_all_objects', 'docforge.models.module.Module.get_all_objects')>",
-            "docstring": "Get all top-level objects in the module.\n\nReturns:\n    An iterable of DocObject instances."
+            "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."
+          }
+        }
+      },
+      "MkDocsRenderer": {
+        "name": "MkDocsRenderer",
+        "kind": "class",
+        "path": "docforge.renderers.mkdocs_renderer.MkDocsRenderer",
+        "signature": "<bound method Class.signature of Class('MkDocsRenderer', 22, 305)>",
+        "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": "<bound method Function.signature of Function('generate_sources', 36, 78)>",
+            "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, optional):\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": "<bound method Function.signature of Function('generate_readme', 80, 139)>",
+            "docstring": "Generate a `README.md` file from the root module docstring.\n\nBehavior:\n\n- If `module_is_source` is True, `README.md` is written to the project\n  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, optional):\n        Whether the module is treated as the project source root."
           }
         }
       }

mcp_docs/modules/docforge.servers.json

@@ -2,14 +2,14 @@
   "module": "docforge.servers",
   "content": {
     "path": "docforge.servers",
-    "docstring": 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---",
     "objects": {
       "MCPServer": {
         "name": "MCPServer",
         "kind": "class",
         "path": "docforge.servers.MCPServer",
         "signature": "<bound method Alias.signature of Alias('MCPServer', 'docforge.servers.mcp_server.MCPServer')>",
-        "docstring": "MCP server for serving a pre-built MCP documentation bundle.",
+        "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.",
         "members": {
           "mcp_root": {
             "name": "mcp_root",
@@ -30,7 +30,7 @@
             "kind": "function",
             "path": "docforge.servers.MCPServer.run",
             "signature": "<bound method Alias.signature of Alias('run', 'docforge.servers.mcp_server.MCPServer.run')>",
-            "docstring": "Start the MCP server.\n\nArgs:\n    transport: MCP transport (default: 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`."
           }
         }
       },
@@ -39,7 +39,7 @@
         "kind": "module",
         "path": "docforge.servers.mcp_server",
         "signature": null,
-        "docstring": 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).",
         "members": {
           "annotations": {
             "name": "annotations",
@@ -87,8 +87,8 @@
             "name": "MCPServer",
             "kind": "class",
             "path": "docforge.servers.mcp_server.MCPServer",
-            "signature": "<bound method Class.signature of Class('MCPServer', 10, 95)>",
-            "docstring": "MCP server for serving a pre-built MCP documentation bundle.",
+            "signature": "<bound method Class.signature of Class('MCPServer', 19, 136)>",
+            "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.",
             "members": {
               "mcp_root": {
                 "name": "mcp_root",
@@ -108,8 +108,8 @@
                 "name": "run",
                 "kind": "function",
                 "path": "docforge.servers.mcp_server.MCPServer.run",
-                "signature": "<bound method Function.signature of Function('run', 88, 95)>",
-                "docstring": "Start the MCP server.\n\nArgs:\n    transport: MCP transport (default: streamable-http)"
+                "signature": "<bound method Function.signature of Function('run', 124, 136)>",
+                "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_docs/modules/docforge.servers.mcp_server.json

@@ -2,7 +2,7 @@
   "module": "docforge.servers.mcp_server",
   "content": {
     "path": "docforge.servers.mcp_server",
-    "docstring": 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).",
     "objects": {
       "annotations": {
         "name": "annotations",
@@ -50,8 +50,8 @@
         "name": "MCPServer",
         "kind": "class",
         "path": "docforge.servers.mcp_server.MCPServer",
-        "signature": "<bound method Class.signature of Class('MCPServer', 10, 95)>",
-        "docstring": "MCP server for serving a pre-built MCP documentation bundle.",
+        "signature": "<bound method Class.signature of Class('MCPServer', 19, 136)>",
+        "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.",
         "members": {
           "mcp_root": {
             "name": "mcp_root",
@@ -71,8 +71,8 @@
             "name": "run",
             "kind": "function",
             "path": "docforge.servers.mcp_server.MCPServer.run",
-            "signature": "<bound method Function.signature of Function('run', 88, 95)>",
-            "docstring": "Start the MCP server.\n\nArgs:\n    transport: MCP transport (default: streamable-http)"
+            "signature": "<bound method Function.signature of Function('run', 124, 136)>",
+            "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_docs/nav.json

@@ -7,13 +7,21 @@
     "module": "docforge.cli",
     "resource": "doc://modules/docforge.cli"
   },
+  {
+    "module": "docforge.cli.commands",
+    "resource": "doc://modules/docforge.cli.commands"
+  },
   {
     "module": "docforge.cli.main",
     "resource": "doc://modules/docforge.cli.main"
   },
   {
-    "module": "docforge.cli.mkdocs",
-    "resource": "doc://modules/docforge.cli.mkdocs"
+    "module": "docforge.cli.mcp_utils",
+    "resource": "doc://modules/docforge.cli.mcp_utils"
+  },
+  {
+    "module": "docforge.cli.mkdocs_utils",
+    "resource": "doc://modules/docforge.cli.mkdocs_utils"
   },
   {
     "module": "docforge.loaders",

mkdocs.yml

@@ -1,5 +1,3 @@
-site_name: DocForge
-
 theme:
   name: material
   palette:
@@ -10,12 +8,19 @@ theme:
     text: Inter
     code: JetBrains Mono
   features:
-  - navigation.tabs
+  - navigation.sections
   - navigation.expand
   - navigation.top
   - navigation.instant
+  - navigation.tracking
+  - navigation.indexes
   - content.code.copy
   - content.code.annotate
+  - content.tabs.link
+  - content.action.edit
+  - search.highlight
+  - search.share
+  - search.suggest
 plugins:
 - search
 - mkdocstrings:
@@ -33,28 +38,54 @@ plugins:
           annotations_path: brief
           show_root_heading: true
           group_by_category: true
-
+          show_category_heading: true
+          show_object_full_path: false
+          show_symbol_type_heading: true
+markdown_extensions:
+- pymdownx.superfences
+- pymdownx.inlinehilite
+- pymdownx.snippets
+- admonition
+- pymdownx.details
+- pymdownx.superfences
+- pymdownx.highlight:
+    linenums: true
+    anchor_linenums: true
+    line_spans: __span
+    pygments_lang_class: true
+- pymdownx.tabbed:
+    alternate_style: true
+- pymdownx.tasklist:
+    custom_checkbox: true
+- tables
+- footnotes
+- pymdownx.caret
+- pymdownx.tilde
+- pymdownx.mark
+site_name: docforge
 nav:
-- Home: docforge/index.md
+- Home: index.md
 - Loaders:
-  - docforge/loaders/index.md
-  - docforge/loaders/griffe_loader.md
+  - loaders/index.md
+  - loaders/griffe_loader.md
 - Models:
-  - docforge/models/index.md
-  - docforge/models/module.md
-  - docforge/models/object.md
-  - docforge/models/project.md
+  - models/index.md
+  - models/module.md
+  - models/object.md
+  - models/project.md
 - Navigation:
-  - docforge/nav/index.md
-  - docforge/nav/spec.md
-  - docforge/nav/resolver.md
-  - docforge/nav/mkdocs.md
+  - nav/index.md
+  - nav/spec.md
+  - nav/resolver.md
+  - nav/mkdocs.md
 - Renderers:
-  - docforge/renderers/index.md
-  - docforge/renderers/base.md
-  - docforge/renderers/mkdocs_renderer.md
-  - docforge/renderers/mcp_renderer.md
+  - renderers/index.md
+  - renderers/base.md
+  - renderers/mkdocs_renderer.md
+  - renderers/mcp_renderer.md
 - CLI:
-  - docforge/cli/index.md
-  - docforge/cli/main.md
-  - docforge/cli/mkdocs.md
+  - cli/index.md
+  - cli/main.md
+  - cli/commands.md
+  - cli/mcp_utils.md
+  - cli/mkdocs_utils.md

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "doc-forge"
-version = "0.0.2"
+version = "0.0.6"
 description = "A renderer-agnostic Python documentation compiler"
 readme = "README.md"
 requires-python = ">=3.10"

tests/cli/conftest.py

@@ -1,111 +0,0 @@
-import json
-import pytest
-from pathlib import Path
-
-from click.testing import CliRunner
-
-
-@pytest.fixture
-def cli_runner() -> CliRunner:
-    """Click CLI runner."""
-    return CliRunner()
-
-
-@pytest.fixture
-def fake_mkdocs_yml(tmp_path: Path) -> Path:
-    """Create a minimal mkdocs.yml file."""
-    yml = tmp_path / "mkdocs.yml"
-    yml.write_text(
-        """
-site_name: Test Docs
-nav: []
-plugins:
-  - mkdocstrings
-""",
-        encoding="utf-8",
-    )
-    return yml
-
-
-@pytest.fixture
-def mock_mkdocs_load_config(monkeypatch):
-    """Mock mkdocs.config.load_config."""
-    def fake_load_config(path):
-        return object()  # dummy config object
-
-    monkeypatch.setattr(
-        "mkdocs.config.load_config",
-        fake_load_config,
-    )
-
-
-@pytest.fixture
-def mock_mkdocs_build(monkeypatch):
-    called = {"value": False}
-
-    def fake_build(config):
-        called["value"] = True
-
-    monkeypatch.setattr(
-        "mkdocs.commands.build.build",
-        fake_build,
-    )
-    return lambda: called["value"]
-
-
-@pytest.fixture
-def mock_mkdocs_serve(monkeypatch):
-    called = {"value": False}
-
-    def fake_serve(*args, **kwargs):
-        called["value"] = True
-
-    monkeypatch.setattr(
-        "mkdocs.commands.serve.serve",
-        fake_serve,
-    )
-    return lambda: called["value"]
-
-@pytest.fixture
-def fake_mcp_docs(tmp_path: Path) -> Path:
-    """
-    Create a minimal valid MCP bundle in mcp_docs/.
-    """
-    mcp_root = tmp_path / "mcp_docs"
-    modules_dir = mcp_root / "modules"
-    modules_dir.mkdir(parents=True)
-
-    (mcp_root / "index.json").write_text(
-        json.dumps({"project": "test", "type": "docforge-model"}),
-        encoding="utf-8",
-    )
-
-    (mcp_root / "nav.json").write_text(
-        json.dumps([]),
-        encoding="utf-8",
-    )
-
-    (modules_dir / "test.mod.json").write_text(
-        json.dumps({"module": "test.mod", "content": {}}),
-        encoding="utf-8",
-    )
-
-    return mcp_root
-
-
-@pytest.fixture
-def mock_mcp_server_run(monkeypatch):
-    """
-    Mock MCPServer.run so no real server is started.
-    """
-    called = {"value": False}
-
-    def fake_run(self, transport="streamable-http"):
-        called["value"] = True
-
-    monkeypatch.setattr(
-        "docforge.servers.MCPServer.run",
-        fake_run,
-    )
-
-    return lambda: called["value"]

tests/cli/test_build.py

@@ -1,20 +0,0 @@
-from docforge.cli.main import cli
-
-
-def test_build_command(
-    cli_runner,
-    fake_mkdocs_yml,
-    mock_mkdocs_load_config,
-    mock_mkdocs_build,
-):
-    result = cli_runner.invoke(
-        cli,
-        [
-            "build",
-            "--mkdocs-yml",
-            str(fake_mkdocs_yml),
-        ],
-    )
-
-    assert result.exit_code == 0
-    assert mock_mkdocs_build() is True

tests/cli/test_build_mcp.py

@@ -1,35 +1,29 @@
 from pathlib import Path
-
 from docforge.cli.main import cli
 
-
-def test_generate_command(cli_runner):
+def test_mcp_build(cli_runner):
     with cli_runner.isolated_filesystem():
         cwd = Path.cwd()
-
-        # Create package structure
         pkg = cwd / "testpkg"
         pkg.mkdir()
         (pkg / "__init__.py").write_text("")
         (pkg / "mod.py").write_text("def f(): ...\n")
 
-        docs_dir = cwd / "docs"
+        out_dir = cwd / "mcp_docs"
 
         result = cli_runner.invoke(
             cli,
             [
-                "generate",
+                "build",
+                "--mcp",
                 "--module",
                 "testpkg",
-                "--docs-dir",
-                str(docs_dir),
+                "--out-dir",
+                str(out_dir),
             ],
         )
 
         assert result.exit_code == 0
-
-        md = docs_dir / "testpkg" / "mod.md"
-        assert md.exists()
-
-        content = md.read_text()
-        assert "::: testpkg.mod" in content
+        assert (out_dir / "index.json").exists()
+        assert (out_dir / "nav.json").exists()
+        assert (out_dir / "modules" / "testpkg.mod.json").exists()

tests/cli/test_build_mkdocs.py

@@ -0,0 +1,99 @@
+from pathlib import Path
+from docforge.cli.main import cli
+
+def test_mkdocs_build_full_flow(
+    cli_runner,
+    mock_mkdocs_build,
+    mock_mkdocs_load_config,
+    tmp_path,
+):
+    # This test covers what used to be generate + mkdocs + build
+    with cli_runner.isolated_filesystem():
+        cwd = Path.cwd()
+        pkg = cwd / "testpkg"
+        pkg.mkdir()
+        (pkg / "__init__.py").write_text("")
+        (pkg / "mod.py").write_text("def f(): ...\n")
+
+        nav_file = cwd / "docforge.nav.yml"
+        nav_file.write_text("home: testpkg/index.md\ngroups: {}\n")
+        
+        # We need to create a dummy testpkg/index.md for nav resolution if it's there
+        # But generate_sources will create it. 
+        # Wait, the current logic runs generate_sources first, THEN generate_config.
+        
+        result = cli_runner.invoke(
+            cli,
+            [
+                "build",
+                "--mkdocs",
+                "--module",
+                "testpkg",
+                "--site-name",
+                "Test Site",
+                "--docs-dir",
+                "docs",
+                "--mkdocs-yml",
+                "mkdocs.yml",
+            ],
+        )
+
+        assert result.exit_code == 0
+        assert mock_mkdocs_build() is True
+        assert (cwd / "mkdocs.yml").exists()
+        assert (cwd / "docs" / "testpkg" / "mod.md").exists()
+
+def test_mkdocs_build_missing_module_fails(cli_runner):
+    result = cli_runner.invoke(cli, ["build", "--mkdocs", "--site-name", "Test"])
+    assert result.exit_code != 0
+    assert "--module is required" in result.output
+
+def test_mkdocs_build_without_site_name_uses_module_as_default_full_flow(
+    cli_runner,
+    mock_mkdocs_build,
+    mock_mkdocs_load_config,
+):
+    # Full integration test: real generation, real config, mocked mkdocs build
+    with cli_runner.isolated_filesystem():
+        cwd = Path.cwd()
+
+        # Create a minimal Python package
+        pkg = cwd / "testpkg"
+        pkg.mkdir()
+        (pkg / "__init__.py").write_text("")
+        (pkg / "mod.py").write_text("def f(): ...\n")
+
+        # Create nav spec expected by generate_config
+        nav_file = cwd / "docforge.nav.yml"
+        nav_file.write_text(
+            "home: testpkg/index.md\ngroups: {}\n",
+            encoding="utf-8",
+        )
+
+        result = cli_runner.invoke(
+            cli,
+            [
+                "build",
+                "--mkdocs",
+                "--module",
+                "testpkg",
+                "--docs-dir",
+                "docs",
+                "--mkdocs-yml",
+                "mkdocs.yml",
+            ],
+        )
+
+        assert result.exit_code == 0
+        assert mock_mkdocs_build() is True
+
+        # MkDocs config must exist
+        mkdocs_yml = cwd / "mkdocs.yml"
+        assert mkdocs_yml.exists()
+
+        # Site name must default to module name
+        content = mkdocs_yml.read_text()
+        assert "site_name: testpkg" in content
+
+        # Docs must be generated
+        assert (cwd / "docs" / "testpkg" / "mod.md").exists()

tests/cli/test_mkdocs.py

@@ -1,123 +0,0 @@
-from pathlib import Path
-
-import yaml
-from click.testing import CliRunner
-
-from docforge.cli.main import cli
-
-
-def _write_nav_spec(path: Path) -> None:
-    path.write_text(
-        """
-home: openapi_first/index.md
-groups:
-  Core:
-    - openapi_first/app.md
-    - openapi_first/client.md
-""".strip(),
-        encoding="utf-8",
-    )
-
-
-def _write_docs(docs: Path) -> None:
-    files = [
-        "openapi_first/index.md",
-        "openapi_first/app.md",
-        "openapi_first/client.md",
-    ]
-    for rel in files:
-        p = docs / rel
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_text(f"# {rel}", encoding="utf-8")
-
-
-def test_mkdocs_uses_builtin_template(tmp_path: Path) -> None:
-    docs = tmp_path / "docs"
-    docs.mkdir()
-
-    nav_file = tmp_path / "docforge.nav.yml"
-    out_file = tmp_path / "mkdocs.yml"
-
-    _write_docs(docs)
-    _write_nav_spec(nav_file)
-
-    runner = CliRunner()
-    result = runner.invoke(
-        cli,
-        [
-            "mkdocs",
-            "--site-name",
-            "DocForge",
-            "--docs-dir",
-            str(docs),
-            "--nav",
-            str(nav_file),
-            "--out",
-            str(out_file),
-        ],
-    )
-
-    assert result.exit_code == 0
-    assert out_file.exists()
-
-
-def test_mkdocs_overrides_template(tmp_path: Path) -> None:
-    docs = tmp_path / "docs"
-    docs.mkdir()
-
-    nav_file = tmp_path / "docforge.nav.yml"
-    template = tmp_path / "custom.yml"
-    out_file = tmp_path / "mkdocs.yml"
-
-    _write_docs(docs)
-    _write_nav_spec(nav_file)
-
-    template.write_text(
-        """
-site_name: Custom Site
-theme:
-  name: readthedocs
-""".strip(),
-        encoding="utf-8",
-    )
-
-    runner = CliRunner()
-    result = runner.invoke(
-        cli,
-        [
-            "mkdocs",
-            "--site-name",
-            "Override Site",
-            "--docs-dir",
-            str(docs),
-            "--nav",
-            str(nav_file),
-            "--template",
-            str(template),
-            "--out",
-            str(out_file),
-        ],
-    )
-
-    assert result.exit_code == 0
-    assert out_file.exists()
-
-
-def test_mkdocs_missing_nav_fails(tmp_path: Path) -> None:
-    docs = tmp_path / "docs"
-    docs.mkdir()
-
-    runner = CliRunner()
-    result = runner.invoke(
-        cli,
-        [
-            "mkdocs",
-            "--site-name",
-            "DocForge",
-            "--docs-dir",
-            str(docs),
-        ],
-    )
-
-    assert result.exit_code != 0
-    assert "Nav spec not found" in result.output

tests/cli/test_serve_mcp.py

@@ -1,7 +1,6 @@
 from docforge.cli.main import cli
 
-
-def test_serve_mcp(
+def test_mcp_serve(
     cli_runner,
     fake_mcp_docs,
     mock_mcp_server_run,
@@ -11,7 +10,7 @@ def test_serve_mcp(
 
     result = cli_runner.invoke(
         cli,
-        ["serve-mcp"],
+        ["serve", "--mcp", "--module", "fake_module", "--out-dir", str(fake_mcp_docs)],
     )
 
     assert result.exit_code == 0

tests/cli/test_serve_mkdocs.py

@@ -1,7 +1,6 @@
 from docforge.cli.main import cli
 
-
-def test_serve_command(
+def test_mkdocs_serve(
     cli_runner,
     fake_mkdocs_yml,
     mock_mkdocs_serve,
@@ -10,6 +9,7 @@ def test_serve_command(
         cli,
         [
             "serve",
+            "--mkdocs",
             "--mkdocs-yml",
             str(fake_mkdocs_yml),
         ],

tests/cli/test_tree.py

@@ -1,24 +0,0 @@
-from docforge.cli.main import cli
-
-
-def test_tree_command(cli_runner, temp_package):
-    (temp_package / "mod.py").write_text(
-        '''
-class A:
-    def f(self): ...
-'''
-    )
-
-    result = cli_runner.invoke(
-        cli,
-        [
-            "tree",
-            "--modules",
-            "testpkg.mod",
-        ],
-    )
-
-    assert result.exit_code == 0
-    assert "testpkg" in result.output
-    assert "mod" in result.output
-    assert "A" in result.output

tests/conftest.py

@@ -1,7 +1,9 @@
 import sys
+import json
+import pytest
 from pathlib import Path
 
-import pytest
+from click.testing import CliRunner
 
 
 @pytest.fixture
@@ -16,3 +18,109 @@ def temp_package(tmp_path: Path):
     sys.path.insert(0, str(tmp_path))
     yield pkg
     sys.path.remove(str(tmp_path))
+
+
+@pytest.fixture
+def cli_runner() -> CliRunner:
+    """Click CLI runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def fake_mkdocs_yml(tmp_path: Path) -> Path:
+    """Create a minimal mkdocs.yml file."""
+    yml = tmp_path / "mkdocs.yml"
+    yml.write_text(
+        """
+site_name: Test Docs
+nav: []
+plugins:
+  - mkdocstrings
+""",
+        encoding="utf-8",
+    )
+    return yml
+
+
+@pytest.fixture
+def mock_mkdocs_load_config(monkeypatch):
+    """Mock mkdocs.config.load_config."""
+    def fake_load_config(path):
+        return object()  # dummy config object
+
+    monkeypatch.setattr(
+        "mkdocs.config.load_config",
+        fake_load_config,
+    )
+
+
+@pytest.fixture
+def mock_mkdocs_build(monkeypatch):
+    called = {"value": False}
+
+    def fake_build(config):
+        called["value"] = True
+
+    monkeypatch.setattr(
+        "mkdocs.commands.build.build",
+        fake_build,
+    )
+    return lambda: called["value"]
+
+
+@pytest.fixture
+def mock_mkdocs_serve(monkeypatch):
+    called = {"value": False}
+
+    def fake_serve(*args, **kwargs):
+        called["value"] = True
+
+    monkeypatch.setattr(
+        "mkdocs.commands.serve.serve",
+        fake_serve,
+    )
+    return lambda: called["value"]
+
+@pytest.fixture
+def fake_mcp_docs(tmp_path: Path) -> Path:
+    """
+    Create a minimal valid MCP bundle in mcp_docs/.
+    """
+    mcp_root = tmp_path / "mcp_docs"
+    modules_dir = mcp_root / "modules"
+    modules_dir.mkdir(parents=True)
+
+    (mcp_root / "index.json").write_text(
+        json.dumps({"project": "test", "type": "docforge-model"}),
+        encoding="utf-8",
+    )
+
+    (mcp_root / "nav.json").write_text(
+        json.dumps([]),
+        encoding="utf-8",
+    )
+
+    (modules_dir / "test.mod.json").write_text(
+        json.dumps({"module": "test.mod", "content": {}}),
+        encoding="utf-8",
+    )
+
+    return mcp_root
+
+
+@pytest.fixture
+def mock_mcp_server_run(monkeypatch):
+    """
+    Mock MCPServer.run so no real server is started.
+    """
+    called = {"value": False}
+
+    def fake_run(self, transport="streamable-http"):
+        called["value"] = True
+
+    monkeypatch.setattr(
+        "docforge.servers.MCPServer.run",
+        fake_run,
+    )
+
+    return lambda: called["value"]

tests/renderers/mkdocs/test_mkdocs_content.py

@@ -17,3 +17,34 @@ def test_mkdocs_file_content(tmp_path: Path):
 
     assert "# Mod" in content
     assert "::: testpkg.mod" in content
+
+
+def test_generate_readme_source_root(tmp_path: Path):
+    project = Project("testpkg")
+
+    root = Module("testpkg")
+    root.docstring = "Test package documentation."
+
+    project.add_module(root)
+    project.add_module(Module("testpkg.mod"))
+
+    docs_dir = tmp_path / "docs"
+
+    renderer = MkDocsRenderer()
+
+    renderer.generate_sources(project, docs_dir)
+
+    renderer.generate_readme(
+        project,
+        docs_dir,
+        module_is_source=True,
+    )
+
+    readme = tmp_path / "README.md"
+
+    assert readme.exists()
+
+    content = readme.read_text()
+
+    assert "# testpkg" in content
+    assert "Test package documentation." in content

tests/renderers/mkdocs/test_mkdocs_idempotency.py

@@ -18,3 +18,36 @@ def test_mkdocs_idempotent(tmp_path: Path):
     second = (out_dir / "testpkg" / "mod.md").read_text()
 
     assert first == second
+
+
+def test_generate_readme_idempotent(tmp_path: Path):
+    project = Project("testpkg")
+
+    root = Module("testpkg")
+    root.docstring = "Test package documentation."
+
+    project.add_module(root)
+
+    docs_dir = tmp_path / "docs"
+
+    renderer = MkDocsRenderer()
+
+    renderer.generate_readme(
+        project,
+        docs_dir,
+        module_is_source=True,
+    )
+
+    readme = tmp_path / "README.md"
+
+    first = readme.read_text()
+
+    renderer.generate_readme(
+        project,
+        docs_dir,
+        module_is_source=True,
+    )
+
+    second = readme.read_text()
+
+    assert first == second

tests/renderers/mkdocs/test_mkdocs_module_coverage.py

@@ -17,6 +17,12 @@ def test_mkdocs_emits_all_modules(tmp_path: Path) -> None:
     renderer = MkDocsRenderer()
     renderer.generate_sources(project, tmp_path)
 
+    renderer.generate_readme(
+        project,
+        tmp_path,
+        module_is_source=True,
+    )
+
     emitted = {
         p.relative_to(tmp_path).as_posix()
         for p in tmp_path.rglob("*.md")
@@ -39,3 +45,8 @@ def test_mkdocs_emits_all_modules(tmp_path: Path) -> None:
 
     missing = expected - emitted
     assert not missing, f"Missing markdown files for modules: {missing}"
+
+    readme = tmp_path.parent / "README.md"
+    assert readme.exists(), "README.md was not generated"
+    content = readme.read_text(encoding="utf-8")
+    assert project.name in content

tests/renderers/mkdocs/test_mkdocs_structure.py

@@ -13,6 +13,12 @@ def test_mkdocs_directory_structure(tmp_path: Path):
     renderer = MkDocsRenderer()
 
     renderer.generate_sources(project, out_dir)
+    renderer.generate_readme(
+        project,
+        out_dir,
+        module_is_source=True,
+    )
 
     assert (out_dir / "testpkg" / "index.md").exists()
     assert (out_dir / "testpkg" / "sub.md").exists()
+    assert (tmp_path / "README.md").exists()