Extension Points

from bengal.content_types import ContentStrategy, ContentTypeRegistry

class CustomStrategy(ContentStrategy):
    def get_template(self, page):
        # Custom template selection logic
        return 'custom/template.html'

    def get_url_pattern(self, page):
        # Custom URL structure
        return f"custom/{page.slug}/"

    def get_sorting_key(self, pages):
        # Custom page sorting
        return lambda p: p.title

    def should_generate_index(self, section):
        return True

# Register your strategy
ContentTypeRegistry.register('custom', CustomStrategy)

[content_type]
strategy = "custom"

from bengal.rendering.parsers.base import BaseMarkdownParser

class CustomMarkdownParser(BaseMarkdownParser):
    def parse(self, content: str) -> str:
        # Parse markdown to HTML
        return html

    def parse_with_toc(self, content: str) -> tuple[str, list]:
        # Parse with TOC extraction
        return html, toc_items

# Register in parser factory
# (requires modification of bengal/rendering/parsers/__init__.py)

[build]
markdown_engine = "custom"

# In your site's custom module
from bengal.rendering.template_engine import TemplateEngine

def my_custom_filter(value):
    """Custom filter implementation."""
    return value.upper()

# Register with template engine (requires hook - see below)
def register_custom_functions(engine: TemplateEngine):
    engine.env.filters['custom'] = my_custom_filter

# In bengal/postprocess/ or custom module
class RobotsGenerator:
    def __init__(self, site):
        self.site = site

    def generate(self) -> None:
        """Generate robots.txt"""
        robots_content = self._build_robots_txt()
        output_path = self.site.output_dir / 'robots.txt'
        output_path.write_text(robots_content)

    def _build_robots_txt(self) -> str:
        # Build robots.txt content
        return "User-agent: *\nDisallow: /admin/"

# Add to PostprocessOrchestrator
# (requires modification or plugin hook)

from bengal.health.base import BaseValidator, CheckResult, CheckStatus

class CustomValidator(BaseValidator):
    name = "custom"
    description = "Custom validation checks"

    def validate(self, site) -> list[CheckResult]:
        results = []

        # Your validation logic
        for page in site.pages:
            if not self._check_custom_requirement(page):
                results.append(CheckResult(
                    status=CheckStatus.ERROR,
                    message=f"Page {page.title} fails custom check",
                    recommendation="Fix the issue"
                ))

        return results

# Register with health system
# (requires modification of bengal/health/health_check.py)

[health_check.validators]
custom = true

from bengal.rendering.plugins import ShortcodePlugin

class AlertShortcode(ShortcodePlugin):
    name = "alert"

    def render(self, content, **kwargs):
        alert_type = kwargs.get('type', 'info')
        return f'<div class="alert alert-{alert_type}">{content}</div>'

# Register shortcode
# (requires plugin system)

{{% alert type="warning" %}}
This is a warning message!
{{% /alert %}}

from bengal.plugins import Plugin, hook

class MyPlugin(Plugin):
    name = "my-plugin"
    version = "1.0.0"

    @hook('pre_build')
    def before_build(self, site):
        """Called before build starts"""
        print(f"Building {len(site.pages)} pages")

    @hook('post_page_render')
    def after_page_render(self, page, html):
        """Called after each page renders"""
        return self._modify_html(html)

    @hook('post_build')
    def after_build(self, site, stats):
        """Called after build completes"""
        print(f"Built in {stats.duration}s")

# Register plugin
# bengal.toml:
# [plugins]
# my-plugin = true

import click
from bengal.cli import cli

@cli.command()
@click.option('--verbose', is_flag=True)
def custom(verbose):
    """My custom command."""
    print("Executing custom command")

# Commands automatically discovered and registered

from bengal.autodoc.base import Extractor, DocElement

class OpenAPIExtractor(Extractor):
    """Extract docs from OpenAPI specs."""

    def extract(self, source_path):
        spec = self._load_openapi_spec(source_path)

        elements = []
        for path, methods in spec['paths'].items():
            for method, details in methods.items():
                element = DocElement(
                    name=f"{method.upper()} {path}",
                    element_type='endpoint',
                    description=details.get('summary', ''),
                    metadata=details
                )
                elements.append(element)

        return elements

# Register extractor
# (planned: autodoc registry system)