feat: Add capabilities/templates.py

capabilities/templates.py

@@ -0,0 +1,614 @@
+"""
+Jinja Templates and MDX Components for MiniMind Max2
+Enhanced code generation with rich formatting support.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any, Union
+import re
+import json
+from enum import Enum
+
+
+class MDXComponentType(Enum):
+    """Supported MDX component types."""
+    LINEAR_PROCESS_FLOW = "LinearProcessFlow"
+    QUIZ = "Quiz"
+    MATH = "math"
+    THINKING = "Thinking"
+    CODE_BLOCK = "CodeBlock"
+    MERMAID = "Mermaid"
+    CALLOUT = "Callout"
+    TABS = "Tabs"
+    ACCORDION = "Accordion"
+
+
+@dataclass
+class CodeBlockMeta:
+    """Metadata for extended code blocks."""
+    project: str = ""
+    file: str = ""
+    block_type: str = "code"  # react, nodejs, html, markdown, diagram, code
+    language: str = "python"
+    title: str = ""
+    show_line_numbers: bool = True
+    highlight_lines: List[int] = field(default_factory=list)
+    executable: bool = False
+
+
+@dataclass
+class ThinkingBlock:
+    """Represents a thinking/reasoning block."""
+    content: str
+    step: int = 0
+    is_final: bool = False
+    confidence: float = 1.0
+
+
+class JinjaTemplateEngine:
+    """
+    Jinja-style template engine for code generation.
+    Supports variables, loops, conditionals, and filters.
+    """
+
+    def __init__(self):
+        self.filters = {
+            "upper": str.upper,
+            "lower": str.lower,
+            "capitalize": str.capitalize,
+            "title": str.title,
+            "strip": str.strip,
+            "length": len,
+            "default": lambda x, d: x if x else d,
+            "join": lambda x, sep=", ": sep.join(str(i) for i in x),
+            "first": lambda x: x[0] if x else None,
+            "last": lambda x: x[-1] if x else None,
+            "json": json.dumps,
+        }
+        self.globals = {}
+
+    def register_filter(self, name: str, func):
+        """Register a custom filter."""
+        self.filters[name] = func
+
+    def register_global(self, name: str, value):
+        """Register a global variable."""
+        self.globals[name] = value
+
+    def render(self, template: str, context: Dict[str, Any]) -> str:
+        """
+        Render a Jinja-style template.
+
+        Args:
+            template: Template string with {{ }} and {% %} blocks
+            context: Variables to substitute
+
+        Returns:
+            Rendered string
+        """
+        # Merge context with globals
+        full_context = {**self.globals, **context}
+
+        # Process control structures first
+        result = self._process_control_structures(template, full_context)
+
+        # Then substitute variables
+        result = self._substitute_variables(result, full_context)
+
+        return result
+
+    def _substitute_variables(self, template: str, context: Dict[str, Any]) -> str:
+        """Substitute {{ variable }} expressions."""
+        pattern = r'\{\{\s*(.+?)\s*\}\}'
+
+        def replace(match):
+            expr = match.group(1)
+            return str(self._evaluate_expression(expr, context))
+
+        return re.sub(pattern, replace, template)
+
+    def _evaluate_expression(self, expr: str, context: Dict[str, Any]) -> Any:
+        """Evaluate a Jinja expression."""
+        # Handle filters (e.g., name|upper)
+        if '|' in expr:
+            parts = expr.split('|')
+            value = self._evaluate_expression(parts[0].strip(), context)
+            for filter_expr in parts[1:]:
+                filter_expr = filter_expr.strip()
+                # Handle filter with arguments
+                if '(' in filter_expr:
+                    filter_name = filter_expr[:filter_expr.index('(')]
+                    args_str = filter_expr[filter_expr.index('(')+1:-1]
+                    if filter_name in self.filters:
+                        value = self.filters[filter_name](value, args_str.strip('"\''))
+                else:
+                    if filter_expr in self.filters:
+                        value = self.filters[filter_expr](value)
+            return value
+
+        # Handle attribute access (e.g., user.name)
+        if '.' in expr:
+            parts = expr.split('.')
+            value = context.get(parts[0])
+            for part in parts[1:]:
+                if isinstance(value, dict):
+                    value = value.get(part)
+                elif hasattr(value, part):
+                    value = getattr(value, part)
+                else:
+                    return None
+            return value
+
+        # Handle index access (e.g., items[0])
+        if '[' in expr:
+            match = re.match(r'(\w+)\[(.+)\]', expr)
+            if match:
+                var_name = match.group(1)
+                index = match.group(2)
+                value = context.get(var_name)
+                if value:
+                    try:
+                        idx = int(index)
+                        return value[idx]
+                    except (ValueError, IndexError):
+                        return None
+            return None
+
+        # Simple variable lookup
+        return context.get(expr, '')
+
+    def _process_control_structures(self, template: str, context: Dict[str, Any]) -> str:
+        """Process {% for %}, {% if %}, etc."""
+        result = template
+
+        # Process for loops
+        for_pattern = r'\{%\s*for\s+(\w+)\s+in\s+(\w+)\s*%\}(.*?)\{%\s*endfor\s*%\}'
+        while True:
+            match = re.search(for_pattern, result, re.DOTALL)
+            if not match:
+                break
+
+            var_name = match.group(1)
+            iterable_name = match.group(2)
+            body = match.group(3)
+
+            iterable = context.get(iterable_name, [])
+            rendered_parts = []
+
+            for item in iterable:
+                item_context = {**context, var_name: item}
+                rendered_parts.append(self._substitute_variables(body, item_context))
+
+            result = result[:match.start()] + ''.join(rendered_parts) + result[match.end():]
+
+        # Process if statements
+        if_pattern = r'\{%\s*if\s+(.+?)\s*%\}(.*?)(?:\{%\s*else\s*%\}(.*?))?\{%\s*endif\s*%\}'
+        while True:
+            match = re.search(if_pattern, result, re.DOTALL)
+            if not match:
+                break
+
+            condition = match.group(1)
+            true_block = match.group(2)
+            false_block = match.group(3) or ''
+
+            if self._evaluate_condition(condition, context):
+                replacement = true_block
+            else:
+                replacement = false_block
+
+            result = result[:match.start()] + replacement + result[match.end():]
+
+        return result
+
+    def _evaluate_condition(self, condition: str, context: Dict[str, Any]) -> bool:
+        """Evaluate a condition expression."""
+        # Simple conditions
+        if ' == ' in condition:
+            left, right = condition.split(' == ', 1)
+            left_val = self._evaluate_expression(left.strip(), context)
+            right_val = right.strip().strip('"\'')
+            return str(left_val) == right_val
+
+        if ' != ' in condition:
+            left, right = condition.split(' != ', 1)
+            left_val = self._evaluate_expression(left.strip(), context)
+            right_val = right.strip().strip('"\'')
+            return str(left_val) != right_val
+
+        if ' > ' in condition:
+            left, right = condition.split(' > ', 1)
+            left_val = self._evaluate_expression(left.strip(), context)
+            right_val = float(right.strip())
+            return float(left_val) > right_val
+
+        if ' < ' in condition:
+            left, right = condition.split(' < ', 1)
+            left_val = self._evaluate_expression(left.strip(), context)
+            right_val = float(right.strip())
+            return float(left_val) < right_val
+
+        # Truthiness check
+        value = self._evaluate_expression(condition.strip(), context)
+        return bool(value)
+
+
+class MDXRenderer:
+    """
+    Render MDX components for rich documentation and UI.
+    """
+
+    def __init__(self):
+        self.components = {}
+        self._register_default_components()
+
+    def _register_default_components(self):
+        """Register default MDX components."""
+        self.components = {
+            MDXComponentType.LINEAR_PROCESS_FLOW: self._render_linear_process_flow,
+            MDXComponentType.QUIZ: self._render_quiz,
+            MDXComponentType.MATH: self._render_math,
+            MDXComponentType.THINKING: self._render_thinking,
+            MDXComponentType.MERMAID: self._render_mermaid,
+            MDXComponentType.CALLOUT: self._render_callout,
+            MDXComponentType.TABS: self._render_tabs,
+        }
+
+    def render(self, component_type: MDXComponentType, props: Dict[str, Any]) -> str:
+        """Render an MDX component."""
+        if component_type in self.components:
+            return self.components[component_type](props)
+        return f"<!-- Unknown component: {component_type} -->"
+
+    def _render_linear_process_flow(self, props: Dict[str, Any]) -> str:
+        """Render a linear process flow diagram."""
+        steps = props.get("steps", [])
+        title = props.get("title", "Process Flow")
+
+        html = f'<div class="linear-process-flow">\n'
+        html += f'  <h3>{title}</h3>\n'
+        html += '  <div class="steps">\n'
+
+        for i, step in enumerate(steps):
+            html += f'    <div class="step" data-step="{i+1}">\n'
+            html += f'      <div class="step-number">{i+1}</div>\n'
+            html += f'      <div class="step-content">\n'
+            html += f'        <h4>{step.get("title", f"Step {i+1}")}</h4>\n'
+            html += f'        <p>{step.get("description", "")}</p>\n'
+            html += '      </div>\n'
+            if i < len(steps) - 1:
+                html += '      <div class="step-arrow">→</div>\n'
+            html += '    </div>\n'
+
+        html += '  </div>\n'
+        html += '</div>'
+
+        return html
+
+    def _render_quiz(self, props: Dict[str, Any]) -> str:
+        """Render an interactive quiz."""
+        questions = props.get("questions", [])
+        title = props.get("title", "Quiz")
+
+        html = f'<div class="quiz" data-quiz-id="{props.get("id", "quiz")}">\n'
+        html += f'  <h3>{title}</h3>\n'
+
+        for i, q in enumerate(questions):
+            html += f'  <div class="question" data-question="{i}">\n'
+            html += f'    <p class="question-text">{q.get("question", "")}</p>\n'
+            html += '    <div class="options">\n'
+
+            for j, opt in enumerate(q.get("options", [])):
+                correct = j == q.get("correct", 0)
+                html += f'      <label class="option" data-correct="{str(correct).lower()}">\n'
+                html += f'        <input type="radio" name="q{i}" value="{j}">\n'
+                html += f'        <span>{opt}</span>\n'
+                html += '      </label>\n'
+
+            html += '    </div>\n'
+            if q.get("explanation"):
+                html += f'    <div class="explanation" hidden>{q["explanation"]}</div>\n'
+            html += '  </div>\n'
+
+        html += '</div>'
+        return html
+
+    def _render_math(self, props: Dict[str, Any]) -> str:
+        """Render LaTeX math expressions."""
+        expression = props.get("expression", "")
+        display = props.get("display", False)
+
+        if display:
+            return f'$${expression}$$'
+        return f'${expression}$'
+
+    def _render_thinking(self, props: Dict[str, Any]) -> str:
+        """Render a thinking/reasoning block."""
+        content = props.get("content", "")
+        step = props.get("step", 0)
+        is_visible = props.get("visible", False)
+
+        css_class = "thinking-block" + (" visible" if is_visible else " hidden")
+
+        html = f'<div class="{css_class}" data-step="{step}">\n'
+        html += '  <div class="thinking-header">\n'
+        html += f'    <span class="thinking-icon">🤔</span>\n'
+        html += f'    <span class="thinking-label">Thinking (Step {step})</span>\n'
+        html += '  </div>\n'
+        html += f'  <div class="thinking-content">{content}</div>\n'
+        html += '</div>'
+
+        return html
+
+    def _render_mermaid(self, props: Dict[str, Any]) -> str:
+        """Render a Mermaid diagram."""
+        code = props.get("code", "")
+        title = props.get("title", "")
+
+        html = '<div class="mermaid-diagram">\n'
+        if title:
+            html += f'  <div class="diagram-title">{title}</div>\n'
+        html += f'  <pre class="mermaid">\n{code}\n  </pre>\n'
+        html += '</div>'
+
+        return html
+
+    def _render_callout(self, props: Dict[str, Any]) -> str:
+        """Render a callout/alert box."""
+        callout_type = props.get("type", "info")  # info, warning, error, success
+        title = props.get("title", "")
+        content = props.get("content", "")
+
+        icons = {
+            "info": "ℹ️",
+            "warning": "⚠️",
+            "error": "❌",
+            "success": "✅",
+        }
+
+        html = f'<div class="callout callout-{callout_type}">\n'
+        html += f'  <div class="callout-icon">{icons.get(callout_type, "ℹ️")}</div>\n'
+        html += '  <div class="callout-content">\n'
+        if title:
+            html += f'    <div class="callout-title">{title}</div>\n'
+        html += f'    <div class="callout-body">{content}</div>\n'
+        html += '  </div>\n'
+        html += '</div>'
+
+        return html
+
+    def _render_tabs(self, props: Dict[str, Any]) -> str:
+        """Render a tabbed interface."""
+        tabs = props.get("tabs", [])
+
+        html = '<div class="tabs-container">\n'
+        html += '  <div class="tabs-header">\n'
+
+        for i, tab in enumerate(tabs):
+            active = "active" if i == 0 else ""
+            html += f'    <button class="tab-button {active}" data-tab="{i}">{tab.get("label", f"Tab {i+1}")}</button>\n'
+
+        html += '  </div>\n'
+        html += '  <div class="tabs-content">\n'
+
+        for i, tab in enumerate(tabs):
+            active = "active" if i == 0 else ""
+            html += f'    <div class="tab-panel {active}" data-tab="{i}">{tab.get("content", "")}</div>\n'
+
+        html += '  </div>\n'
+        html += '</div>'
+
+        return html
+
+
+class ExtendedCodeBlockParser:
+    """
+    Parse and generate extended code blocks with metadata.
+    """
+
+    # Language to file extension mapping
+    LANG_EXTENSIONS = {
+        "python": ".py",
+        "javascript": ".js",
+        "typescript": ".ts",
+        "tsx": ".tsx",
+        "jsx": ".jsx",
+        "rust": ".rs",
+        "go": ".go",
+        "java": ".java",
+        "cpp": ".cpp",
+        "c": ".c",
+        "html": ".html",
+        "css": ".css",
+        "json": ".json",
+        "yaml": ".yaml",
+        "markdown": ".md",
+        "sql": ".sql",
+        "bash": ".sh",
+        "shell": ".sh",
+    }
+
+    @classmethod
+    def parse(cls, code_block: str) -> tuple[CodeBlockMeta, str]:
+        """
+        Parse an extended code block.
+
+        Args:
+            code_block: Full code block including ``` markers
+
+        Returns:
+            Tuple of (metadata, code_content)
+        """
+        lines = code_block.strip().split('\n')
+        first_line = lines[0]
+
+        # Parse first line for metadata
+        meta = CodeBlockMeta()
+
+        # Extract language
+        lang_match = re.match(r'```(\w+)', first_line)
+        if lang_match:
+            meta.language = lang_match.group(1)
+
+        # Extract attributes
+        attrs = {}
+        attr_pattern = r'(\w+)="([^"]*)"'
+        for match in re.finditer(attr_pattern, first_line):
+            attrs[match.group(1)] = match.group(2)
+
+        meta.project = attrs.get("project", "")
+        meta.file = attrs.get("file", "")
+        meta.block_type = attrs.get("type", "code")
+        meta.title = attrs.get("title", "")
+        meta.executable = meta.block_type in ["react", "nodejs", "html"]
+
+        # Handle highlight lines
+        if "highlight" in attrs:
+            try:
+                meta.highlight_lines = [int(x) for x in attrs["highlight"].split(",")]
+            except ValueError:
+                pass
+
+        # Extract code content
+        code_lines = lines[1:-1] if lines[-1].strip() == '```' else lines[1:]
+        code = '\n'.join(code_lines)
+
+        return meta, code
+
+    @classmethod
+    def format(cls, code: str, meta: CodeBlockMeta) -> str:
+        """
+        Format code with extended code block syntax.
+
+        Args:
+            code: Code content
+            meta: Metadata for the code block
+
+        Returns:
+            Formatted code block string
+        """
+        attrs = []
+
+        if meta.project:
+            attrs.append(f'project="{meta.project}"')
+        if meta.file:
+            attrs.append(f'file="{meta.file}"')
+        if meta.block_type != "code":
+            attrs.append(f'type="{meta.block_type}"')
+        if meta.title:
+            attrs.append(f'title="{meta.title}"')
+        if meta.highlight_lines:
+            attrs.append(f'highlight="{",".join(str(x) for x in meta.highlight_lines)}"')
+
+        attr_str = " " + " ".join(attrs) if attrs else ""
+
+        return f"```{meta.language}{attr_str}\n{code}\n```"
+
+    @classmethod
+    def create_react_component(
+        cls,
+        code: str,
+        component_name: str,
+        project: str = "MiniMind",
+    ) -> str:
+        """Create a React component code block."""
+        meta = CodeBlockMeta(
+            project=project,
+            file=f"components/{component_name}.tsx",
+            block_type="react",
+            language="tsx",
+        )
+        return cls.format(code, meta)
+
+    @classmethod
+    def create_mermaid_diagram(
+        cls,
+        code: str,
+        title: str = "",
+    ) -> str:
+        """Create a Mermaid diagram code block."""
+        meta = CodeBlockMeta(
+            block_type="diagram",
+            language="mermaid",
+            title=title,
+        )
+        return cls.format(code, meta)
+
+
+class TemplateLibrary:
+    """
+    Pre-built templates for common code patterns.
+    """
+
+    TEMPLATES = {
+        "react_component": '''
+import React from 'react';
+
+interface {{ name }}Props {
+{% for prop in props %}
+  {{ prop.name }}: {{ prop.type }};
+{% endfor %}
+}
+
+export const {{ name }}: React.FC<{{ name }}Props> = ({ {% for prop in props %}{{ prop.name }}{% if not loop.last %}, {% endif %}{% endfor %} }) => {
+  return (
+    <div className="{{ name | lower }}">
+      {{ content }}
+    </div>
+  );
+};
+''',
+        "python_class": '''
+class {{ name }}:
+    """{{ description }}"""
+
+    def __init__(self{% for param in params %}, {{ param.name }}: {{ param.type }}{% if param.default %} = {{ param.default }}{% endif %}{% endfor %}):
+{% for param in params %}
+        self.{{ param.name }} = {{ param.name }}
+{% endfor %}
+
+{% for method in methods %}
+    def {{ method.name }}(self{% for arg in method.args %}, {{ arg.name }}: {{ arg.type }}{% endfor %}) -> {{ method.return_type }}:
+        """{{ method.description }}"""
+        {{ method.body }}
+
+{% endfor %}
+''',
+        "api_endpoint": '''
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/{{ prefix }}", tags=["{{ tag }}"])
+
+{% for model in models %}
+class {{ model.name }}(BaseModel):
+{% for field in model.fields %}
+    {{ field.name }}: {{ field.type }}
+{% endfor %}
+
+{% endfor %}
+
+{% for endpoint in endpoints %}
+@router.{{ endpoint.method }}("{{ endpoint.path }}")
+async def {{ endpoint.name }}({% for param in endpoint.params %}{{ param.name }}: {{ param.type }}{% if not loop.last %}, {% endif %}{% endfor %}):
+    """{{ endpoint.description }}"""
+    {{ endpoint.body }}
+
+{% endfor %}
+''',
+    }
+
+    def __init__(self):
+        self.engine = JinjaTemplateEngine()
+
+    def render(self, template_name: str, context: Dict[str, Any]) -> str:
+        """Render a pre-built template."""
+        if template_name not in self.TEMPLATES:
+            raise ValueError(f"Unknown template: {template_name}")
+
+        template = self.TEMPLATES[template_name]
+        return self.engine.render(template, context)
+
+    def add_template(self, name: str, template: str):
+        """Add a custom template."""
+        self.TEMPLATES[name] = template