Struct TemplateRenderer 

pub struct TemplateRenderer { /* private fields */ }

Template renderer with Tera engine and custom functions.

This struct wraps a Tera instance with AGPM-specific configuration, custom functions, and filters. It provides a safe, sandboxed environment for rendering Markdown templates.

Security

The renderer is configured with security restrictions:

• No file system access via includes/extends (except content filter)
• No network access
• Sandboxed template execution
• Custom functions are carefully vetted
• Project file access restricted to project directory with validation

Implementations

impl TemplateRenderer

pub fn new( enabled: bool, project_dir: PathBuf, max_content_file_size: Option<u64>, ) -> Result<Self>

Create a new template renderer with AGPM-specific configuration.

Arguments

• enabled - Whether templating is enabled globally
• project_dir - Project root directory for content filter validation
• max_content_file_size - Maximum file size in bytes for content filter (None for no limit)

Returns

Returns a configured TemplateRenderer instance with custom filters registered.

Filters

The following custom filters are registered:

• content: Read project-specific files with path validation and size limits

pub fn render_template( &mut self, template_content: &str, context: &TeraContext, metadata: Option<&RenderingMetadata>, ) -> Result<String, TemplateError>

Render a Markdown template with the given context.

This method supports recursive template rendering where project files can reference other project files using the content filter. Rendering continues up to filters::MAX_RENDER_DEPTH levels deep.

Render a Markdown template with the given context.

This method processes template syntax using the Tera engine. Content within

placeholders before processing, then restoring it afterwards.

# Arguments

* `template_content` - The raw Markdown template content
* `context` - The template context containing variables

# Returns

Returns the rendered Markdown content.

# Errors

Returns an error if:
- Template syntax is invalid
- Context variables are missing
- Custom functions/filters fail
- Recursive rendering exceeds maximum depth (10 levels)

# Literal Blocks

Content wrapped in ```literal fences will be protected from
template rendering and displayed literally:

````markdown
```literal
{{ agpm.deps.snippets.example.content }}

// This is a documentation example showing template syntax
// The actual template content would be in a separate file

This is useful for documentation that shows template syntax examples.

# Recursive Rendering

When a template contains 'content' filter references, those files
may themselves contain template syntax. The renderer automatically
detects this and performs multiple rendering passes until either:
- No template syntax remains in the output
- Maximum depth is reached (error)

Example recursive template chain:
// In a markdown file:
// # Main Agent
// {{ "docs/guide.md" | content }}

Where 'docs/guide.md' contains:
// # Guide
// {{ "docs/common.md" | content }}

This will render up to 10 levels deep.

pub fn format_tera_error(error: &Error) -> String

Format a Tera error with detailed information about what went wrong.

Tera errors can contain various types of issues:

• Missing variables (e.g., “Variable foo not found”)
• Syntax errors (e.g., “Unexpected end of template”)
• Filter/function errors (e.g., “Filter unknown not found”)

This function extracts the root cause and formats it in a user-friendly way, filtering out unhelpful internal template names like ‘__tera_one_off’.

Arguments

• error - The Tera error to format