fix(mkdocs): rebase cross-kind wiki links under directory URLs

Wiki pages linking to a sibling kind (for example ../lib/...) were emitted verbatim by MkDocs and, with use_directory_urls, resolved into a non-existent <kind>/<kind>/ path. Add a docforge-linkfix plugin (doc-forge 0.0.8) that rebases those links to the repository root.

.drone.yml

@@ -23,20 +23,50 @@ steps:
     commands:
       - PACKAGE_NAME=$(grep -E '^name\s*=' pyproject.toml | head -1 | cut -d'"' -f2)
       - VERSION=$(grep -E '^version\s*=' pyproject.toml | head -1 | cut -d'"' -f2)
-      - echo "🔍 Checking if $PACKAGE_NAME==$VERSION exists on $PIP_REPO_URL ..."
       - |
-        if curl -fsSL -u "$PIP_USERNAME:$PIP_PASSWORD" "$PIP_REPO_URL/simple/$PACKAGE_NAME/" | grep -q "$VERSION"; then
-          echo "✅ $PACKAGE_NAME==$VERSION already exists — skipping build."
+        if [ "$DRONE_TAG" != "$VERSION" ]; then
+          echo "Tag '$DRONE_TAG' does not match pyproject version '$VERSION'; refusing to publish."
+          exit 1
+        fi
+      - echo "Checking if $PACKAGE_NAME==$VERSION exists on $PIP_REPO_URL ..."
+      - |
+        if curl -fsSL -u "$PIP_USERNAME:$PIP_PASSWORD" "$PIP_REPO_URL/simple/$PACKAGE_NAME/" | grep -qE "${PACKAGE_NAME}-${VERSION}(-|\.tar\.gz|\.whl)"; then
+          echo "$PACKAGE_NAME==$VERSION already exists; skipping build."
           exit 78
         else
-          echo "🆕 New version detected: $PACKAGE_NAME==$VERSION"
+          echo "New version detected: $PACKAGE_NAME==$VERSION"
         fi
 
+  - name: quality-gate
+    image: python:3.13-slim
+    environment:
+      PIP_REPO_URL:
+        from_secret: PIP_REPO_URL
+      PIP_USERNAME:
+        from_secret: PIP_USERNAME
+      PIP_PASSWORD:
+        from_secret: PIP_PASSWORD
+    commands:
+      - pip install --upgrade pip build
+      - |
+        if [ -z "$PIP_REPO_URL" ] || [ -z "$PIP_USERNAME" ] || [ -z "$PIP_PASSWORD" ]; then
+          echo "PIP_REPO_URL / PIP_USERNAME / PIP_PASSWORD are not set" >&2
+          exit 1
+        fi
+      - AUTH_URL="https://$PIP_USERNAME:$PIP_PASSWORD@$(echo "$PIP_REPO_URL" | sed -E 's|^[a-zA-Z]+://||; s|/*$||')/simple"
+      - pip install --index-url "$AUTH_URL" --extra-index-url https://pypi.org/simple/ -U ".[dev]" "pydoclint>=0.9.1"
+      - echo "Running quality gate..."
+      - python -m black --check .
+      - python -m ruff check .
+      - python -m mypy
+      - pydoclint .
+      - python -m pytest
+
   - name: build-package
     image: python:3.13-slim
     commands:
       - pip install --upgrade pip build
-      - echo "📦 Building Python package..."
+      - echo "Building Python package..."
       - python -m build
       - ls -l dist
 
@@ -51,7 +81,7 @@ steps:
         from_secret: PIP_PASSWORD
     commands:
       - pip install --upgrade twine
-      - echo "🚀 Uploading to private PyPI at $PIP_REPO_URL ..."
+      - echo "Uploading to private PyPI at $PIP_REPO_URL ..."
       - |
         twine upload \
           --repository-url "$PIP_REPO_URL" \
@@ -98,25 +128,31 @@ steps:
         set -e
 
         PACKAGE_NAME=$(grep -E '^name\s*=' pyproject.toml | cut -d'"' -f2)
-        echo "📦 Package: $PACKAGE_NAME"
+        echo "Package: $PACKAGE_NAME"
 
         for TAG in $(git tag --sort=version:refname); do
           VERSION="$TAG"
-          echo "🔁 Version: $VERSION"
+          echo "Version: $VERSION"
 
           if curl -fsSL -u "$PIP_USERNAME:$PIP_PASSWORD" \
-            "$PIP_REPO_URL/simple/$PACKAGE_NAME/" | grep -q "$VERSION"; then
-            echo "⏭️  Exists, skipping"
+            "$PIP_REPO_URL/simple/$PACKAGE_NAME/" | grep -qE "${PACKAGE_NAME}-${VERSION}(-|\.tar\.gz|\.whl)"; then
+            echo "Exists, skipping"
             continue
           fi
 
           git checkout --force "$TAG"
 
-          echo "🏗️  Building $VERSION"
+          TAG_VERSION=$(grep -E '^version\s*=' pyproject.toml | head -1 | cut -d'"' -f2)
+          if [ "$TAG" != "$TAG_VERSION" ]; then
+            echo "Tag $TAG != pyproject version $TAG_VERSION at that commit; skipping"
+            continue
+          fi
+
+          echo "Building $VERSION"
           rm -rf dist
           python -m build
 
-          echo "⬆️  Uploading $VERSION"
+          echo "Uploading $VERSION"
           twine upload \
             --repository-url "$PIP_REPO_URL" \
             -u "$PIP_USERNAME" \

.gitignore

@@ -53,6 +53,7 @@ test-results/
 site/
 docs/_site/
 docs/build/
+mkdocs.yml
 
 # =========================
 # MkDocs / Sphinx output
@@ -87,3 +88,8 @@ Thumbs.db
 # =========================
 .env
 .env.*
+
+# =========================
+# Testing artifacts
+# =========================
+coverage.xml

.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.*

CHANGELOG.md

@@ -0,0 +1,64 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.0.8] - 2026-10-17
+
+### Added
+- `docforge-linkfix` MkDocs plugin (registered via the `mkdocs.plugins`
+  entry point) that rebases cross-kind relative links — for example
+  `../lib/...` written in a wiki page — to the repository root so they resolve
+  to `/<repo>/<kind>/` under directory URLs.
+
+### Changed
+- The wiki template (`mkdocs.wiki.yml`) now enables `docforge-linkfix`;
+  regenerating a wiki config (or passing `--refresh`) propagates the fix.
+
+### Fixed
+- Cross-kind links (`../lib/`, `../api/`, `../wiki/`) in generated wikis no
+  longer resolve into a non-existent `<kind>/<kind>/` path.
+
+## [0.0.7] - 2026-10-17
+
+### Added
+- `py.typed` marker for PEP 561 type information.
+- `build --refresh` flag to rebaseline an existing `docs/mkdocs.{kind}.yml`
+  from the packaged templates.
+- `wiki` build kind with navigation derived from the source file structure.
+- `--api` build mode rendering an OpenAPI reference under `docs/api` with
+  lib-prefixed navigation.
+- Hand-written wiki, plus doc-forge-generated API reference under `docs/lib`
+  and MCP bundle under `docs/mcp` (per-kind MkDocs configs).
+- MIT `LICENSE`.
+
+### Changed
+- Adopted the standard Type A PyPI CI pipeline: a `tag == version` guard and a
+  quality gate (black, ruff, mypy, pydoclint, pytest).
+- Standardized `pyproject.toml` (canonical packaging, lint tool config, extras).
+- Pinned the `mcp` extra to `mcp>=1.0.0,<2.0.0` to restore compatibility with
+  the current MCP server API used by doc-forge.
+- Per-kind MkDocs configs (`docs/mkdocs.{lib,api,wiki}.yml`) are generated only
+  when absent; an existing config is used verbatim (the file wins). Pass
+  `--refresh` to regenerate it from the templates.
+- The wiki template now uses the mongo-ops look: horizontal `navigation.tabs`
+  header, blue grey/teal palette, Roboto font, and additional material feature
+  flags. The lib and api templates are unchanged.
+- Docstrings and wiki brought to the GSDFC (Google-style) standard.
+- The `dev` extra now includes the `mkdocs` and `mcp` extras so the
+  quality-gate environment can install and run the full test suite.
+
+### Fixed
+- Loader-generated signatures render cleanly and unresolvable aliases are
+  dropped from generated models.
+- Stub fixes for typed API surfaces.
+- `import docforge` no longer requires the optional `mcp` dependency; the
+  MCP server imports `mcp` lazily, matching the MkDocs backend.
+
+[Unreleased]: https://git.aetoskia.com/aetos/doc-forge/compare/0.0.8...HEAD
+[0.0.8]: https://git.aetoskia.com/aetos/doc-forge/compare/0.0.7...0.0.8
+[0.0.7]: https://git.aetoskia.com/aetos/doc-forge/compare/0.0.6...0.0.7

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aetoskia Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,243 +1,586 @@
-# 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
+
+Each site kind (`lib`, `api`, `wiki`) is built independently into `site/{kind}`.
+
+## Build the library reference 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
+## Build the API reference from an OpenAPI spec:
 
 ```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 --api --openapi-spec spec.json
 ```
 
-### Python API
-
-```python
-from docforge.loader 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.
+## Build the hand-written wiki:
 
 ```bash
-doc-forge generate --renderer mkdocs --out-dir docs mypackage
+doc-forge build --wiki --site-name my_package
 ```
 
-### `build`
-Build final documentation artifacts (HTML, etc.).
+## Generate MCP JSON documentation:
 
 ```bash
-doc-forge build --renderer sphinx mypackage
+doc-forge build --mcp --module my_package
 ```
 
-### `serve`
-Start a local development server.
+## Build several kinds in one pass:
 
 ```bash
-doc-forge serve --renderer mkdocs --port 9000 mypackage
+doc-forge build --mcp --mkdocs --wiki --module my_package
 ```
 
-### `export`
-Export to MCP format for machine consumption.
+Each enabled kind gets its own MkDocs config (`docs/mkdocs.{lib,api,wiki}.yml`)
+and its own site under `site/`.
+
+## Serve a site locally:
 
 ```bash
-doc-forge export --out-dir mcp mypackage
+doc-forge serve --wiki        # preview from docs/mkdocs.wiki.yml
+doc-forge serve --lib
+doc-forge serve --api
+# or any config directly:
+doc-forge serve --mkdocs --mkdocs-yml docs/mkdocs.wiki.yml
 ```
 
-### `server`
-Start live MCP server for real-time access.
+## Serve MCP locally:
 
 ```bash
-doc-forge server --host 0.0.0.0 --port 8080 mypackage
+doc-forge serve --mcp --module my_package
 ```
 
-## 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.
+- Use parenthesized types in prose entries (`name (Type):`) that match the
+  signature types. This keeps docstrings self-contained and machine-parseable.
+- 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 argument descriptions and other prose lines.
+
+Inside `Example:` sections, fenced `python` code blocks are allowed and must be
+indented four spaces, matching the examples below.
+
+---
+
+# 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.
+        '''
+        ```
+
+---
+
+# Type parity (`.pyi` stubs and `py.typed`)
+
+Documented APIs ship matching type information:
+
+- Each `.py` module has a synchronized `.pyi` stub in the same package.
+- Packages expose a `py.typed` marker so type checkers (and consumers)
+  use the authored signatures instead of `Any`.
+- When signatures change, update the `.py` implementation and its `.pyi`
+  stub together.
+- Doc-forge documents the docstrings in `.py`; the `.pyi` stub is the
+  machine-consumable signature surface.
+
+---
+
+# 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,23 +1,30 @@
-home: docforge/index.md
+home: lib/index.md
 groups:
-  Loader:
-    - docforge/loader/index.md
-    - docforge/loader/griffe_loader.md
-  Model:
-    - docforge/model/index.md
-    - docforge/model/module.md
-    - docforge/model/object.md
-    - docforge/model/project.md
+  Loaders:
+    - lib/loaders/index.md
+    - lib/loaders/griffe_loader.md
+  Models:
+    - lib/models/index.md
+    - lib/models/module.md
+    - lib/models/object.md
+    - lib/models/project.md
   Navigation:
-    - docforge/nav/index.md
-    - docforge/nav/spec.md
-    - docforge/nav/resolver.md
-    - docforge/nav/mkdocs.md
+    - lib/nav/index.md
+    - lib/nav/spec.md
+    - lib/nav/resolver.md
+    - lib/nav/mkdocs.md
   Renderers:
-    - docforge/renderers/index.md
-    - docforge/renderers/base.md
-    - docforge/renderers/mkdocs.md
+    - lib/renderers/index.md
+    - lib/renderers/base.md
+    - lib/renderers/mkdocs_renderer.md
+    - lib/renderers/mcp_renderer.md
   CLI:
-    - docforge/cli/index.md
-    - docforge/cli/main.md
-    - docforge/cli/mkdocs.md
+    - lib/cli/index.md
+    - lib/cli/main.md
+    - lib/cli/commands.md
+    - lib/cli/api_utils.md
+    - lib/cli/mcp_utils.md
+    - lib/cli/mkdocs_utils.md
+icon:
+  logo: material/file-document-multiple
+  repo: fontawesome/brands/github

docforge/__init__.py

@@ -1,65 +1,600 @@
 """
-# 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 model.
+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
+
+Each site kind (`lib`, `api`, `wiki`) is built independently into `site/{kind}`.
+
+## Build the library reference from a Python package:
+
+```bash
+doc-forge build --mkdocs --module my_package
+```
+
+## Build the API reference from an OpenAPI spec:
+
+```bash
+doc-forge build --api --openapi-spec spec.json
+```
+
+## Build the hand-written wiki:
+
+```bash
+doc-forge build --wiki --site-name my_package
+```
+
+## Generate MCP JSON documentation:
+
+```bash
+doc-forge build --mcp --module my_package
+```
+
+## Build several kinds in one pass:
+
+```bash
+doc-forge build --mcp --mkdocs --wiki --module my_package
+```
+
+Each enabled kind gets its own MkDocs config (`docs/mkdocs.{lib,api,wiki}.yml`)
+and its own site under `site/`.
+
+## Serve a site locally:
+
+```bash
+doc-forge serve --wiki        # preview from docs/mkdocs.wiki.yml
+doc-forge serve --lib
+doc-forge serve --api
+# or any config directly:
+doc-forge serve --mkdocs --mkdocs-yml docs/mkdocs.wiki.yml
+```
+
+## 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.
+- Use parenthesized types in prose entries (`name (Type):`) that match the
+  signature types. This keeps docstrings self-contained and machine-parseable.
+- 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 argument descriptions and other prose lines.
+
+Inside `Example:` sections, fenced `python` code blocks are allowed and must be
+indented four spaces, matching the examples below.
+
+---
+
+# 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.loader`: Introspects source code using static analysis (`griffe`).
-- `docforge.model`: The internal representation of your project, modules, and objects.
-- `docforge.renderers`: Converters that turn the model 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.
+        '''
+        ```
+
+---
+
+# Type parity (`.pyi` stubs and `py.typed`)
+
+Documented APIs ship matching type information:
+
+- Each `.py` module has a synchronized `.pyi` stub in the same package.
+- Packages expose a `py.typed` marker so type checkers (and consumers)
+  use the authored signatures instead of `Any`.
+- When signatures change, update the `.py` implementation and its `.pyi`
+  stub together.
+- Doc-forge documents the docstrings in `.py`; the `.pyi` stub is the
+  machine-consumable signature surface.
+
+---
+
+# 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 .loader import GriffeLoader, discover_module_paths
-from .renderers import MkDocsRenderer
+from .loaders import GriffeLoader, discover_module_paths
+from .renderers import MkDocsRenderer, MCPRenderer
 from .cli import main
-from . import model
+from . import models
 
 __all__ = [
     "GriffeLoader",
     "discover_module_paths",
     "MkDocsRenderer",
-    "model",
+    "MCPRenderer",
+    "models",
     "main",
 ]

docforge/__init__.pyi

@@ -1,12 +1,13 @@
-from .loader import GriffeLoader, discover_module_paths
-from .renderers import MkDocsRenderer
+from . import models
 from .cli import main
-from . import model
+from .loaders import GriffeLoader, discover_module_paths
+from .renderers import MCPRenderer, MkDocsRenderer
 
 __all__ = [
     "GriffeLoader",
     "discover_module_paths",
     "MkDocsRenderer",
-    "model",
+    "MCPRenderer",
+    "models",
     "main",
 ]

docforge/cli/__init__.py

@@ -1,20 +1,40 @@
 """
-# 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
 
-__all__ = [
-    "main"
-]
+__all__ = ["main"]

docforge/cli/__init__.pyi

@@ -1,5 +1,3 @@
 from .main import main
 
-__all__ = [
-    "main"
-]
+__all__ = ["main"]

docforge/cli/api_utils.py

@@ -0,0 +1,118 @@
+"""
+# Summary
+
+Utilities for building API documentation from an OpenAPI specification.
+"""
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+
+SWAGGER_SPEC_FILENAME = "openapi.json"
+
+
+@dataclass
+class OpenAPIMetadata:
+    """
+    Metadata derived from the ``info`` block of an OpenAPI specification.
+
+    Attributes:
+        site_name: Spec title, used as the MkDocs site name.
+        site_description: Spec description, used as the site description.
+        site_author: Contact name (fallback: contact email), used as the
+            site author.
+    """
+
+    site_name: str
+    site_description: str | None
+    site_author: str | None
+
+
+def load_openapi_spec(spec_path: Path) -> dict:
+    """
+    Load and validate an OpenAPI specification from a JSON file.
+
+    Args:
+        spec_path (Path):
+            Path to the OpenAPI JSON specification file.
+
+    Returns:
+        dict:
+            The parsed OpenAPI specification.
+
+    Raises:
+        click.ClickException:
+            If the file cannot be read or the ``info`` block is invalid.
+    """
+    if not spec_path.exists():
+        raise click.ClickException(f"OpenAPI spec not found: {spec_path}")
+
+    try:
+        data = json.loads(spec_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as exc:
+        raise click.ClickException(f"Unable to read OpenAPI spec: {exc}") from exc
+
+    if not isinstance(data, dict):
+        raise click.ClickException("OpenAPI spec must be a JSON mapping")
+
+    info = data.get("info")
+    if not isinstance(info, dict) or not isinstance(info.get("title"), str):
+        raise click.ClickException("OpenAPI spec missing 'info.title'")
+
+    return data
+
+
+def derive_metadata(spec: dict) -> OpenAPIMetadata:
+    """
+    Derive MkDocs site metadata from an OpenAPI spec ``info`` block.
+
+    Args:
+        spec (dict):
+            Parsed OpenAPI specification.
+
+    Returns:
+        OpenAPIMetadata:
+            Site name, description, and author derived from the spec.
+    """
+    info = spec["info"]
+
+    contact = info.get("contact")
+    if isinstance(contact, dict):
+        author = contact.get("name") or contact.get("email")
+    else:
+        author = None
+
+    return OpenAPIMetadata(
+        site_name=info.get("title", ""),
+        site_description=info.get("description"),
+        site_author=author,
+    )
+
+
+def generate_api_sources(spec: dict, docs_dir: Path) -> None:
+    """
+    Generate swagger-enabled Markdown sources and the spec copy.
+
+    The specification is written as ``openapi.json`` inside ``docs_dir`` and
+    an ``index.md`` embedding the swagger UI is generated alongside it.
+
+    Args:
+        spec (dict):
+            Parsed OpenAPI specification.
+        docs_dir (Path):
+            Directory (for example ``docs/api``) where the swagger
+            sources are written.
+    """
+    docs_dir.mkdir(parents=True, exist_ok=True)
+
+    spec_path = docs_dir / SWAGGER_SPEC_FILENAME
+    spec_json = json.dumps(spec, indent=2)
+    if not spec_path.exists() or spec_path.read_text(encoding="utf-8") != spec_json:
+        spec_path.write_text(spec_json, encoding="utf-8")
+
+    index_path = docs_dir / "index.md"
+    content = "# API Reference\n\n" f'<swagger-ui src="{SWAGGER_SPEC_FILENAME}"/>\n'
+    if not index_path.exists() or index_path.read_text(encoding="utf-8") != content:
+        index_path.write_text(content, encoding="utf-8")

docforge/cli/api_utils.pyi

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+@dataclass
+class OpenAPIMetadata:
+    site_name: str
+    site_description: str | None
+    site_author: str | None
+
+def load_openapi_spec(spec_path: Path) -> dict[Any, Any]: ...
+def derive_metadata(spec: dict[Any, Any]) -> OpenAPIMetadata: ...
+def generate_api_sources(spec: dict[Any, Any], docs_dir: Path) -> None: ...

docforge/cli/commands.py

@@ -0,0 +1,445 @@
+"""
+# Summary
+
+Command definitions for the doc-forge CLI.
+
+Provides the CLI structure using Click, including build, serve, and tree commands.
+
+---
+
+Notes:
+    - The `build` command validates requested modes before generating anything.
+    - `--mkdocs`, `--api`, and `--wiki` each emit their own MkDocs config and
+      build (`docs/mkdocs.{kind}.yml` into `site/{kind}`); `--mcp` generates a
+      machine-readable bundle independently.
+
+---
+"""
+
+import os
+from pathlib import Path
+
+import click
+
+from docforge.cli import api_utils, mcp_utils, mkdocs_utils
+from docforge.loaders import GriffeLoader
+from docforge.models import DocObject
+
+
+@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 the lib MkDocs site")
+@click.option("--api", is_flag=True, help="Build API docs from an OpenAPI spec")
+@click.option(
+    "--wiki", is_flag=True, help="Build a hand-written wiki as its own MkDocs site"
+)
+@click.option(
+    "--refresh",
+    is_flag=True,
+    help="Regenerate existing docs/mkdocs.{kind}.yml configs from templates",
+)
+@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(
+    "--openapi-spec",
+    type=click.Path(path_type=Path),
+    help="Path to the OpenAPI JSON specification",
+)
+@click.option("--project-name", help="Project name override")
+@click.option("--site-name", help="MkDocs site name for lib and wiki sites")
+@click.option(
+    "--docs-dir",
+    type=click.Path(path_type=Path),
+    default=Path("docs"),
+    help="MkDocs documentation root",
+)
+@click.option(
+    "--wiki-dir",
+    type=click.Path(path_type=Path),
+    default=Path("docs/wiki"),
+    help="Hand-written wiki directory built as its own MkDocs site",
+)
+@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(
+    "--out-dir",
+    type=click.Path(path_type=Path),
+    default=Path("docs/mcp"),
+    help="MCP output directory",
+)
+def build(
+    mcp: bool,
+    mkdocs: bool,
+    api: bool,
+    wiki: bool,
+    refresh: bool,
+    module_is_source: bool,
+    module: str | None,
+    openapi_spec: Path | None,
+    project_name: str | None,
+    site_name: str | None,
+    docs_dir: Path,
+    wiki_dir: Path,
+    nav_file: Path,
+    template: Path | None,
+    out_dir: Path,
+) -> None:
+    """
+    Build documentation artifacts.
+
+    This command runs the full documentation pipeline: it loads Python
+    modules, generates renderer-specific documentation sources, and
+    optionally builds the final output.
+
+    Depending on the selected options, the build can target:
+
+    - A lib MkDocs site (`--mkdocs`) for library reference docs
+    - A swagger-enabled API MkDocs site (`--api`) built from an OpenAPI spec
+    - A wiki MkDocs site (`--wiki`) built from hand-written markdown
+    - MCP structured documentation resources (`--mcp`)
+
+    Each enabled site kind produces its own MkDocs configuration
+    (`docs/mkdocs.{kind}.yml`) and its own build (`site/{kind}`).
+
+    Notes:
+        - At least one of `--mcp`, `--mkdocs`, `--wiki`, or `--api` must be
+          provided.
+        - `--mkdocs`, `--api`, and `--wiki` emit independent MkDocs builds,
+          while `--mcp` emits a machine-readable bundle.
+        - Configuration files are generated only when absent; an existing
+          `docs/mkdocs.{kind}.yml` is used as-is. Pass `--refresh` to
+          rebaseline it from the templates.
+
+    Args:
+        mcp (bool):
+            Enable MCP documentation generation.
+
+        mkdocs (bool):
+            Enable the lib MkDocs documentation generation.
+
+        api (bool):
+            Enable API documentation generation from an OpenAPI spec.
+
+        wiki (bool):
+            Build a hand-written wiki directory as its own MkDocs site.
+
+        refresh (bool):
+            Regenerate ``docs/mkdocs.{kind}.yml`` from templates even when
+            it already exists. By default, existing configs are used as-is.
+
+        module_is_source (bool):
+            Treat the specified module directory as the project root.
+
+        module (str | None):
+            Python module import path to document.
+
+        openapi_spec (Path | None):
+            Path to the OpenAPI JSON specification used for API docs.
+
+        project_name (str | None):
+            Optional override for the project name.
+
+        site_name (str | None):
+            Display name for the lib and wiki MkDocs sites.
+
+        docs_dir (Path):
+            Shared documentation root used for generated sources.
+        wiki_dir (Path):
+            Directory containing hand-written wiki markdown files.
+
+        nav_file (Path):
+            Path to the navigation specification file.
+
+        template (Path | None):
+            Optional custom MkDocs configuration template.
+
+        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 and not api and not wiki:
+        raise click.UsageError("Must specify either --mcp, --mkdocs, --wiki, or --api")
+
+    if api:
+        if not openapi_spec:
+            raise click.UsageError("--openapi-spec is required for API build")
+        if site_name and not mkdocs and not wiki:
+            raise click.UsageError(
+                "--site-name cannot be overridden for API build; "
+                "the OpenAPI spec provides the site name"
+            )
+
+    if mkdocs and not module:
+        raise click.UsageError("--module is required for MkDocs build")
+    if mcp and not module:
+        raise click.UsageError("--module is required for MCP build")
+
+    spec: dict | None = None
+    if api:
+        spec = api_utils.load_openapi_spec(openapi_spec)
+
+    kinds: list[str] = []
+    if mkdocs:
+        kinds.append("lib")
+        lib_dir = docs_dir / "lib"
+        click.echo(f"Generating MkDocs sources in {lib_dir}...")
+        mkdocs_utils.generate_sources(
+            module,
+            lib_dir,
+            project_name,
+            module_is_source,
+            readme_dir=Path(".").resolve(),
+        )
+
+    if api:
+        kinds.append("api")
+        api_dir = docs_dir / "api"
+        click.echo(f"Generating API sources in {api_dir}...")
+        api_utils.generate_api_sources(spec, api_dir)
+
+    if wiki:
+        kinds.append("wiki")
+
+    if kinds:
+        api_metadata: api_utils.OpenAPIMetadata | None = None
+        if api:
+            api_metadata = api_utils.derive_metadata(spec)
+        theme_icon = mkdocs_utils.load_spec_icon(nav_file)
+
+        config_paths: list[Path] = []
+        for kind in kinds:
+            out = docs_dir / f"mkdocs.{kind}.yml"
+            if out.exists() and not refresh:
+                click.echo(
+                    f"Using existing MkDocs config {out} (run --refresh to rebaseline)..."
+                )
+                config_paths.append(out)
+                continue
+
+            kind_root = wiki_dir if kind == "wiki" else docs_dir / kind
+
+            site_name_kind = site_name or module or Path.cwd().name
+            site_description: str | None = None
+            site_author: str | None = None
+            if kind == "api" and api_metadata:
+                site_name_kind = api_metadata.site_name
+                site_description = api_metadata.site_description
+                site_author = api_metadata.site_author
+
+            if kind == "lib":
+                nav_block, _kind_icon = mkdocs_utils.build_lib_nav(nav_file, docs_dir)
+            elif kind == "wiki":
+                nav_block = mkdocs_utils.build_wiki_nav_block(wiki_dir)
+            else:
+                nav_block = [{"API Reference": "index.md"}]
+
+            click.echo(f"Generating MkDocs config {out}...")
+            mkdocs_utils.generate_site_config(
+                kind,
+                kind_root,
+                nav_block,
+                out,
+                site_name_kind,
+                Path(os.path.relpath(kind_root, docs_dir)).as_posix(),
+                Path(os.path.relpath(Path.cwd() / "site" / kind, docs_dir)).as_posix(),
+                template=template,
+                site_description=site_description,
+                site_author=site_author,
+                theme_icon=theme_icon,
+            )
+            config_paths.append(out)
+
+        click.echo("Running MkDocs builds...")
+        mkdocs_utils.build_configs(config_paths)
+
+    if mcp:
+        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 an MkDocs site from --mkdocs-yml")
+@click.option("--lib", is_flag=True, help="Serve the lib MkDocs site")
+@click.option("--api", is_flag=True, help="Serve the API MkDocs site")
+@click.option("--wiki", is_flag=True, help="Serve the wiki MkDocs site")
+@click.option("--module", help="Python module to serve")
+@click.option(
+    "--mkdocs-yml",
+    type=click.Path(path_type=Path),
+    default=Path("docs/mkdocs.wiki.yml"),
+    help="MkDocs config path",
+)
+@click.option(
+    "--out-dir",
+    type=click.Path(path_type=Path),
+    default=Path("docs/mcp"),
+    help="MCP root directory",
+)
+def serve(
+    mcp: bool,
+    mkdocs: bool,
+    lib: bool,
+    api: bool,
+    wiki: bool,
+    module: str | None,
+    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 a site, or
+    - An MCP server exposing structured documentation resources
+
+    The kind flags (`--lib`, `--api`, `--wiki`) select the generated
+    per-kind config (`docs/mkdocs.{kind}.yml`); `--mkdocs` serves the config
+    passed via `--mkdocs-yml`.
+
+    Args:
+        mcp (bool):
+            Serve documentation using the MCP server.
+
+        mkdocs (bool):
+            Serve the MkDocs development site from ``--mkdocs-yml``.
+
+        lib (bool):
+            Serve the lib MkDocs site.
+
+        api (bool):
+            Serve the API MkDocs site.
+
+        wiki (bool):
+            Serve the wiki MkDocs site.
+
+        module (str | None):
+            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.
+    """
+    selected = [
+        name
+        for name, enabled in (
+            ("mcp", mcp),
+            ("mkdocs", mkdocs),
+            ("lib", lib),
+            ("api", api),
+            ("wiki", wiki),
+        )
+        if enabled
+    ]
+    if len(selected) != 1:
+        raise click.UsageError(
+            "Must specify exactly one of --mcp, --mkdocs, --lib, --api, --wiki"
+        )
+
+    if mcp:
+        if not module:
+            raise click.UsageError("--module is required for MCP serve")
+        mcp_utils.serve(module, out_dir)
+        return
+
+    config = mkdocs_yml
+    if lib:
+        config = Path("docs/mkdocs.lib.yml")
+    elif api:
+        config = Path("docs/mkdocs.api.yml")
+    elif wiki:
+        config = Path("docs/mkdocs.wiki.yml")
+
+    mkdocs_utils.serve(config)
+
+
+@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: str | None,
+) -> 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 (str | None):
+            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: DocObject, 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 (DocObject):
+            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,39 @@
+from pathlib import Path
+
+from click.core import Group
+
+from docforge.models import DocObject
+
+cli: Group
+
+def build(
+    mcp: bool,
+    mkdocs: bool,
+    api: bool,
+    wiki: bool,
+    module_is_source: bool,
+    module: str | None,
+    openapi_spec: Path | None,
+    project_name: str | None,
+    site_name: str | None,
+    docs_dir: Path,
+    wiki_dir: Path,
+    nav_file: Path,
+    template: Path | None,
+    out_dir: Path,
+) -> None: ...
+def serve(
+    mcp: bool,
+    mkdocs: bool,
+    lib: bool,
+    api: bool,
+    wiki: bool,
+    module: str | None,
+    mkdocs_yml: Path,
+    out_dir: Path,
+) -> None: ...
+def tree(
+    module: str,
+    project_name: str | None,
+) -> None: ...
+def _print_object(obj: DocObject, indent: str) -> None: ...

docforge/cli/main.py

@@ -1,188 +1,22 @@
 """
-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.loader import GriffeLoader, discover_module_paths
-from docforge.renderers.mkdocs import MkDocsRenderer
-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.
-    """
-    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}")
-
-
-# ---------------------------------------------------------------------
-# 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
-# ---------------------------------------------------------------------
-
-@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.
+    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()
 

docforge/cli/main.pyi

@@ -1,76 +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()
-@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."""
-
-
-def main() -> None:
-    """CLI entry point."""
+def main() -> None: ...

docforge/cli/mcp_utils.py

@@ -0,0 +1,92 @@
+"""
+# Summary
+
+Utilities for working with MCP in the doc-forge CLI.
+
+---
+
+Notes:
+    - `generate_resources` produces the bundle consumed by `MCPServer`:
+      `index.json`, `nav.json`, and per-module resources under `modules/`.
+    - Resource URIs use the `docs://` scheme: `docs://index`, `docs://nav`,
+      and `docs://modules/{module}`.
+
+---
+"""
+
+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 (str | None):
+            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,6 @@
+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,453 @@
+"""
+# Summary
+
+Utilities for working with MkDocs in the doc-forge CLI.
+
+---
+
+Notes:
+    - A separate `mkdocs.{kind}.yml` configuration and build is emitted per
+      enabled kind (lib, api, wiki), each scoped to its own `docs_dir` and
+      written into its own `site_dir` (`site/lib`, `site/api`, `site/wiki`).
+    - Navigation blocks are re-rooted per kind: the wiki navigation drops its
+      leading `wiki/` scope and the resolved nav spec drops its `lib/` scope.
+
+---
+"""
+
+from collections.abc import Iterable
+from importlib import resources
+from pathlib import Path
+from typing import Any, cast
+
+import click
+import yaml
+
+from docforge.loaders import GriffeLoader, discover_module_paths
+from docforge.nav import (
+    MkDocsNavEmitter,
+    build_wiki_nav,
+    load_nav_spec,
+    resolve_nav,
+)
+from docforge.renderers import MkDocsRenderer
+
+
+def generate_sources(
+    module: str,
+    docs_dir: Path,
+    project_name: str | None = None,
+    module_is_source: bool | None = None,
+    readme_dir: Path | 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 (str | None):
+            Optional override for the project name used in documentation metadata.
+
+        module_is_source (bool | None):
+            If True, treat the specified module directory as the project root
+            rather than a nested module.
+
+        readme_dir (Path | None):
+            Directory where the generated README.md should be written. If not
+            provided, defaults to the parent of ``docs_dir``.
+    """
+    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,
+        readme_dir,
+    )
+
+
+def build_lib_nav(
+    nav_file: Path,
+    docs_root: Path,
+) -> tuple[list[dict[str, Any]], dict[str, str] | None]:
+    """
+    Build the re-rooted navigation block for a lib site.
+
+    The navigation specification is resolved against the shared documentation
+    root and every resulting path is re-rooted relative to the ``lib``
+    subdirectory by stripping its leading ``lib/`` scope component.
+
+    Args:
+        nav_file (Path):
+            Path to the `docforge.nav.yml` navigation specification.
+
+        docs_root (Path):
+            Shared documentation root containing the ``lib`` sources.
+
+    Returns:
+        tuple[list[dict[str, Any]], dict[str, str] | None]:
+            The re-rooted navigation block and the optional theme icon
+            mapping from the specification.
+
+    Raises:
+        click.FileError:
+            If the navigation specification 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_root)
+    block = MkDocsNavEmitter().emit(resolved)
+    return cast(list[dict[str, Any]], _strip_scope(block, "lib")), spec.icon
+
+
+def build_wiki_nav_block(wiki_dir: Path) -> list[dict[str, Any]]:
+    """
+    Build the re-rooted navigation block for a wiki site.
+
+    The wiki navigation derived from the wiki file structure is re-rooted
+    relative to the wiki directory itself by stripping the leading ``wiki/``
+    scope component.
+
+    Args:
+        wiki_dir (Path):
+            Path to the hand-written wiki directory, for example ``docs/wiki``.
+
+    Returns:
+        list[dict[str, Any]]:
+            Navigation entries relative to the wiki directory.
+
+    Raises:
+        click.FileError:
+            If the wiki directory does not exist.
+    """
+    if not wiki_dir.exists():
+        raise click.FileError(str(wiki_dir), hint="Wiki dir not found")
+
+    return cast(list[dict[str, Any]], _strip_scope(build_wiki_nav(wiki_dir), "wiki"))
+
+
+def load_spec_icon(nav_file: Path) -> dict[str, str] | None:
+    """
+    Load the theme icon mapping from a navigation specification.
+
+    Args:
+        nav_file (Path):
+            Path to the navigation specification file.
+
+    Returns:
+        dict[str, str] | None:
+            The icon mapping, or ``None`` when the specification file is
+            absent or cannot be parsed.
+    """
+    if not nav_file.exists():
+        return None
+
+    try:
+        return load_nav_spec(nav_file).icon
+    except (ValueError, yaml.YAMLError):
+        return None
+
+
+def _strip_scope(value: object, scope: str) -> object:
+    """
+    Re-root navigation paths by removing a leading scope component.
+
+    The navigation block is walked recursively and every relative path
+    string that starts with ``{scope}/`` has that prefix removed, so a lib
+    or wiki site scoped to its own ``docs_dir`` can reuse paths that were
+    originally written relative to the shared documentation root.
+
+    Args:
+        value (object):
+            Navigation block, group list, path string, or scalar value.
+        scope (str):
+            Leading path component to strip, for example ``lib`` or ``wiki``.
+
+    Returns:
+        object:
+            The navigation structure with re-rooted paths.
+    """
+    if isinstance(value, str):
+        prefix = f"{scope}/"
+        return value[len(prefix) :] if value.startswith(prefix) else value
+    if isinstance(value, list):
+        return [_strip_scope(item, scope) for item in value]
+    if isinstance(value, dict):
+        return {key: _strip_scope(val, scope) for key, val in value.items()}
+    return value
+
+
+def generate_site_config(
+    kind: str,
+    kind_root: Path,
+    nav_block: list[dict[str, Any]],
+    out: Path,
+    site_name: str,
+    docs_dir: str,
+    site_dir: str,
+    template: Path | None = None,
+    site_description: str | None = None,
+    site_author: str | None = None,
+    theme_icon: dict[str, str] | None = None,
+) -> None:
+    """
+    Generate a per-kind `mkdocs.{kind}.yml` configuration file.
+
+    The configuration is created by merging the shared ``mkdocs.common.yml``
+    template with the fragment contributed by the kind (``lib``, ``api``, or
+    ``wiki``). Both ``docs_dir`` and ``site_dir`` are written relative to the
+    configuration file's directory: the kind's sources when expressed as a
+    sibling path (for example ``lib``) and the per-kind site output (for
+    example ``../site/lib``).
+
+    Args:
+        kind (str):
+            Documentation kind, one of ``lib``, ``api``, or ``wiki``.
+
+        kind_root (Path):
+            Directory scoped to the kind (for example ``docs/lib``) that
+            serves as the MkDocs ``docs_dir``.
+
+        nav_block (list[dict[str, Any]]):
+            Re-rooted navigation entries for the kind's site.
+
+        out (Path):
+            Destination path where the generated ``mkdocs.{kind}.yml`` file
+            is written.
+
+        site_name (str):
+            Display name for the generated documentation site.
+
+        docs_dir (str):
+            MkDocs ``docs_dir`` value, relative to the configuration
+            file's directory.
+
+        site_dir (str):
+            MkDocs ``site_dir`` value, relative to the configuration
+            file's directory.
+
+        template (Path | None):
+            Optional path to a fully custom MkDocs configuration template
+            that replaces the built-in templates entirely.
+
+        site_description (str | None):
+            Optional site description written into the configuration.
+
+        site_author (str | None):
+            Optional site author written into the configuration.
+
+        theme_icon (dict[str, str] | None):
+            Optional mapping of theme icon entries injected as
+            ``theme.icon``.
+    """
+    data = _load_template(template, [kind])
+
+    data["site_name"] = site_name
+    if site_description:
+        data["site_description"] = site_description
+    if site_author:
+        data["site_author"] = site_author
+    data["docs_dir"] = docs_dir
+    data["site_dir"] = site_dir
+    data["nav"] = nav_block
+
+    if theme_icon:
+        theme = data.setdefault("theme", {})
+        if not isinstance(theme, dict):
+            theme = {}
+        theme["icon"] = theme_icon
+        data["theme"] = theme
+
+    out.write_text(yaml.safe_dump(data, sort_keys=False), encoding="utf-8")
+
+
+def _load_template(
+    template: Path | None,
+    modes: Iterable[str] | None,
+) -> dict:
+    """
+    Load the MkDocs configuration template.
+
+    When a custom template path is provided, it is used as-is. Otherwise the
+    shared ``mkdocs.common.yml`` template is deep-merged with the fragments
+    contributed by each enabled mode (``lib``, ``api``, or ``wiki``).
+
+    Args:
+        template (Path | None):
+            Optional fully custom template that replaces the built-ins.
+
+        modes (Iterable[str] | None):
+            Documentation modes whose template fragments should be merged.
+
+    Returns:
+        dict:
+            Merged MkDocs configuration mapping.
+
+    Raises:
+        click.FileError:
+            If a referenced template file cannot be found.
+    """
+    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"))
+
+    data: dict = {}
+    active_modes = list(modes) if modes else ["lib"]
+    parts = ["common", *active_modes]
+
+    seen: set[str] = set()
+    for part_name in parts:
+        if part_name in seen:
+            continue
+        seen.add(part_name)
+
+        text = (
+            resources.files("docforge.templates")
+            .joinpath(f"mkdocs.{part_name}.yml")
+            .read_text(encoding="utf-8")
+        )
+        part: dict = yaml.safe_load(text)
+        data = _deep_merge(data, part)
+
+    return data
+
+
+def _item_name(item: object) -> str:
+    """
+    Return the identifying name of a list entry.
+
+    String entries identify as themselves; mapping entries identify by their
+    first key. This is used to deduplicate plugin and extension lists.
+
+    Args:
+        item (object):
+            List entry, either a string or a single-key mapping.
+
+    Returns:
+        str:
+            The identifying name of the entry.
+    """
+    if isinstance(item, dict):
+        return next(iter(item.keys()), "")
+    return str(item)
+
+
+def _merge_list(base: list, added: list) -> list:
+    """
+    Merge two lists, preserving order and dropping duplicates by name.
+
+    Args:
+        base (list):
+            Existing list entries.
+        added (list):
+            Entries to append when not already present.
+
+    Returns:
+        list:
+            Merged list with duplicates removed.
+    """
+    result = list(base)
+    names = {_item_name(item) for item in result}
+    for item in added:
+        name = _item_name(item)
+        if name not in names:
+            result.append(item)
+            names.add(name)
+    return result
+
+
+def _deep_merge(base: dict, part: dict) -> dict:
+    """
+    Deep merge a template fragment into a base configuration.
+
+    Mappings are merged recursively, while lists are combined by
+    deduplicating entries by their identifying name. Non-container values in
+    the fragment override the base.
+
+    Args:
+        base (dict):
+            Configuration being built up.
+        part (dict):
+            Template fragment to merge into the base.
+
+    Returns:
+        dict:
+            The merged configuration.
+    """
+    for key, value in part.items():
+        if isinstance(value, dict) and isinstance(base.get(key), dict):
+            base[key] = _deep_merge(base[key], value)
+        elif isinstance(value, list) and isinstance(base.get(key), list):
+            base[key] = _merge_list(base[key], value)
+        else:
+            base[key] = value
+    return base
+
+
+def build_configs(yml_paths: Iterable[Path]) -> None:
+    """
+    Build the MkDocs documentation site for every given configuration.
+
+    Each configuration file is loaded and built in turn, producing the
+    per-kind static sites (``site/lib``, ``site/api``, ``site/wiki``).
+
+    Args:
+        yml_paths (Iterable[Path]):
+            Configuration files to build, in order.
+
+    Raises:
+        click.ClickException:
+            If a configuration file does not exist.
+    """
+    from mkdocs.commands.build import build as mkdocs_build
+    from mkdocs.config import load_config
+
+    for yml in yml_paths:
+        if not yml.exists():
+            raise click.ClickException(f"mkdocs.yml not found: {yml}")
+        mkdocs_build(load_config(str(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,33 @@
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+def generate_sources(
+    module: str,
+    docs_dir: Path,
+    project_name: str | None = None,
+    module_is_source: bool | None = None,
+    readme_dir: Path | None = None,
+) -> None: ...
+def build_lib_nav(
+    nav_file: Path,
+    docs_root: Path,
+) -> tuple[list[dict[str, Any]], dict[str, str] | None]: ...
+def build_wiki_nav_block(wiki_dir: Path) -> list[dict[str, Any]]: ...
+def load_spec_icon(nav_file: Path) -> dict[str, str] | None: ...
+def _strip_scope(value: object, scope: str) -> object: ...
+def generate_site_config(
+    kind: str,
+    kind_root: Path,
+    nav_block: list[dict[str, Any]],
+    out: Path,
+    site_name: str,
+    docs_dir: str,
+    site_dir: str,
+    template: Path | None = None,
+    site_description: str | None = None,
+    site_author: str | None = None,
+    theme_icon: dict[str, str] | None = None,
+) -> None: ...
+def build_configs(yml_paths: Iterable[Path]) -> None: ...
+def serve(mkdocs_yml: Path) -> None: ...

docforge/loader/__init__.py

@@ -1,22 +0,0 @@
-"""
-# Loader Layer
-
-The `docforge.loader` package is responsible for discovering Python source files
-and extracting their documentation using static analysis.
-
-## Core Features
-
-- **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.
-"""
-
-from .griffe_loader import GriffeLoader, discover_module_paths
-
-__all__ = [
-    "GriffeLoader",
-    "discover_module_paths",
-]

docforge/loader/griffe_loader.py

@@ -1,188 +0,0 @@
-"""
-This module provides the GriffeLoader, which uses the 'griffe' library to
-introspect Python source code and populate the doc-forge Project model.
-"""
-
-import logging
-from pathlib import Path
-from typing import List, Optional
-
-from griffe import (
-    GriffeLoader as _GriffeLoader,
-    ModulesCollection,
-    LinesCollection,
-    Object,
-    AliasResolutionError,
-)
-
-from docforge.model import Module, Project, DocObject
-
-logger = logging.getLogger(__name__)
-
-
-def discover_module_paths(
-    module_name: str,
-    project_root: Path | None = None,
-) -> List[str]:
-    """
-    Discover all Python modules under a package via filesystem traversal.
-
-    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.
-
-    Args:
-        module_name: The name of the package to discover.
-        project_root: The root directory of the project. Defaults to current working directory.
-
-    Returns:
-        A sorted list of dotted module paths.
-    """
-
-    if project_root is None:
-        project_root = Path.cwd()
-
-    pkg_dir = project_root / module_name
-    if not pkg_dir.exists():
-        raise FileNotFoundError(f"Package not found: {pkg_dir}")
-
-    module_paths: List[str] = []
-
-    for path in pkg_dir.rglob("*.py"):
-        if path.name == "__init__.py":
-            module_path = path.parent
-        else:
-            module_path = path
-
-        rel = module_path.relative_to(project_root)
-        dotted = ".".join(rel.with_suffix("").parts)
-        module_paths.append(dotted)
-
-    return sorted(set(module_paths))
-
-
-class GriffeLoader:
-    """
-    Loads Python modules and extracts documentation using the Griffe introspection engine.
-    """
-
-    def __init__(self) -> None:
-        """
-        Initialize the GriffeLoader.
-        """
-        self._loader = _GriffeLoader(
-            modules_collection=ModulesCollection(),
-            lines_collection=LinesCollection(),
-        )
-
-    def load_project(
-        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 model.
-
-        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.
-
-        Returns:
-            A Project instance containing the loaded modules.
-        """
-        if not module_paths:
-            raise ValueError("At least one module path must be provided")
-
-        if project_name is None:
-            project_name = module_paths[0].split(".")[0]
-
-        project = Project(name=project_name)
-
-        for module_path in module_paths:
-            try:
-                module = self.load_module(module_path)
-            except ImportError as import_error:
-                if skip_import_errors:
-                    logger.debug("Could not load %s: %s", module_path, import_error)
-                    continue
-                else:
-                    raise import_error
-            project.add_module(module)
-
-        return project
-
-    def load_module(self, path: str) -> Module:
-        """
-        Load a single module and convert its introspection data into the docforge model.
-
-        Args:
-            path: The dotted path of the module to load.
-
-        Returns:
-            A Module instance.
-        """
-        self._loader.load(path)
-        griffe_module = self._loader.modules_collection[path]
-
-        return self._convert_module(griffe_module)
-
-    # -------------------------
-    # Conversion helpers
-    # -------------------------
-
-    def _convert_module(self, obj: Object) -> Module:
-        module = Module(
-            path=obj.path,
-            docstring=self._safe_docstring(obj),
-        )
-
-        for name, member in obj.members.items():
-            if name.startswith("_"):
-                continue
-
-            module.add_object(self._convert_object(member))
-
-        return module
-
-    def _convert_object(self, obj: Object) -> DocObject:
-        kind = obj.kind.value
-        signature = self._safe_signature(obj)
-
-        doc_obj = DocObject(
-            name=obj.name,
-            kind=kind,
-            path=obj.path,
-            signature=signature,
-            docstring=self._safe_docstring(obj),
-        )
-
-        try:
-            for name, member in obj.members.items():
-                if name.startswith("_"):
-                    continue
-                doc_obj.add_member(self._convert_object(member))
-        except AliasResolutionError:
-            pass
-
-        return doc_obj
-
-    # -------------------------
-    # Safe extractors
-    # -------------------------
-
-    def _safe_docstring(self, obj: Object) -> Optional[str]:
-        try:
-            return obj.docstring.value if obj.docstring else None
-        except AliasResolutionError:
-            return None
-
-    def _safe_signature(self, obj: Object) -> Optional[str]:
-        try:
-            if hasattr(obj, "signature") and obj.signature:
-                return str(obj.signature)
-        except AliasResolutionError:
-            return None
-        return None

docforge/loaders/__init__.py

@@ -0,0 +1,33 @@
+"""
+# Summary
+
+Loader layer for doc-forge.
+
+The `docforge.loaders` package is responsible for discovering Python modules
+and extracting documentation data using static analysis.
+
+---
+
+# 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
+
+__all__ = [
+    "GriffeLoader",
+    "discover_module_paths",
+]

docforge/loaders/griffe_loader.py

@@ -0,0 +1,357 @@
+"""
+# 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.
+
+---
+
+Notes:
+    - All analysis is static; analyzed modules are never executed.
+    - Private members (names starting with `_`) are skipped during conversion.
+    - Imported aliases that cannot be resolved (stdlib/third-party names) are
+      skipped; aliases that resolve within the documented project are kept.
+
+---
+"""
+
+import logging
+from pathlib import Path
+
+from griffe import (
+    AliasResolutionError,
+    LinesCollection,
+    ModulesCollection,
+    Object,
+)
+from griffe import (
+    GriffeLoader as _GriffeLoader,
+)
+
+from docforge.models import DocObject, Module, Project
+
+logger = logging.getLogger(__name__)
+
+
+def discover_module_paths(
+    module_name: str,
+    project_root: Path | None = None,
+) -> list[str]:
+    """
+    Discover Python modules within a package directory.
+
+    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 (str):
+            Top-level package name to discover modules from.
+
+        project_root (Path | None):
+            Root directory used to resolve module paths. If not provided, the
+            current working directory is used.
+
+    Returns:
+        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:
+        project_root = Path.cwd()
+
+    pkg_dir = project_root / module_name
+    if not pkg_dir.exists():
+        raise FileNotFoundError(f"Package not found: {pkg_dir}")
+
+    module_paths: list[str] = []
+
+    for path in pkg_dir.rglob("*.py"):
+        if path.name == "__init__.py":
+            module_path = path.parent
+        else:
+            module_path = path
+
+        rel = module_path.relative_to(project_root)
+        dotted = ".".join(rel.with_suffix("").parts)
+        module_paths.append(dotted)
+
+    return sorted(set(module_paths))
+
+
+class GriffeLoader:
+    """
+    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.
+
+    Attributes:
+        _loader (_GriffeLoader):
+            Internal Griffe loader with dedicated module and line collections.
+    """
+
+    def __init__(self) -> None:
+        """
+        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(),
+            lines_collection=LinesCollection(),
+        )
+
+    def load_project(
+        self,
+        module_paths: list[str],
+        project_name: str | None = None,
+        skip_import_errors: bool | None = None,
+    ) -> Project:
+        """
+        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 (list[str]):
+                List of dotted module import paths to load.
+
+            project_name (str | None):
+                Optional override for the project name. Defaults to the top-level
+                name of the first module.
+
+            skip_import_errors (bool | None):
+                If True, modules that fail to load will be skipped instead of raising an error.
+
+        Returns:
+            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")
+
+        if project_name is None:
+            project_name = module_paths[0].split(".")[0]
+
+        project = Project(name=project_name)
+
+        for module_path in module_paths:
+            try:
+                module = self.load_module(module_path)
+            except ImportError as import_error:
+                if skip_import_errors:
+                    logger.debug("Could not load %s: %s", module_path, import_error)
+                    continue
+                else:
+                    raise import_error
+            project.add_module(module)
+
+        return project
+
+    def load_module(self, path: str) -> Module:
+        """
+        Load and convert a single Python module.
+
+        The module is introspected using Griffe and then transformed into
+        a doc-forge `Module` model.
+
+        Args:
+            path (str):
+                Dotted import path of the module.
+
+        Returns:
+            Module:
+                A populated `Module` instance.
+
+        Raises:
+            ImportError:
+                If the module cannot be loaded by Griffe.
+
+            KeyError:
+                If the loaded module is missing from the module collection.
+
+        Example:
+            Load a single module:
+
+                ```python
+                loader = GriffeLoader()
+                module = loader.load_module("mypackage.submodule")
+                ```
+        """
+        self._loader.load(path)
+        griffe_module = self._loader.modules_collection[path]
+
+        return self._convert_module(griffe_module)
+
+    # -------------------------
+    # Conversion helpers
+    # -------------------------
+
+    def _convert_module(self, obj: Object) -> 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 (Object):
+                Griffe object representing the module.
+
+        Returns:
+            Module:
+                A populated `Module` model.
+        """
+        module = Module(
+            path=obj.path,
+            docstring=self._safe_docstring(obj),
+        )
+
+        for name, member in obj.members.items():
+            if name.startswith("_"):
+                continue
+            if not self._is_resolvable_alias(member):
+                continue
+
+            module.add_object(self._convert_object(member))
+
+        return module
+
+    def _convert_object(self, obj: Object) -> DocObject:
+        """
+        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 (Object):
+                Griffe object representing a documented Python object.
+
+        Returns:
+            DocObject:
+                A `DocObject` instance representing the converted object.
+        """
+        kind = obj.kind.value
+        signature = self._safe_signature(obj)
+
+        doc_obj = DocObject(
+            name=obj.name,
+            kind=kind,
+            path=obj.path,
+            signature=signature,
+            docstring=self._safe_docstring(obj),
+        )
+
+        try:
+            for name, member in obj.members.items():
+                if name.startswith("_"):
+                    continue
+                if not self._is_resolvable_alias(member):
+                    continue
+                doc_obj.add_member(self._convert_object(member))
+        except AliasResolutionError:
+            pass
+
+        return doc_obj
+
+    # -------------------------
+    # Safe extractors
+    # -------------------------
+
+    def _safe_docstring(self, obj: Object) -> str | None:
+        """
+        Safely extract a docstring from a Griffe object.
+
+        Args:
+            obj (Object):
+                Griffe object to inspect.
+
+        Returns:
+            str | None:
+                The raw docstring text if available, otherwise `None`.
+        """
+        try:
+            return obj.docstring.value if obj.docstring else None
+        except AliasResolutionError:
+            return None
+
+    def _safe_signature(self, obj: Object) -> str | None:
+        """
+        Safely extract the signature of a Griffe object.
+
+        Griffe exposes signatures as callables (``Object.signature``); the
+        method is invoked and stringified to produce a clean, stable signature.
+        Aliases that point outside the loaded project fail resolution and are
+        reported as `None`.
+
+        Args:
+            obj (Object):
+                Griffe object to inspect.
+
+        Returns:
+            str | None:
+                Clean string representation of the object's signature if
+                available, otherwise `None`.
+        """
+        try:
+            signature = getattr(obj, "signature", None)
+            if signature is None:
+                return None
+            if callable(signature):
+                signature = signature()
+            if not signature:
+                return None
+            return str(signature).strip() or None
+        except Exception:
+            return None
+
+    def _is_resolvable_alias(self, obj: Object) -> bool:
+        """
+        Report whether an object is a resolvable part of the documented API.
+
+        Aliases that cannot be resolved (stdlib or third-party imports) are
+        treated as noise and excluded from the model. Non-alias objects are
+        always resolvable.
+
+        Args:
+            obj (Object):
+                Griffe object to test.
+
+        Returns:
+            bool:
+                True if the object should be kept, False if it is an
+                unresolvable alias.
+        """
+        if obj.kind.value != "alias":
+            return True
+        try:
+            _ = obj.canonical_path
+        except AliasResolutionError:
+            return False
+        return True

docforge/loaders/griffe_loader.pyi

@@ -1,29 +1,25 @@
-from typing import List, Optional
 from pathlib import Path
 
-from docforge.model import Module, Project
-
+from docforge.models import Module, Project
 
 def discover_module_paths(
     module_name: str,
     project_root: Path | None = None,
-) -> List[str]:
-    ...
-
+) -> list[str]: ...
 
 class GriffeLoader:
-    """Griffe-based introspection loader.
+    """Griffe-based introspection loaders.
 
     This is the only supported introspection backend in doc-forge.
+    Converts Griffe results into `Project`, `Module`, and `DocObject` models.
     """
 
     def __init__(self) -> None: ...
-
     def load_project(
         self,
-        module_paths: List[str],
-        project_name: Optional[str] = ...,
-        skip_import_errors: bool = ...,
+        module_paths: list[str],
+        project_name: str | None = ...,
+        skip_import_errors: bool | None = ...,
     ) -> Project:
         """Load a documentation project from Python modules."""
 

docforge/mkdocs_links.py

@@ -0,0 +1,72 @@
+"""
+# Summary
+
+MkDocs plugin that fixes cross-kind relative links in generated wikis.
+
+A repository served under ``/<repo>/<kind>/`` (for example a wiki at
+``/myrepo/wiki/`` and a library reference at ``/myrepo/lib/``) is built as
+two independent MkDocs sites. Authors naturally write links between them
+using source-relative paths such as ``../lib/01_build_recipe/``.
+
+MkDocs only rewrites links whose target lives inside ``docs_dir``; anything
+pointing at a sibling site is emitted verbatim. When ``use_directory_urls``
+is enabled (the default) the rendered page sits one or more directory levels
+deeper than its source, so ``../lib/`` resolves to ``/<repo>/wiki/lib/`` and
+breaks.
+
+`docforge-linkfix` rewrites such links at render time, prefixing them with
+enough ``../`` segments to climb back to the repository root so they resolve
+to ``/<repo>/<kind>/`` regardless of how deeply the page is nested.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from mkdocs.plugins import BasePlugin
+
+if TYPE_CHECKING:
+    from mkdocs.config.defaults import MkDocsConfig
+    from mkdocs.structure.files import Files
+    from mkdocs.structure.pages import Page
+
+__all__ = ["LinkFixPlugin"]
+
+_CROSS_KIND_LINK = re.compile(r"\]\((?:\.\./)+(lib|api|wiki)/")
+"""Matches a Markdown link whose target climbs out of the current doc kind."""
+
+
+class LinkFixPlugin(BasePlugin):  # type: ignore[no-untyped-call, type-arg]
+    """
+    Rewrite cross-kind relative links so they survive directory URLs.
+    """
+
+    def on_page_markdown(
+        self,
+        markdown: str,
+        /,
+        *,
+        page: Page,
+        config: MkDocsConfig,
+        files: Files,
+    ) -> str:
+        """
+        Prefix cross-kind links with the depth required to reach the repo root.
+
+        Args:
+            markdown (str): The raw Markdown source of the current page.
+            page (Page): The page being rendered; its destination URI is used
+                to determine how many directory levels the output sits below
+                the site root.
+            config (MkDocsConfig): The active MkDocs configuration.
+            files (Files): The collection of files in the site.
+
+        Returns:
+            str: The Markdown with cross-kind links rebased to the repo root.
+        """
+        depth = page.file.dest_uri.count("/")
+        prefix = "../" * (depth + 1)
+        return _CROSS_KIND_LINK.sub(
+            lambda match: f"]({prefix}{match.group(1)}/", markdown
+        )

docforge/model/__init__.py

@@ -1,25 +0,0 @@
-"""
-# Model Layer
-
-The `docforge.model` package provides the core data structures used to represent
-Python source code in a documentation-focused hierarchy.
-
-## Key Components
-
-- **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).
-"""
-
-from .project import Project
-from .module import Module
-from .object import DocObject
-
-__all__ = [
-    "Project",
-    "Module",
-    "DocObject",
-]

docforge/model/module.py

@@ -1,66 +0,0 @@
-"""
-This module defines the Module class, which represents a Python module or package
-in the doc-forge documentation model. It acts as a container for top-level
-documented objects.
-"""
-
-from typing import Dict, Iterable, Optional
-
-from docforge.model.object import DocObject
-
-
-class Module:
-    """
-    Represents a documented Python module or package.
-
-    Attributes:
-        path: Dotted import path of the module.
-        docstring: Module-level docstring content.
-        members: Dictionary mapping object names to their DocObject representations.
-    """
-
-    def __init__(
-        self,
-        path: str,
-        docstring: Optional[str] = None,
-    ) -> None:
-        """
-        Initialize a new Module.
-
-        Args:
-            path: The dotted path of the module.
-            docstring: The module's docstring, if any.
-        """
-        self.path = path
-        self.docstring = docstring
-        self.members: Dict[str, DocObject] = {}
-
-    def add_object(self, obj: DocObject) -> None:
-        """
-        Add a documented object to the module.
-
-        Args:
-            obj: The object to add.
-        """
-        self.members[obj.name] = obj
-
-    def get_object(self, name: str) -> DocObject:
-        """
-        Retrieve a member object by name.
-
-        Args:
-            name: The name of the object.
-
-        Returns:
-            The requested DocObject.
-        """
-        return self.members[name]
-
-    def get_all_objects(self) -> Iterable[DocObject]:
-        """
-        Get all top-level objects in the module.
-
-        Returns:
-            An iterable of DocObject instances.
-        """
-        return self.members.values()

docforge/model/object.py

@@ -1,76 +0,0 @@
-"""
-This module defines the DocObject class, the fundamental recursive unit of the
-doc-forge documentation model. A DocObject represents a single Python entity
-(class, function, method, or attribute) and its nested members.
-"""
-
-from typing import Dict, Iterable, Optional
-
-
-class DocObject:
-    """
-    Represents a documented Python object (class, function, method, etc.).
-
-    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.
-    """
-
-    def __init__(
-        self,
-        name: str,
-        kind: str,
-        path: str,
-        signature: Optional[str] = None,
-        docstring: Optional[str] = None,
-    ) -> None:
-        """
-        Initialize a new DocObject.
-
-        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.
-        """
-        self.name = name
-        self.kind = kind
-        self.path = path
-        self.signature = signature
-        self.docstring = docstring
-        self.members: Dict[str, 'DocObject'] = {}
-
-    def add_member(self, obj: 'DocObject') -> None:
-        """
-        Add a child member to this object (e.g., a method to a class).
-
-        Args:
-            obj: The child DocObject to add.
-        """
-        self.members[obj.name] = obj
-
-    def get_member(self, name: str) -> 'DocObject':
-        """
-        Retrieve a child member by name.
-
-        Args:
-            name: The name of the member.
-
-        Returns:
-            The requested DocObject.
-        """
-        return self.members[name]
-
-    def get_all_members(self) -> Iterable['DocObject']:
-        """
-        Get all members of this object.
-
-        Returns:
-            An iterable of child DocObject instances.
-        """
-        return self.members.values()

docforge/model/object.pyi

@@ -1,27 +0,0 @@
-from typing import Dict, Iterable, Optional
-
-
-class DocObject:
-    """Represents a documented Python object."""
-
-    name: str
-    kind: str
-    path: str
-    signature: Optional[str]
-    docstring: Optional[str]
-    members: Dict[str, "DocObject"]
-
-    def __init__(
-        self,
-        name: str,
-        kind: str,
-        path: str,
-        signature: Optional[str] = ...,
-        docstring: Optional[str] = ...,
-    ) -> None: ...
-
-    def add_member(self, obj: "DocObject") -> None: ...
-
-    def get_member(self, name: str) -> "DocObject": ...
-
-    def get_all_members(self) -> Iterable["DocObject"]: ...

docforge/model/project.py

@@ -1,67 +0,0 @@
-"""
-This module defines the Project class, the top-level container for a documented
-project. It aggregates multiple Module instances into a single named entity.
-"""
-
-from typing import Dict, Iterable
-
-from docforge.model.module import Module
-
-
-class Project:
-    """
-    Represents a documentation project, serving as a container for modules.
-
-    Attributes:
-        name: Name of the project.
-        modules: Dictionary mapping module paths to Module instances.
-    """
-
-    def __init__(self, name: str) -> None:
-        """
-        Initialize a new Project.
-
-        Args:
-            name: The name of the project.
-        """
-        self.name = name
-        self.modules: Dict[str, Module] = {}
-
-    def add_module(self, module: Module) -> None:
-        """
-        Add a module to the project.
-
-        Args:
-            module: The module to add.
-        """
-        self.modules[module.path] = module
-
-    def get_module(self, path: str) -> Module:
-        """
-        Retrieve a module by its dotted path.
-
-        Args:
-            path: The dotted path of the module (e.g., 'pkg.mod').
-
-        Returns:
-            The requested Module.
-        """
-        return self.modules[path]
-
-    def get_all_modules(self) -> Iterable[Module]:
-        """
-        Get all modules in the project.
-
-        Returns:
-            An iterable of Module objects.
-        """
-        return self.modules.values()
-
-    def get_module_list(self) -> list[str]:
-        """
-        Get the list of all module dotted paths.
-
-        Returns:
-            A list of module paths.
-        """
-        return list(self.modules.keys())

docforge/models/__init__.py

@@ -0,0 +1,41 @@
+"""
+# Summary
+
+Model layer for doc-forge.
+
+The `docforge.models` package defines the core data structures used to
+represent Python source code as a structured documentation model.
+
+---
+
+# 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
+from .module import Module
+from .object import DocObject
+
+__all__ = [
+    "Project",
+    "Module",
+    "DocObject",
+]

docforge/models/__init__.pyi

@@ -1,6 +1,6 @@
-from .project import Project
 from .module import Module
 from .object import DocObject
+from .project import Project
 
 __all__ = [
     "Project",

docforge/models/module.py

@@ -0,0 +1,98 @@
+"""
+# 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.
+
+---
+
+Notes:
+    - Only public members are stored; private names are filtered by the loader.
+
+---
+"""
+
+from collections.abc import Iterable
+
+from docforge.models.object import DocObject
+
+
+class Module:
+    """
+    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 (str):
+            Dotted import path of the module.
+
+        docstring (str | None):
+            Module-level documentation string, if present.
+
+        members (dict[str, DocObject]):
+            Mapping of object names to their corresponding `DocObject` representations.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        docstring: str | None = None,
+    ) -> None:
+        """
+        Initialize a Module instance.
+
+        Args:
+            path (str):
+                Dotted import path identifying the module.
+
+            docstring (str | None):
+                Module-level documentation text, if available.
+        """
+        self.path = path
+        self.docstring = docstring
+        self.members: dict[str, DocObject] = {}
+
+    def add_object(self, obj: DocObject) -> None:
+        """
+        Add a documented object to the module.
+
+        Args:
+            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 documented object by name.
+
+        Args:
+            name (str):
+                Name of the object to retrieve.
+
+        Returns:
+            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]:
+        """
+        Return all top-level documentation objects in the module.
+
+        Returns:
+            Iterable[DocObject]:
+                An iterable of `DocObject` instances representing the module's public members.
+        """
+        return self.members.values()

docforge/models/module.pyi

@@ -1,23 +1,19 @@
-from typing import Dict, Iterable, Optional
-
-from docforge.model.object import DocObject
+from collections.abc import Iterable
 
+from docforge.models.object import DocObject
 
 class Module:
     """Represents a documented Python module."""
 
     path: str
-    docstring: Optional[str]
-    members: Dict[str, DocObject]
+    docstring: str | None
+    members: dict[str, DocObject]
 
     def __init__(
         self,
         path: str,
-        docstring: Optional[str] = ...,
+        docstring: str | None = ...,
     ) -> None: ...
-
     def add_object(self, obj: DocObject) -> None: ...
-
     def get_object(self, name: str) -> DocObject: ...
-
     def get_all_objects(self) -> Iterable[DocObject]: ...

docforge/models/object.py

@@ -0,0 +1,124 @@
+"""
+# 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.
+
+---
+
+Notes:
+    - `DocObject` instances form a tree mirroring the Python import hierarchy.
+    - Objects are renderer-agnostic and may be consumed by any renderer.
+
+---
+"""
+
+from collections.abc import Iterable
+
+
+class DocObject:
+    """
+    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 (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 (str | None):
+            Callable signature if the object represents a callable.
+
+        docstring (str | None):
+            Raw docstring text extracted from the source code.
+
+        members (dict[str, DocObject]):
+            Mapping of member names to child `DocObject` instances.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        kind: str,
+        path: str,
+        signature: str | None = None,
+        docstring: str | None = None,
+    ) -> None:
+        """
+        Initialize a DocObject instance.
+
+        Args:
+            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 (str | None):
+                Callable signature if applicable.
+
+            docstring (str | None):
+                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] = {}
+
+    def add_member(self, obj: "DocObject") -> None:
+        """
+        Add a child documentation object.
+
+        This is typically used when attaching methods to classes or
+        nested objects to their parent containers.
+
+        Args:
+            obj (DocObject):
+                Documentation object to add as a member.
+        """
+        self.members[obj.name] = obj
+
+    def get_member(self, name: str) -> "DocObject":
+        """
+        Retrieve a member object by name.
+
+        Args:
+            name (str):
+                Name of the member to retrieve.
+
+        Returns:
+            DocObject:
+                The corresponding `DocObject` instance.
+
+        Raises:
+            KeyError:
+                If the member does not exist.
+        """
+        return self.members[name]
+
+    def get_all_members(self) -> Iterable["DocObject"]:
+        """
+        Return all child members of the object.
+
+        Returns:
+            Iterable[DocObject]:
+                An iterable of `DocObject` instances representing nested members.
+        """
+        return self.members.values()

docforge/models/object.pyi

@@ -0,0 +1,23 @@
+from collections.abc import Iterable
+
+class DocObject:
+    """Represents a documented Python object."""
+
+    name: str
+    kind: str
+    path: str
+    signature: str | None
+    docstring: str | None
+    members: dict[str, DocObject]
+
+    def __init__(
+        self,
+        name: str,
+        kind: str,
+        path: str,
+        signature: str | None = ...,
+        docstring: str | None = ...,
+    ) -> None: ...
+    def add_member(self, obj: DocObject) -> None: ...
+    def get_member(self, name: str) -> DocObject: ...
+    def get_all_members(self) -> Iterable[DocObject]: ...

docforge/models/project.py

@@ -0,0 +1,104 @@
+"""
+# 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.
+
+---
+
+Notes:
+    - Modules are keyed by their dotted import path.
+    - Objects are renderer-agnostic; the same model feeds every renderer.
+
+---
+"""
+
+from collections.abc import Iterable
+
+from docforge.models.module import Module
+
+
+class Project:
+    """
+    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 (str):
+            Name of the project.
+
+        modules (dict[str, Module]):
+            Mapping of module paths to `Module` instances.
+    """
+
+    def __init__(self, name: str) -> None:
+        """
+        Initialize a Project instance.
+
+        Args:
+            name (str):
+                Name used to identify the documentation project.
+
+        Example:
+            Create a project and register a module:
+
+                ```python
+                project = Project("mypackage")
+                project.add_module(module)
+                ```
+        """
+        self.name = name
+        self.modules: dict[str, Module] = {}
+
+    def add_module(self, module: Module) -> None:
+        """
+        Register a module in the project.
+
+        Args:
+            module (Module):
+                Module instance to add to the project.
+        """
+        self.modules[module.path] = module
+
+    def get_module(self, path: str) -> Module:
+        """
+        Retrieve a module by its dotted path.
+
+        Args:
+            path (str):
+                Fully qualified dotted module path (for example `pkg.module`).
+
+        Returns:
+            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]:
+        """
+        Return all modules contained in the project.
+
+        Returns:
+            Iterable[Module]:
+                An iterable of `Module` instances.
+        """
+        return self.modules.values()
+
+    def get_module_list(self) -> list[str]:
+        """
+        Return the list of module import paths.
+
+        Returns:
+            list[str]:
+                A list containing the dotted paths of all modules in the project.
+        """
+        return list(self.modules.keys())

docforge/models/project.pyi

@@ -1,20 +1,15 @@
-from typing import Dict, Iterable
-
-from docforge.model.module import Module
+from collections.abc import Iterable
 
+from docforge.models.module import Module
 
 class Project:
     """Represents a documentation project."""
 
     name: str
-    modules: Dict[str, Module]
+    modules: dict[str, Module]
 
     def __init__(self, name: str) -> None: ...
-
     def add_module(self, module: Module) -> None: ...
-
     def get_module(self, path: str) -> Module: ...
-
     def get_all_modules(self) -> Iterable[Module]: ...
-
     def get_module_list(self) -> list[str]: ...

docforge/nav/__init__.py

@@ -1,27 +1,38 @@
 """
-# 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
 from .resolver import ResolvedNav, resolve_nav
 from .mkdocs import MkDocsNavEmitter
+from .wiki import build_wiki_nav
 
 __all__ = [
     "NavSpec",
     "ResolvedNav",
     "MkDocsNavEmitter",
+    "build_wiki_nav",
     "resolve_nav",
     "load_nav_spec",
 ]

docforge/nav/__init__.pyi

@@ -1,11 +1,13 @@
-from .spec import NavSpec, load_nav_spec
-from .resolver import ResolvedNav, resolve_nav
 from .mkdocs import MkDocsNavEmitter
+from .resolver import ResolvedNav, resolve_nav
+from .spec import NavSpec, load_nav_spec
+from .wiki import build_wiki_nav
 
 __all__ = [
     "NavSpec",
     "ResolvedNav",
     "MkDocsNavEmitter",
+    "build_wiki_nav",
     "resolve_nav",
     "load_nav_spec",
 ]

docforge/nav/mkdocs.py

@@ -1,32 +1,49 @@
 """
-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.
+
+---
+
+Notes:
+    - The emitted structure is a list of dictionaries, one per top-level nav
+      entry, matching the MkDocs ``nav`` YAML format.
+
+---
 """
 
 from pathlib import Path
-from typing import List, Dict, Any
+from typing import Any
 
 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]]:
+    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 (ResolvedNav):
+                Resolved navigation data describing documentation groups
+                and their associated Markdown files.
 
         Returns:
-            A list of dictionary mappings representing the MkDocs navigation.
+            list[dict[str, Any]]:
+                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]] = []
+        result: list[dict[str, Any]] = []
 
         # Home entry (semantic path)
         if nav.home:
@@ -34,7 +51,7 @@ class MkDocsNavEmitter:
 
         # Group entries
         for group, paths in nav.groups.items():
-            entries: List[str] = []
+            entries: list[str] = []
             for p in paths:
                 # Convert filesystem path back to docs-relative path
                 rel_path = self._to_relative(p, nav._docs_root)
@@ -45,16 +62,21 @@ 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 (Path):
+                Filesystem path to convert.
+            docs_root (Path | None):
+                Root directory of the documentation sources.
 
         Returns:
-            A string representing the relative POSIX-style path.
+            str:
+                POSIX-style path relative to the documentation root.
         """
         if docs_root and path.is_absolute():
             try:
@@ -66,7 +88,7 @@ class MkDocsNavEmitter:
             path_str = path.as_posix()
             docs_root_str = docs_root.as_posix()
             if path_str.startswith(docs_root_str + "/"):
-                return path_str[len(docs_root_str) + 1:]
-        
+                return path_str[len(docs_root_str) + 1 :]
+
         # Fallback for other cases
         return path.as_posix().split("/docs/", 1)[-1]

docforge/nav/mkdocs.pyi

@@ -1,15 +1,14 @@
-from typing import Dict, List, Any
 from pathlib import Path
+from typing import Any
 
 from docforge.nav.resolver import ResolvedNav
 
-
 class MkDocsNavEmitter:
     """
     Converts a ResolvedNav into MkDocs-compatible `nav` data.
     """
 
-    def emit(self, nav: ResolvedNav) -> List[Dict[str, Any]]:
+    def emit(self, nav: ResolvedNav) -> list[dict[str, Any]]:
         """
         Emit a structure suitable for insertion into mkdocs.yml.
 

docforge/nav/resolver.py

@@ -1,40 +1,54 @@
 """
-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.
 
-from pathlib import Path
-from typing import Dict, Iterable, List
+This module resolves a ``NavSpec`` against the filesystem by expanding glob
+patterns and validating that referenced documentation files exist.
+
+---
+
+Notes:
+    - Glob resolution is recursive and returns paths in sorted order.
+    - Unmatched patterns raise ``FileNotFoundError`` to fail fast on typos.
+
+---
+"""
 
 import glob
+from collections.abc import Iterable
+from pathlib import Path
 
 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__(
         self,
         home: str | None,
-        groups: Dict[str, List[Path]],
+        groups: dict[str, list[Path]],
         docs_root: Path | None = None,
     ) -> None:
         """
         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 (str | None):
+                Relative path to the home page within the documentation root.
+            groups (dict[str, list[Path]]):
+                Mapping of group titles to resolved documentation file paths.
+            docs_root (Path | None):
+                Root directory of the documentation source files.
         """
         self.home = home
         self.groups = groups
@@ -42,18 +56,24 @@ 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.
+        Yields:
+            Path:
+                A documentation file referenced by the navigation, including
+                the home page when defined.
+
+        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
+            yield from paths
 
 
 def resolve_nav(
@@ -61,34 +81,52 @@ 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 (NavSpec):
+            Navigation specification describing documentation layout.
+        docs_root (Path):
+            Root directory containing documentation Markdown files.
 
     Returns:
-        A ResolvedNav instance.
+        ResolvedNav:
+            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]:
+    def resolve_pattern(pattern: str) -> list[Path]:
+        """
+        Resolve a glob pattern relative to the documentation root.
+
+        Args:
+            pattern (str):
+                Glob pattern used to match documentation files.
+
+        Returns:
+            list[Path]:
+                A sorted list of matching `Path` objects.
+
+        Raises:
+            FileNotFoundError: If the pattern does not match any files.
+        """
         full = docs_root / pattern
-        matches = sorted(
-            Path(p) for p in glob.glob(str(full), recursive=True)
-        )
+        matches = sorted(Path(p) for p in glob.glob(str(full), recursive=True))
 
         if not matches:
             raise FileNotFoundError(pattern)
 
         return matches
 
-    # Resolve home
+    # Resolve home page
     home: str | None = None
     if spec.home:
         home_path = docs_root / spec.home
@@ -96,11 +134,11 @@ def resolve_nav(
             raise FileNotFoundError(spec.home)
         home = spec.home
 
-    # Resolve groups
-    resolved_groups: Dict[str, List[Path]] = {}
+    # Resolve navigation groups
+    resolved_groups: dict[str, list[Path]] = {}
 
     for group, patterns in spec.groups.items():
-        files: List[Path] = []
+        files: list[Path] = []
         for pattern in patterns:
             files.extend(resolve_pattern(pattern))
         resolved_groups[group] = files

docforge/nav/resolver.pyi

@@ -1,9 +1,8 @@
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Dict, List, Iterable, Optional
 
 from docforge.nav.spec import NavSpec
 
-
 class ResolvedNav:
     """
     Fully-resolved navigation tree.
@@ -13,17 +12,16 @@ class ResolvedNav:
     - Order is preserved
     """
 
-    home: Optional[str]
-    groups: Dict[str, List[Path]]
-    _docs_root: Optional[Path]
+    home: str | None
+    groups: dict[str, list[Path]]
+    _docs_root: Path | None
 
     def __init__(
         self,
         home: str | None,
-        groups: Dict[str, List[Path]],
+        groups: dict[str, list[Path]],
         docs_root: Path | None = ...,
     ) -> None: ...
-
     def all_files(self) -> Iterable[Path]:
         """
         Return all resolved documentation files in nav order.
@@ -33,7 +31,6 @@ class ResolvedNav:
         """
         ...
 
-
 def resolve_nav(
     spec: NavSpec,
     docs_root: Path,

docforge/nav/spec.py

@@ -1,53 +1,84 @@
 """
-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``).
+
+---
+
+Notes:
+    - The spec file supports an optional ``icon`` mapping for MkDocs theme
+      customization.
+    - All file references in ``groups`` are relative to the documentation root.
+
+---
 """
 
+from __future__ import annotations
+
 from pathlib import Path
-from typing import Dict, List, Optional
 
 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.
+        icon: Optional mapping of theme icon entries (for example
+            ``{"logo": "material/code-tags"}``) injected into the MkDocs
+            theme as ``theme.icon``.
     """
 
     def __init__(
         self,
-        home: Optional[str],
-        groups: Dict[str, List[str]],
+        home: str | None,
+        groups: dict[str, list[str]],
+        icon: dict[str, str] | None = None,
     ) -> 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 (str | None):
+                Relative path to the home document.
+            groups (dict[str, list[str]]):
+                Mapping of group names to lists of path patterns
+                (glob expressions).
+            icon (dict[str, str] | None):
+                Optional mapping of theme icon entries applied to the
+                generated MkDocs configuration.
         """
         self.home = home
         self.groups = groups
+        self.icon = icon
 
     @classmethod
-    def load(cls, path: Path) -> "NavSpec":
+    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 (Path):
+                Filesystem path to the navigation specification file.
 
         Returns:
-            A NavSpec instance.
+            NavSpec:
+                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)
@@ -59,6 +90,7 @@ class NavSpec:
 
         home = data.get("home")
         groups = data.get("groups", {})
+        icon = data.get("icon")
 
         if home is not None and not isinstance(home, str):
             raise ValueError("home must be a string")
@@ -74,41 +106,65 @@ class NavSpec:
             ):
                 raise ValueError(f"group '{key}' must be a list of strings")
 
-        return cls(home=home, groups=groups)
+        if icon is not None and (
+            not isinstance(icon, dict)
+            or not all(
+                isinstance(k, str) and isinstance(v, str) for k, v in icon.items()
+            )
+        ):
+            raise ValueError("icon must be a mapping of strings")
 
-    def all_patterns(self) -> List[str]:
+        return cls(home=home, groups=groups, icon=icon)
+
+    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).
+            list[str]:
+                A list containing the home document (if defined) and all
+                group pattern entries.
         """
-        patterns: List[str] = []
+        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.
+        path (Path):
+            Path to the navigation specification file.
 
     Returns:
-        A loaded NavSpec instance.
+        NavSpec:
+            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")
 
     return NavSpec(
         home=data.get("home"),
         groups=data.get("groups", {}),
+        icon=data.get("icon"),
     )

docforge/nav/spec.pyi

@@ -1,6 +1,4 @@
 from pathlib import Path
-from typing import Dict, List, Optional
-
 
 class NavSpec:
     """
@@ -10,18 +8,16 @@ class NavSpec:
     of filesystem structure or MkDocs specifics.
     """
 
-    home: Optional[str]
-    groups: Dict[str, List[str]]
+    home: str | None
+    groups: dict[str, list[str]]
 
     def __init__(
         self,
-        home: Optional[str],
-        groups: Dict[str, List[str]],
-    ) -> None:
-        ...
-
+        home: str | None,
+        groups: dict[str, list[str]],
+    ) -> None: ...
     @classmethod
-    def load(cls, path: Path) -> "NavSpec":
+    def load(cls, path: Path) -> NavSpec:
         """
         Load and validate a nav specification from YAML.
 
@@ -31,12 +27,11 @@ class NavSpec:
         """
         ...
 
-    def all_patterns(self) -> List[str]:
+    def all_patterns(self) -> list[str]:
         """
         Return all path patterns referenced by the spec
         (including home and group entries).
         """
         ...
 
-
 def load_nav_spec(path: Path) -> NavSpec: ...

docforge/nav/wiki.py

@@ -0,0 +1,165 @@
+"""
+# Summary
+
+Wiki navigation derivation.
+
+This module provides ``build_wiki_nav``, which derives an MkDocs-ready
+navigation block from the file structure of a hand-written wiki directory
+(typically ``docs/wiki``). wiki content is authored by hand and is never
+modified by doc-forge; only the navigation layout is inferred.
+
+# Notes
+
+- ``index.md`` at the wiki root becomes the ``Home`` entry.
+- Page labels are derived from filenames: numeric order prefixes such as
+  ``01_`` or ``02-`` are stripped, separators are replaced with spaces, and
+  names are title-cased (``01_overview.md`` becomes ``Overview``).
+- Subdirectories become nested navigation groups. A nested ``index.md`` is
+  rendered as the section root placed first inside the group.
+- Only ``.md`` files are considered; hidden entries are ignored.
+"""
+
+import re
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+
+def build_wiki_nav(wiki_dir: Path) -> list[dict[str, Any]]:
+    """
+    Derive an MkDocs navigation block from a wiki directory.
+
+    Returned paths are relative to the parent of ``wiki_dir`` and carry the
+    wiki directory name as their leading component (for example
+    ``wiki/01_overview.md`` when the wiki lives at ``docs/wiki``). This makes
+    the result directly usable in an MkDocs ``nav`` block with
+
+    - ``index.md`` at the wiki root becomes the ``Home`` entry.
+    - Page labels are derived from filenames: numeric order prefixes such as
+      ``01_`` or ``02-`` are stripped, separators are replaced with spaces, and
+      names are title-cased (``01_overview.md`` becomes ``Overview``).
+    - Subdirectories become nested navigation groups. A nested ``index.md`` is
+      rendered as the section root placed first inside the group.
+    - Only ``.md`` files are considered; hidden entries are ignored.
+
+    Args:
+        wiki_dir (Path):
+            Path to the hand-written wiki directory, for example ``docs/wiki``.
+
+    Returns:
+        list[dict[str, Any]]:
+            Navigation entries compatible with the MkDocs ``nav`` configuration.
+            The list is empty if the wiki contains no Markdown files.
+
+    Raises:
+        FileNotFoundError:
+            If the wiki directory does not exist.
+    """
+    if not wiki_dir.exists():
+        raise FileNotFoundError(wiki_dir)
+
+    root = wiki_dir.parent
+
+    def rel(path: Path) -> str:
+        try:
+            return path.relative_to(root).as_posix()
+        except ValueError:
+            return path.as_posix()
+
+    nav: list[dict[str, Any]] = []
+
+    if (wiki_dir / "index.md").exists():
+        nav.append({"Home": rel(wiki_dir / "index.md")})
+
+    nav.extend(_render_entries(wiki_dir, rel))
+
+    return nav
+
+
+def _render_entries(
+    base_dir: Path,
+    rel: Callable[[Path], str],
+) -> list[dict[str, Any]]:
+    """
+    Render navigation entries for the children of a wiki directory.
+
+    Markdown pages become labeled entries, subdirectories containing
+    Markdown become nested groups, and a nested ``index.md`` is emitted
+    first as the section root.
+
+    Args:
+        base_dir (Path):
+            Directory whose children are rendered.
+
+        rel (Callable[[Path], str]):
+            Callable converting a wiki file path into a docs-relative path.
+
+    Returns:
+        list[dict[str, Any]]:
+            Navigation entries for ``base_dir`` in natural sort order.
+    """
+    children = sorted(
+        (child for child in base_dir.iterdir() if not child.name.startswith(".")),
+        key=lambda child: _natural_key(child.name),
+    )
+
+    entries: list[dict[str, Any]] = []
+
+    for child in children:
+        if child.is_dir():
+            if not any(child.rglob("*.md")):
+                continue
+
+            group: list[dict[str, Any]] = []
+            nested_index = child / "index.md"
+            if nested_index.exists():
+                group.append({_prettify(child.name): rel(nested_index)})
+            group.extend(_render_entries(child, rel))
+            entries.append({_prettify(child.name): group})
+        elif child.suffix == ".md":
+            if child.name == "index.md":
+                continue
+            entries.append({_prettify(child.stem): rel(child)})
+
+    return entries
+
+
+def _prettify(name: str) -> str:
+    """
+    Convert a filename or directory name into a navigation label.
+
+    Numeric order prefixes (``01_``, ``02-``, ``03.``) are stripped,
+    separators are replaced with spaces, and the result is title-cased.
+
+    Args:
+        name (str):
+            Filename stem or directory name to prettify.
+
+    Returns:
+        str:
+            Title-cased navigation label.
+    """
+    name = re.sub(r"^\d+[_\-. ]?", "", name)
+    name = re.sub(r"[_-]+", " ", name).strip()
+    return name.title()
+
+
+def _natural_key(name: str) -> list[object]:
+    """
+    Build a natural sort key from a filename.
+
+    The key splits ``name`` into alternating non-digit and digit parts so
+    that numeric prefixes sort numerically (``02`` before ``10``).
+
+    Args:
+        name (str):
+            Filename or directory name to key.
+
+    Returns:
+        list[object]:
+            Mixed list of lowercased strings and integers used for sorting.
+    """
+    return [
+        int(part) if part.isdigit() else part.lower()
+        for part in re.split(r"(\d+)", name)
+    ]

docforge/nav/wiki.pyi

@@ -0,0 +1,41 @@
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+def build_wiki_nav(wiki_dir: Path) -> list[dict[str, Any]]:
+    """
+    Derive an MkDocs navigation block from a wiki directory.
+
+    Args:
+        wiki_dir (Path):
+            Path to the hand-written wiki directory.
+
+    Returns:
+        list[dict[str, Any]]:
+            Wiki navigation entries compatible with the MkDocs `nav`
+            configuration.
+
+    Raises:
+        FileNotFoundError:
+            If the wiki directory does not exist.
+    """
+    ...
+
+def _render_entries(
+    base_dir: Path,
+    rel: Callable[[Path], str],
+) -> list[dict[str, Any]]:
+    """
+    Render navigation entries for the children of a wiki directory.
+
+    Args:
+        base_dir (Path):
+            Directory whose children are rendered.
+        rel (Callable[[Path], str]):
+            Callable converting a wiki file path into a docs-relative path.
+
+    Returns:
+        list[dict[str, Any]]:
+            Navigation entries for `base_dir` in natural sort order.
+    """
+    ...

docforge/renderers/__init__.py

@@ -1,24 +1,40 @@
 """
-# Renderers Layer
+# Summary
 
-The `docforge.renderers` package handles the transformation of the internal
-documentation model 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 import MkDocsRenderer
+from .mkdocs_renderer import MkDocsRenderer
+from .mcp_renderer import MCPRenderer
 
 __all__ = [
     "MkDocsRenderer",
+    "MCPRenderer",
 ]

docforge/renderers/__init__.pyi

@@ -1,5 +1,7 @@
-from .mkdocs import MkDocsRenderer
+from .mcp_renderer import MCPRenderer
+from .mkdocs_renderer import MkDocsRenderer
 
 __all__ = [
     "MkDocsRenderer",
+    "MCPRenderer",
 ]

docforge/renderers/base.py

@@ -1,25 +1,45 @@
 """
-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
 from typing import Protocol
 
-from docforge.model import Project
+from docforge.models import Project
 
 
 class RendererConfig:
     """
     Configuration container for documentation renderers.
 
-    Args:
-        out_dir: The directory where documentation files should be written.
-        project: The introspected project model 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 model 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/base.pyi

@@ -1,8 +1,7 @@
 from pathlib import Path
 from typing import Protocol
 
-from docforge.model import Project
-
+from docforge.models import Project
 
 class RendererConfig:
     """Renderer configuration container."""
@@ -12,7 +11,6 @@ class RendererConfig:
 
     def __init__(self, out_dir: Path, project: Project) -> None: ...
 
-
 class DocRenderer(Protocol):
     """Renderer interface."""
 

docforge/renderers/mcp_renderer.py

@@ -0,0 +1,159 @@
+"""
+# 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 docforge.models import DocObject, Module, Project
+
+
+class MCPRenderer:
+    """
+    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 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)
+
+        nav: list[dict[str, str]] = []
+
+        for module in project.get_all_modules():
+            self._write_module(module, modules_dir)
+
+            nav.append(
+                {
+                    "module": module.path,
+                    "resource": f"docs://modules/{module.path}",
+                }
+            )
+
+        # Write nav.json
+        (out_dir / "nav.json").write_text(
+            self._json(nav),
+            encoding="utf-8",
+        )
+
+        # Write index.json
+        index = {
+            "project": project.name,
+            "type": "docforge-model",
+            "modules_count": len(nav),
+            "source": "docforge",
+        }
+
+        (out_dir / "index.json").write_text(
+            self._json(index),
+            encoding="utf-8",
+        )
+
+    def _write_module(self, module: Module, modules_dir: Path) -> None:
+        """
+        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,
+            "content": self._render_module(module),
+        }
+
+        out = modules_dir / f"{module.path}.json"
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(self._json(payload), encoding="utf-8")
+
+    def _render_module(self, module: Module) -> dict:
+        """
+        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,
+            "docstring": module.docstring,
+            "objects": {},
+        }
+
+        for obj in module.get_all_objects():
+            data["objects"][obj.name] = self._render_object(obj)
+
+        return data
+
+    def _render_object(self, obj: DocObject) -> dict:
+        """
+        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,
+            "kind": obj.kind,
+            "path": obj.path,
+            "signature": obj.signature,
+            "docstring": obj.docstring,
+        }
+
+        members = list(obj.get_all_members())
+        if members:
+            data["members"] = {
+                member.name: self._render_object(member) for member in members
+            }
+
+        return data
+
+    @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/mcp_renderer.pyi

@@ -0,0 +1,25 @@
+from pathlib import Path
+from typing import Any
+
+from docforge.models import DocObject, Module, Project
+
+class MCPRenderer:
+    """Renderer that emits MCP-native JSON resources from docforge models."""
+
+    name: str
+
+    def generate_sources(self, project: Project, out_dir: Path) -> None:
+        """Generate MCP-compatible JSON resources and navigation for the project."""
+
+    def _write_module(self, module: Module, modules_dir: Path) -> None:
+        """Serialize a module into an MCP JSON resource."""
+
+    def _render_module(self, module: Module) -> dict[str, Any]:
+        """Render a Module into MCP-friendly structured data."""
+
+    def _render_object(self, obj: DocObject) -> dict[str, Any]:
+        """Recursively render a DocObject into structured MCP data."""
+
+    @staticmethod
+    def _json(data: dict[str, Any]) -> str:
+        """Serialize structured data to formatted JSON."""

docforge/renderers/mkdocs.py

@@ -1,91 +0,0 @@
-"""
-This module implements the MkDocsRenderer, which generates Markdown source files
-compatible with the MkDocs 'material' theme and 'mkdocstrings' extension.
-"""
-
-from pathlib import Path
-
-from docforge.model import Project
-
-
-class MkDocsRenderer:
-    """
-    Renderer that generates Markdown source files formatted for the MkDocs
-    'mkdocstrings' plugin.
-    """
-
-    name = "mkdocs"
-
-    def generate_sources(self, project: Project, out_dir: Path) -> None:
-        """
-        Produce a set of Markdown files in the output directory based on the
-        provided Project model.
-
-        Args:
-            project: The project model to render.
-            out_dir: Target directory for documentation files.
-        """
-        modules = list(project.get_all_modules())
-        paths = {m.path for m in modules}
-
-        # Package detection (level-agnostic)
-        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)
-
-    # -------------------------
-    # Internal helpers
-    # -------------------------
-    def _write_module(self, module, packages: set[str], out_dir: Path) -> None:
-        """
-        Write a single module's documentation file. Packages are written as
-        'index.md' inside their respective directories.
-
-        Args:
-            module: The module to write.
-            packages: A set of module paths that are identified as packages.
-            out_dir: The base output directory.
-        """
-        parts = module.path.split(".")
-
-        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()
-        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()
-
-        content = self._render_markdown(title, module.path)
-
-        if md_path.exists() and md_path.read_text(encoding="utf-8") == content:
-            return
-
-        md_path.write_text(content, encoding="utf-8")
-
-    def _render_markdown(self, title: str, module_path: str) -> str:
-        """
-        Generate the Markdown content for a module file.
-
-        Args:
-            title: The display title for the page.
-            module_path: The dotted path of the module to document.
-
-        Returns:
-            A string containing the Markdown source.
-        """
-        return (
-            f"# {title}\n\n"
-            f"::: {module_path}\n"
-        )

docforge/renderers/mkdocs.pyi

@@ -1,17 +0,0 @@
-from pathlib import Path
-from typing import Set
-
-from docforge.model import Project, Module
-
-
-class MkDocsRenderer:
-    name: str
-
-    def generate_sources(self, project: Project, out_dir: Path) -> None: ...
-    def _write_module(
-        self,
-        module: Module,
-        packages: Set[str],
-        out_dir: Path,
-    ) -> None: ...
-    def _render_markdown(self, title: str, module_path: str) -> str: ...

docforge/renderers/mkdocs_renderer.py

@@ -0,0 +1,306 @@
+"""
+# 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 Module, Project
+
+
+class MkDocsRenderer:
+    """
+    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"
+
+    # -------------------------
+    # Public API
+    # -------------------------
+
+    def generate_sources(
+        self,
+        project: Project,
+        out_dir: Path,
+        module_is_source: bool | None = None,
+    ) -> None:
+        """
+        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 (Project):
+                Project model containing modules to document.
+
+            out_dir (Path):
+                Directory where generated Markdown files will be written.
+
+            module_is_source (bool | None):
+                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}
+
+        # 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,
+                module_is_source,
+            )
+
+    def generate_readme(
+        self,
+        project: Project,
+        docs_dir: Path,
+        module_is_source: bool | None = None,
+        readme_dir: Path | None = None,
+    ) -> None:
+        """
+        Generate a `README.md` file from the root module docstring.
+
+        Notes:
+            - 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 | None):
+                Whether the module is treated as the project source root.
+
+            readme_dir (Path | None):
+                Directory where the generated README.md should be written.
+                Defaults to the parent of `docs_dir`.
+        """
+
+        if not module_is_source:
+            # Future: support README generation per module
+            return
+
+        readme_root = readme_dir if readme_dir is not None else docs_dir.parent
+        readme_path = readme_root / "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 _find_root_module(self, project: Project) -> Module | None:
+        """
+        Locate the root module corresponding to the project name.
+
+        Args:
+            project (Project):
+                Project model to inspect.
+
+        Returns:
+            Module | None:
+                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 | None):
+                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:
+            dir_path = out_dir.joinpath(*parts)
+            dir_path.mkdir(parents=True, exist_ok=True)
+
+            md_path = dir_path / "index.md"
+            link_target = f"{parts[-1]}/" if parts else None
+        else:
+            dir_path = out_dir.joinpath(*parts[:-1])
+            dir_path.mkdir(parents=True, exist_ok=True)
+
+            md_path = dir_path / f"{parts[-1]}.md"
+            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 not md_path.exists() or md_path.read_text(encoding="utf-8") != content:
+            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 Markdown content for a module documentation page.
+
+        Args:
+            title (str):
+                Page title displayed in the documentation.
+
+            module_path (str):
+                Dotted import path of the module.
+
+        Returns:
+            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

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+from docforge.models import Module, Project
+
+class MkDocsRenderer:
+    name: str
+
+    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],
+        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: Project, out_dir: Path) -> None: ...
+    def _ensure_parent_index(
+        self, parts: list[str], out_dir: Path, link_target: str, title: str
+    ) -> None: ...

docforge/servers/__init__.py

@@ -0,0 +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/__init__.pyi

@@ -0,0 +1,5 @@
+from .mcp_server import MCPServer
+
+__all__ = [
+    "MCPServer",
+]

docforge/servers/mcp_server.py

@@ -0,0 +1,152 @@
+"""
+# Summary
+
+MCP server implementation.
+
+This module defines the `MCPServer` class, which serves pre-generated
+documentation bundles through the Model Context Protocol (MCP).
+
+---
+
+Notes:
+    - The served bundle is generated offline by `MCPRenderer`.
+    - Missing resources are reported as structured error dictionaries rather
+      than raising exceptions.
+    - The server exposes read-only resources and a single health-check tool.
+
+---
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Literal
+
+
+class MCPServer:
+    """
+    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.
+
+    Attributes:
+        mcp_root (Path):
+            Directory containing the generated MCP documentation bundle.
+
+        app (FastMCP):
+            Underlying FastMCP application instance that registers resources
+            and tools.
+    """
+
+    def __init__(self, mcp_root: Path, name: str) -> None:
+        """
+        Initialize the MCP server.
+
+        Args:
+            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.
+        """
+        from mcp.server.fastmcp import FastMCP
+
+        self.mcp_root = mcp_root
+        self.app = FastMCP(name)
+
+        self._register_resources()
+        self._register_tools()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _read_json(self, path: Path) -> Any:
+        """
+        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):
+                Path to the JSON file to read.
+
+        Returns:
+            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"))
+
+    # ------------------------------------------------------------------
+    # MCP resources
+    # ------------------------------------------------------------------
+
+    def _register_resources(self) -> None:
+        """
+        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")
+
+        @self.app.resource("docs://nav")
+        def nav():
+            return self._read_json(self.mcp_root / "nav.json")
+
+        @self.app.resource("docs://modules/{module}")
+        def module(module: str):
+            return self._read_json(self.mcp_root / "modules" / f"{module}.json")
+
+    # ------------------------------------------------------------------
+    # MCP tools
+    # ------------------------------------------------------------------
+
+    def _register_tools(self) -> None:
+        """
+        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:
+        """
+        Start the MCP server.
+
+        Args:
+            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/servers/mcp_server.pyi

@@ -0,0 +1,20 @@
+from pathlib import Path
+from typing import Any, Literal
+
+from mcp.server.fastmcp import FastMCP
+
+class MCPServer:
+    """MCP server serving a pre-generated documentation bundle.
+
+    Exposes read-only documentation resources and a health-check tool.
+    """
+
+    mcp_root: Path
+    app: FastMCP
+
+    def __init__(self, mcp_root: Path, name: str) -> None: ...
+    def _read_json(self, path: Path) -> Any: ...
+    def _register_resources(self) -> None: ...
+    def _register_tools(self) -> None: ...
+    def run(self, transport: Literal["stdio", "sse", "streamable-http"] = ...) -> None:
+        """Start the MCP server."""

docforge/templates/mkdocs.api.yml

@@ -0,0 +1,16 @@
+theme:
+  features:
+    - toc.integrate
+    - header.autohide
+    - announce.dismiss
+    - footer.social
+
+    - content.code.select
+    - content.code.line_numbers
+    - content.tooltips
+
+plugins:
+  - search
+  - swagger-ui-tag
+  - neoteroi.mkdocsoad:
+      use_pymdownx: true

docforge/templates/mkdocs.common.yml

@@ -0,0 +1,60 @@
+theme:
+  name: material
+  palette:
+    - scheme: slate
+      primary: deep purple
+      accent: cyan
+
+  font:
+    text: Inter
+    code: JetBrains Mono
+
+  features:
+    # 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
+
+markdown_extensions:
+  - pymdownx.superfences
+  - pymdownx.inlinehilite
+  - pymdownx.snippets
+
+  - admonition
+  - pymdownx.details
+
+  - 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
+
+extra_css:
+  - https://unpkg.com/dracula-prism/dist/css/dracula-prism.css

docforge/templates/mkdocs.lib.yml

@@ -1,26 +1,9 @@
-theme:
-  name: material
-  palette:
-    - scheme: slate
-      primary: deep purple
-      accent: cyan
-  font:
-    text: Inter
-    code: JetBrains Mono
-  features:
-    - navigation.tabs
-    - navigation.expand
-    - navigation.top
-    - navigation.instant
-    - content.code.copy
-    - content.code.annotate
-
 plugins:
   - search
   - mkdocstrings:
       handlers:
         python:
-          paths: ["."]
+          paths: [".."]
           options:
             docstring_style: google
             show_source: false
@@ -31,3 +14,6 @@ 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

docforge/templates/mkdocs.wiki.yml

@@ -0,0 +1,26 @@
+theme:
+  features:
+    # Horizontal tab navigation (mongo-ops style)
+    - navigation.tabs
+    # Navigation UX
+    - toc.integrate
+    - header.autohide
+    - announce.dismiss
+    - footer.social
+    # Content & Code
+    - content.code.select
+    - content.code.line_numbers
+    - content.tooltips
+  palette:
+    scheme: slate
+    primary: blue grey
+    accent: teal
+  font:
+    text: Roboto
+    code: JetBrains Mono
+  icon:
+    logo: material/database
+    repo: fontawesome/brands/github
+plugins:
+  - search
+  - docforge-linkfix

docs/docforge/cli/mkdocs.md

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

docs/docforge/loader/griffe_loader.md

@@ -1,3 +0,0 @@
-# Griffe Loader
-
-::: docforge.loader.griffe_loader

docs/docforge/loader/index.md

@@ -1,3 +0,0 @@
-# Loader
-
-::: docforge.loader

docs/docforge/model/index.md

@@ -1,3 +0,0 @@
-# Model
-
-::: docforge.model

docs/docforge/model/module.md

@@ -1,3 +0,0 @@
-# Module
-
-::: docforge.model.module

docs/docforge/model/object.md

@@ -1,3 +0,0 @@
-# Object
-
-::: docforge.model.object

docs/docforge/model/project.md

@@ -1,3 +0,0 @@
-# Project
-
-::: docforge.model.project

docs/docforge/renderers/mkdocs.md

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

docs/lib/cli/api_utils.md

@@ -0,0 +1,3 @@
+# Api Utils
+
+::: docforge.cli.api_utils

docs/lib/cli/commands.md

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

docs/lib/cli/mcp_utils.md

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

docs/lib/cli/mkdocs_utils.md

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

docs/lib/index.md

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

docs/lib/loaders/griffe_loader.md

@@ -0,0 +1,3 @@
+# Griffe Loader
+
+::: docforge.loaders.griffe_loader

docs/lib/loaders/index.md

@@ -0,0 +1,3 @@
+# Loaders
+
+::: docforge.loaders

docs/lib/models/index.md

@@ -0,0 +1,3 @@
+# Models
+
+::: docforge.models

docs/lib/models/module.md

@@ -0,0 +1,3 @@
+# Module
+
+::: docforge.models.module

docs/lib/models/object.md

@@ -0,0 +1,3 @@
+# Object
+
+::: docforge.models.object

docs/lib/models/project.md

@@ -0,0 +1,3 @@
+# Project
+
+::: docforge.models.project

docs/lib/nav/wiki.md

@@ -0,0 +1,3 @@
+# Wiki
+
+::: docforge.nav.wiki