markitecture 0.1.15__py3-none-any.whl

markitecture/generators/configs/mkdocs_yaml.py

@@ -0,0 +1,317 @@
+import re
+from pathlib import Path
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    Set,
+    Union,
+)
+
+import yaml
+
+from markitecture.errors import FileOperationError
+from markitecture.utils.file_handler import FileHandler
+
+
+class MkDocsConfig:
+    """
+    Handles MkDocs configuration generation.
+    """
+
+    # Define priority pages that should appear first in navigation
+    PRIORITY_PAGES: ClassVar[List[str]] = [
+        "readme",
+        "index",
+        "introduction",
+        "getting-started",
+        "quick-start",
+    ]
+
+    def __init__(
+        self,
+        docs_dir: Union[str, Path] = ".markitecture/",
+        site_name: str = "MkDocs Site Documentation",
+        enable_material: bool = True,
+        theme_palette: Dict[str, str] | None = None,
+    ) -> None:
+        if not site_name or not site_name.strip():
+            raise ValueError("Site name cannot be empty")
+
+        self.docs_dir = Path(docs_dir)
+        if not self.docs_dir.exists() and not self.docs_dir.parent.exists():
+            raise ValueError(f"Invalid documentation directory path: {docs_dir}")
+
+        self.site_name = site_name.strip()
+        self.enable_material = enable_material
+        self.theme_palette = theme_palette or {
+            "scheme": "default",
+            "primary": "indigo",
+            "accent": "indigo",
+        }
+        self.file_handler = FileHandler()
+
+    def _format_nav_title(self, filename: str) -> str:
+        """Format a filename into a readable navigation title.
+
+        Args:
+            filename: Name of the markdown file without extension
+
+        Returns:
+            Formatted title suitable for navigation
+        """
+        # Remove common prefix/suffix patterns
+        clean_name = re.sub(r"^[0-9]+[-_]", "", filename)
+        clean_name = re.sub(r"[-_]?index$", "", clean_name)
+
+        # Replace separators and capitalize
+        return clean_name.replace("-", " ").replace("_", " ").strip().title()
+
+    def _generate_nav(self) -> List[Dict[str, str]]:
+        """Generate organized navigation structure from markdown files."""
+        nav: List[Dict[str, str]] = []
+        try:
+            self.docs_dir.mkdir(parents=True, exist_ok=True)
+
+            md_files = list(self.docs_dir.glob("*.md"))
+            if not md_files:
+                placeholder_path = self.docs_dir / "index.md"
+                placeholder_content = "# Home\n\nWelcome to your documentation!"
+                placeholder_path.write_text(placeholder_content, encoding="utf-8")
+                md_files = [placeholder_path]
+
+            # Sort files into priority and regular lists
+            priority_files: List[Path] = []
+            regular_files: List[Path] = []
+            for md_file in md_files:
+                if md_file.stem.lower() in self.PRIORITY_PAGES:
+                    priority_files.append(md_file)
+                else:
+                    regular_files.append(md_file)
+
+            # Add priority files first, in order specified in PRIORITY_PAGES
+            for page in self.PRIORITY_PAGES:
+                matching_files = [f for f in priority_files if f.stem.lower() == page]
+                if matching_files:
+                    title = (
+                        "Home"
+                        if page in ["readme", "index"]
+                        else self._format_nav_title(page)
+                    )
+                    nav.append({
+                        title: str(matching_files[0].relative_to(self.docs_dir))
+                    })
+
+            # Add remaining files alphabetically
+            for md_file in sorted(regular_files, key=lambda x: x.stem.lower()):
+                title = self._format_nav_title(md_file.stem)
+                nav.append({title: str(md_file.relative_to(self.docs_dir))})
+
+        except Exception as e:
+            raise FileOperationError(
+                f"Failed to generate navigation structure: {e!s}"
+            ) from e
+
+        return nav
+
+    def _get_base_config(self) -> Dict[str, Union[str, Dict[str, str]]]:
+        """Get comprehensive MkDocs configuration with enhanced theme settings.
+
+        Returns:
+            Complete MkDocs configuration dictionary
+        """
+        config = {
+            "site_name": self.site_name,
+            "docs_dir": str(self.docs_dir),
+            "nav": self._generate_nav(),
+        }
+
+        if self.enable_material:
+            config.update({
+                "theme": {
+                    "name": "material",
+                    "palette": self.theme_palette,
+                    "features": [
+                        "navigation.instant",
+                        "navigation.tracking",
+                        "navigation.tabs",
+                        "navigation.sections",
+                        "navigation.expand",
+                        "search.highlight",
+                    ],
+                },
+                "markdown_extensions": [
+                    "admonition",
+                    "pymdownx.details",
+                    "pymdownx.superfences",
+                    "pymdownx.highlight",
+                    "pymdownx.inlinehilite",
+                    "pymdownx.snippets",
+                    "tables",
+                    "footnotes",
+                ],
+            })
+
+        return config
+
+    def generate_config(
+        self,
+        output_file: Union[str, Path] | None = None,
+        extra_config: Dict[str, Union[str, Dict[str, str]]] | None = None,
+    ) -> None:
+        """Generate MkDocs configuration file with enhanced error handling.
+
+        Args:
+            output_file: Path for configuration file output
+            extra_config: Additional configuration options to include
+
+        Raises:
+            FileOperationError: If configuration file cannot be written
+            ValueError: If output_file is invalid
+        """
+        if not output_file:
+            output_file = self.docs_dir / "mkdocs.yml"
+
+        config = self._get_base_config()
+
+        # Merge any extra configuration settings
+        if extra_config:
+            config = self._deep_merge_configs(config, extra_config)
+
+        try:
+            # Ensure parent directories exist
+            output_path = Path(output_file)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            with output_path.open("w", encoding="utf-8") as file:
+                yaml.dump(
+                    config,
+                    file,
+                    Dumper=SpacedDumper,
+                    default_flow_style=False,
+                    sort_keys=False,
+                    allow_unicode=True,
+                    indent=2,  # Ensure consistent indentation
+                )
+
+        except Exception as e:
+            raise FileOperationError(
+                f"Failed to write MkDocs configuration to {output_file}: {e!s}"
+            ) from e
+
+    def _deep_merge_configs(
+        self, base: dict[str, Any], update: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Recursively merge two configuration dictionaries.
+
+        Args:
+            base: Base configuration dictionary
+            update: Update configuration dictionary
+
+        Returns:
+            Merged configuration dictionary
+        """
+        result = base.copy()
+        for key, value in update.items():
+            if (
+                isinstance(value, dict)
+                and key in result
+                and isinstance(result[key], dict)
+            ):
+                result[key] = self._deep_merge_configs(result[key], value)
+            else:
+                result[key] = value
+        return result
+
+    def update_nav(self, output_file: Union[str, Path] = "mkdocs.yml") -> None:
+        """Update navigation while preserving other configuration settings.
+
+        Args:
+            output_file: Path to existing MkDocs configuration file
+
+        Raises:
+            FileOperationError: If config file cannot be accessed
+            FileNotFoundError: If config file does not exist
+        """
+        output_path = Path(output_file)
+        if not output_path.exists():
+            raise FileNotFoundError(f"Config file not found: {output_file}")
+
+        try:
+            with output_path.open("r", encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+
+            # Update navigation structure
+            config["nav"] = self._generate_nav()
+
+            # Write updated configuration
+            with output_path.open("w", encoding="utf-8") as file:
+                yaml.dump(
+                    config,
+                    file,
+                    Dumper=SpacedDumper,
+                    default_flow_style=False,
+                    sort_keys=False,
+                    allow_unicode=True,
+                    indent=2,  # Ensure consistent indentation
+                )
+
+        except Exception as e:
+            raise FileOperationError(
+                f"Failed to update navigation in {output_file}: {e!s}"
+            ) from e
+
+
+class SpacedDumper(yaml.Dumper):
+    """
+    Custom YAML dumper that adds spacing between major configuration sections.
+
+    This dumper ensures that the generated YAML config is more readable by:
+    - Keeping basic settings grouped together at the top
+    - Adding line breaks between major sections like nav, theme, and extensions
+    - Maintaining proper indentation throughout
+    """
+
+    # Settings that should be grouped together at the top without extra spacing
+    BASIC_SETTINGS: ClassVar[Set[str]] = {
+        "site_name",
+        "docs_dir",
+        "site_url",
+        "repo_url",
+        "repo_name",
+    }
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.last_was_basic = False
+        self.current_key: str | None = None
+
+    def represent_mapping(
+        self,
+        tag: str,
+        mapping: Any,  # Union[SupportsItems[Any, Any], Iterable[tuple[Any, Any]]],
+        flow_style: bool | None = None,
+    ) -> yaml.MappingNode:
+        """Override to track the current key being processed."""
+        # Get the key if we're at the top level
+        if len(self.indents) == 0 and mapping:
+            self.current_key = next(iter(mapping))  # type: ignore
+        return super().represent_mapping(tag, mapping, flow_style)
+
+    def write_line_break(self, data: str | None = None) -> None:
+        """Add extra line breaks between major sections, but not basic settings."""
+        super().write_line_break(data)
+
+        # Only add extra spacing for top-level items that aren't basic settings
+        if (
+            len(self.indents) == 1
+            and self.current_key not in self.BASIC_SETTINGS
+            and not self.last_was_basic
+        ):
+            super().write_line_break()
+
+        # Track whether we just processed a basic setting
+        self.last_was_basic = (
+            len(self.indents) == 1 and self.current_key in self.BASIC_SETTINGS
+        )

markitecture/metrics/__init__.py

@@ -0,0 +1,9 @@
+from markitecture.metrics.analyzer import ReadabilityAnalyzer, ReadabilityMetrics
+from markitecture.metrics.svg_generator import BadgeStyle, MetricsSvgGenerator
+
+__all__ = [
+    "BadgeStyle",
+    "MetricsSvgGenerator",
+    "ReadabilityAnalyzer",
+    "ReadabilityMetrics",
+]

markitecture/metrics/analyzer.py

@@ -0,0 +1,109 @@
+import re
+from dataclasses import dataclass
+from typing import Tuple
+
+
+@dataclass
+class ReadabilityMetrics:
+    """
+    Data class to store readability metrics.
+    """
+
+    word_count: int
+    sentence_count: int
+    avg_words_per_sentence: float
+    reading_time_mins: float
+    complexity_score: float
+    heading_count: int
+    code_block_count: int
+    link_count: int
+    image_count: int
+
+
+class ReadabilityAnalyzer:
+    """
+    Analyze the content and calculate readability metrics.
+    """
+
+    def __init__(self) -> None:
+        self.READING_SPEED = 238  # words per minute
+        self.CODE_BLOCK_TIME = 20  # seconds
+        self.WEIGHTS = {
+            "avg_sentence_length": 0.3,
+            "code_density": 0.3,
+            "heading_depth": 0.2,
+            "link_density": 0.1,
+            "image_density": 0.1,
+        }
+
+    def _count_words(self, text: str) -> int:
+        """Count words in the text after removing code blocks and URLs."""
+        text = re.sub(r"```.*?```", "", text, flags=re.DOTALL)
+        text = re.sub(r"`.*?`", "", text)
+        text = re.sub(r"http[s]?://\S+", "", text)
+        words = re.findall(r"\w+", text)
+        return len(words)
+
+    def _count_sentences(self, text: str) -> int:
+        """Split text into sentences and count them."""
+        text = re.sub(r"```.*?```", "", text, flags=re.DOTALL)
+        sentences = re.split(r"[.!?]+", text)
+        return len([s for s in sentences if s.strip()])
+
+    def _count_code_blocks(self, text: str) -> int:
+        """Count code blocks enclosed in triple backticks."""
+        return len(re.findall(r"```.*?```", text, re.DOTALL))
+
+    def _count_headings(self, text: str) -> Tuple[int, float]:
+        """Calculate average heading depth."""
+        headings = re.findall(r"^(#{1,6})\s+.*$", text, re.MULTILINE)
+        if not headings:
+            return 0, 0.0
+        total_depth = sum(len(h) for h in headings)
+        return len(headings), total_depth / len(headings)
+
+    def _count_links_and_images(self, text: str) -> Tuple[int, int]:
+        """Count links only if not preceded by an exclamation mark."""
+        links = len(re.findall(r"(?<!\!)\[(.*?)\]\((.*?)\)", text))
+        images = len(re.findall(r"!\[(.*?)\]\((.*?)\)", text))
+        return links, images
+
+    def calculate_complexity(self, metrics: ReadabilityMetrics) -> float:
+        """Calculate a weighted complexity score based on various metrics."""
+        scores = {
+            "avg_sentence_length": min(metrics.avg_words_per_sentence / 20.0, 1.0),
+            "code_density": metrics.code_block_count / max(metrics.word_count / 500, 1),
+            "heading_depth": metrics.heading_count / max(metrics.word_count / 200, 1),
+            "link_density": metrics.link_count / max(metrics.word_count / 200, 1),
+            "image_density": metrics.image_count / max(metrics.word_count / 300, 1),
+        }
+        weighted_score = sum(
+            scores[metric] * weight for metric, weight in self.WEIGHTS.items()
+        )
+        return min(round(weighted_score * 100), 100)
+
+    def analyze_document(self, content: str) -> ReadabilityMetrics:
+        """Analyze the content and calculate readability metrics."""
+        word_count = self._count_words(content)
+        sentence_count = self._count_sentences(content)
+        code_blocks = self._count_code_blocks(content)
+        heading_count, _ = self._count_headings(content)
+        link_count, image_count = self._count_links_and_images(content)
+        avg_words = word_count / max(sentence_count, 1) if sentence_count > 0 else 0
+        base_reading_time = word_count / self.READING_SPEED
+        code_reading_time = (code_blocks * self.CODE_BLOCK_TIME) / 60
+        total_reading_time = base_reading_time + code_reading_time
+
+        metrics = ReadabilityMetrics(
+            word_count=word_count,
+            sentence_count=sentence_count,
+            avg_words_per_sentence=round(avg_words, 1),
+            reading_time_mins=round(total_reading_time, 1),
+            complexity_score=0,  # placeholder
+            heading_count=heading_count,
+            code_block_count=code_blocks,
+            link_count=link_count,
+            image_count=image_count,
+        )
+        metrics.complexity_score = self.calculate_complexity(metrics)
+        return metrics

markitecture/metrics/badges/__init__.py

@@ -0,0 +1,28 @@
+from enum import StrEnum
+
+from markitecture.metrics.badges.compact import CompactBadgeGenerator
+from markitecture.metrics.badges.detailed import DetailedBadgeGenerator
+from markitecture.metrics.badges.minimal import MinimalBadgeGenerator
+from markitecture.metrics.badges.modern import ModernBadgeGenerator
+from markitecture.metrics.badges.retro import RetroBadgeGenerator
+from markitecture.metrics.badges.shields import ShieldsBadgeGenerator
+
+
+class BadgeStyle(StrEnum):
+    MODERN = "modern"
+    COMPACT = "compact"
+    DETAILED = "detailed"
+    MINIMAL = "minimal"
+    RETRO = "retro"
+    SHIELDS = "shields"
+
+
+__all__ = [
+    "BadgeStyle",
+    "CompactBadgeGenerator",
+    "DetailedBadgeGenerator",
+    "MinimalBadgeGenerator",
+    "ModernBadgeGenerator",
+    "RetroBadgeGenerator",
+    "ShieldsBadgeGenerator",
+]

markitecture/metrics/badges/base.py

@@ -0,0 +1,7 @@
+class BaseSvgGenerator:
+    def __init__(self, width: int, height: int):
+        self.width = width
+        self.height = height
+
+    def render(self, content: str) -> str:
+        return f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {self.width} {self.height}">{content}</svg>'

markitecture/metrics/badges/compact.py

@@ -0,0 +1,35 @@
+from typing import Tuple
+
+from markitecture.metrics.analyzer import ReadabilityMetrics
+from markitecture.metrics.badges.base import BaseSvgGenerator
+
+
+class CompactBadgeGenerator(BaseSvgGenerator):
+    def __init__(
+        self,
+        width: int = 400,
+        height: int = 40,
+        gradient: Tuple[str, str] = ("#7934C5", "#4158D0"),
+    ):
+        super().__init__(width, height)
+        self.gradient = gradient
+
+    def generate(self, metrics: ReadabilityMetrics) -> str:
+        gradient_def = (
+            f"<defs>\n"
+            f"  <linearGradient id='gradientBg' x1='0%' y1='0%' x2='100%' y2='0%'>\n"
+            f"    <stop offset='0%' style='stop-color:{self.gradient[0]}' />\n"
+            f"    <stop offset='100%' style='stop-color:{self.gradient[1]}' />\n"
+            f"  </linearGradient>\n"
+            f"</defs>\n"
+        )
+        content = (
+            f"<!-- Compact badge content -->\n"
+            f"<rect x='0' y='0' width='{self.width}' height='{self.height}' rx='20' fill='white' "
+            f"stroke='url(#gradientBg)' stroke-width='2' />\n"
+            f"<text x='20' y='{self.height / 2}' font-family='Arial, sans-serif' font-size='14' fill='#666' "
+            f"dominant-baseline='middle'>"
+            f"{metrics.reading_time_mins}m read • {metrics.word_count:,} words • {metrics.complexity_score}% complexity"
+            f"</text>\n"
+        )
+        return self.render(gradient_def + content)

markitecture/metrics/badges/detailed.py

@@ -0,0 +1,60 @@
+from typing import Tuple
+
+from markitecture.metrics.analyzer import ReadabilityMetrics
+from markitecture.metrics.badges.base import BaseSvgGenerator
+
+
+class DetailedBadgeGenerator(BaseSvgGenerator):
+    def __init__(
+        self,
+        width: int = 600,
+        height: int = 200,
+        gradient: Tuple[str, str] = ("#7934C5", "#4158D0"),
+    ):
+        super().__init__(width, height)
+        self.gradient = gradient
+
+    def generate(self, metrics: ReadabilityMetrics) -> str:
+        gradient_def = (
+            f"<defs>\n"
+            f"  <linearGradient id='gradientBg' x1='0%' y1='0%' x2='100%' y2='0%'>\n"
+            f"    <stop offset='0%' style='stop-color:{self.gradient[0]}' />\n"
+            f"    <stop offset='100%' style='stop-color:{self.gradient[1]}' />\n"
+            f"  </linearGradient>\n"
+            f"  <filter id='shadow' x='-20%' y='-20%' width='140%' height='140%'>\n"
+            f"    <feGaussianBlur in='SourceAlpha' stdDeviation='2' />\n"
+            f"    <feOffset dx='2' dy='2' />\n"
+            f"    <feComponentTransfer>\n"
+            f"      <feFuncA type='linear' slope='0.2' />\n"
+            f"    </feComponentTransfer>\n"
+            f"    <feMerge>\n"
+            f"      <feMergeNode />\n"
+            f"      <feMergeNode in='SourceGraphic' />\n"
+            f"    </feMerge>\n"
+            f"  </filter>\n"
+            f"</defs>\n"
+        )
+        content = (
+            f"<!-- Detailed badge content -->\n"
+            f"<rect x='0' y='0' width='{self.width}' height='{self.height}' rx='15' fill='white' "
+            f"stroke='url(#gradientBg)' stroke-width='2' filter='url(#shadow)' />\n"
+            f"<text x='30' y='40' font-family='Arial, sans-serif' font-size='20' font-weight='bold' "
+            f"fill='url(#gradientBg)'>Document Analytics</text>\n"
+            f"<text x='30' y='80' font-family='Arial, sans-serif' font-size='14' fill='#666'>"
+            f"Reading Time: {metrics.reading_time_mins} minutes</text>\n"
+            f"<text x='30' y='105' font-family='Arial, sans-serif' font-size='14' fill='#666'>"
+            f"Word Count: {metrics.word_count:,}</text>\n"
+            f"<text x='30' y='130' font-family='Arial, sans-serif' font-size='14' fill='#666'>"
+            f"Avg Words/Sentence: {metrics.avg_words_per_sentence:.1f}</text>\n"
+            f"<text x='{self.width / 2 + 30}' y='80' font-family='Arial, sans-serif' font-size='14' fill='#666'>"
+            f"Headings: {metrics.heading_count}</text>\n"
+            f"<text x='{self.width / 2 + 30}' y='105' font-family='Arial, sans-serif' font-size='14' fill='#666'>"
+            f"Code Blocks: {metrics.code_block_count}</text>\n"
+            f"<text x='{self.width / 2 + 30}' y='130' font-family='Arial, sans-serif' font-size='14' fill='#666'>"
+            f"Links: {metrics.link_count}</text>\n"
+            f"<rect x='30' y='160' width='540' height='8' rx='4' fill='#eee' />\n"
+            f"<rect x='30' y='160' width='{5.4 * metrics.complexity_score}' height='8' rx='4' fill='url(#gradientBg)' />\n"
+            f"<text x='{self.width - 40}' y='170' font-family='Arial, sans-serif' font-size='12' fill='#666' text-anchor='end'>"
+            f"{metrics.complexity_score}% Complexity</text>\n"
+        )
+        return self.render(gradient_def + content)

markitecture/metrics/badges/minimal.py

@@ -0,0 +1,19 @@
+from markitecture.metrics.analyzer import ReadabilityMetrics
+from markitecture.metrics.badges.base import BaseSvgGenerator
+
+
+class MinimalBadgeGenerator(BaseSvgGenerator):
+    def __init__(self, width: int = 300, height: int = 80, color: str = "#7934C5"):
+        super().__init__(width, height)
+        self.color = color
+
+    def generate(self, metrics: ReadabilityMetrics) -> str:
+        content = (
+            f"<!-- Minimal badge content -->\n"
+            f"<rect x='0' y='0' width='{self.width}' height='{self.height}' fill='white' />\n"
+            f"<text x='20' y='30' font-family='Arial, sans-serif' font-size='16' fill='#333'>"
+            f"{metrics.reading_time_mins} min read</text>\n"
+            f"<text x='20' y='55' font-family='Arial, sans-serif' font-size='14' fill='{self.color}'>"
+            f"{metrics.complexity_score}% complexity</text>\n"
+        )
+        return self.render(content)

markitecture/metrics/badges/modern.py

@@ -0,0 +1,45 @@
+# markitecture/metrics/badges/modern.py
+from typing import Tuple
+
+from markitecture.metrics.analyzer import ReadabilityMetrics
+from markitecture.metrics.badges.base import BaseSvgGenerator
+
+
+class ModernBadgeGenerator(BaseSvgGenerator):
+    def __init__(
+        self,
+        width: int = 560,
+        height: int = 140,
+        gradient: Tuple[str, str] = ("#7934C5", "#4158D0"),
+    ):
+        super().__init__(width, height)
+        self.gradient = gradient
+
+    def generate(self, metrics: ReadabilityMetrics) -> str:
+        # Improved gradient with additional stops for a smoother transition.
+        gradient_def = (
+            f"<defs>\n"
+            f"  <linearGradient id='gradientBg' x1='0%' y1='0%' x2='100%' y2='0%'>\n"
+            f"    <stop offset='0%' style='stop-color:{self.gradient[0]}; stop-opacity:1' />\n"
+            f"    <stop offset='50%' style='stop-color:#6A2C70; stop-opacity:0.8' />\n"
+            f"    <stop offset='100%' style='stop-color:{self.gradient[1]}; stop-opacity:1' />\n"
+            f"  </linearGradient>\n"
+            f"  <filter id='dropShadow' x='-10%' y='-10%' width='120%' height='120%'>\n"
+            f"    <feGaussianBlur in='SourceAlpha' stdDeviation='3' />\n"
+            f"    <feOffset dx='3' dy='3' result='offsetblur'/>\n"
+            f"    <feMerge>\n"
+            f"      <feMergeNode/>\n"
+            f"      <feMergeNode in='SourceGraphic'/>\n"
+            f"    </feMerge>\n"
+            f"  </filter>\n"
+            f"</defs>\n"
+        )
+        content = (
+            f"<!-- Improved Modern badge content -->\n"
+            f"<rect x='0' y='0' width='{self.width}' height='{self.height}' fill='url(#gradientBg)' filter='url(#dropShadow)' rx='15'/>\n"
+            f"<text x='30' y='{self.height / 2 - 10}' font-family='Helvetica, Arial, sans-serif' font-size='24' fill='white' font-weight='bold'>"
+            f"{metrics.reading_time_mins} min read</text>\n"
+            f"<text x='30' y='{self.height / 2 + 20}' font-family='Helvetica, Arial, sans-serif' font-size='16' fill='white'>"
+            f"{metrics.word_count:,} words | {metrics.complexity_score}% complexity</text>\n"
+        )
+        return self.render(gradient_def + content)

markitecture/metrics/badges/retro.py

@@ -0,0 +1,23 @@
+from markitecture.metrics.analyzer import ReadabilityMetrics
+from markitecture.metrics.badges.base import BaseSvgGenerator
+
+
+class RetroBadgeGenerator(BaseSvgGenerator):
+    def __init__(self, width: int = 480, height: int = 120):
+        super().__init__(width, height)
+
+    def generate(self, metrics: ReadabilityMetrics) -> str:
+        content = (
+            f"<!-- Retro badge content -->\n"
+            f"<rect x='4' y='4' width='{self.width - 8}' height='{self.height - 8}' fill='white' stroke='#333' stroke-width='2' />\n"
+            f"<rect x='0' y='0' width='4' height='4' fill='#333' />\n"
+            f"<rect x='{self.width - 4}' y='0' width='4' height='4' fill='#333' />\n"
+            f"<rect x='0' y='{self.height - 4}' width='4' height='4' fill='#333' />\n"
+            f"<rect x='{self.width - 4}' y='{self.height - 4}' width='4' height='4' fill='#333' />\n"
+            f"<text x='{self.width / 2}' y='40' font-family='Courier, monospace' font-size='16' fill='#333' text-anchor='middle'>DOCUMENT METRICS</text>\n"
+            f"<text x='{self.width / 2}' y='70' font-family='Courier, monospace' font-size='14' fill='#666' text-anchor='middle'>"
+            f"{metrics.reading_time_mins}m | {metrics.word_count:,} words | {metrics.complexity_score}% comp.</text>\n"
+            f"<text x='{self.width / 2}' y='95' font-family='Courier, monospace' font-size='12' fill='#999' text-anchor='middle'>"
+            f"H:{metrics.heading_count} C:{metrics.code_block_count} L:{metrics.link_count} I:{metrics.image_count}</text>\n"
+        )
+        return self.render(content)