aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/copier-aegis-project/{{ project_slug }}/app/cli/main.py.jinja

@@ -0,0 +1,65 @@
+"""
+Main CLI application entry point.
+
+Command-line interface for {{ project_slug }} management tasks.
+"""
+
+import importlib
+from typing import TYPE_CHECKING
+
+import typer
+
+from app.cli import health
+
+if TYPE_CHECKING:
+    pass
+
+app = typer.Typer(
+    name="{{ project_slug }}",
+    help="{{ project_slug }} management CLI",
+    no_args_is_help=True,
+)
+
+# Register sub-commands
+app.add_typer(health.app, name="health")
+
+# Conditionally register load-test command if worker components are available
+try:
+    load_test_module = importlib.import_module("app.cli.load_test")
+    app.add_typer(load_test_module.app, name="load-test")
+except ImportError:
+    # Worker components not available, skip load-test commands
+    pass
+
+# Conditionally register tasks command if scheduler components are available
+try:
+    tasks_module = importlib.import_module("app.cli.tasks")
+    app.add_typer(tasks_module.app, name="tasks")
+except (ImportError, AttributeError):
+    # Scheduler components not available or tasks module incomplete, skip tasks commands
+    pass
+
+# Conditionally register auth command if auth service is available
+try:
+    auth_module = importlib.import_module("app.cli.auth")
+    app.add_typer(auth_module.app, name="auth")
+except ImportError:
+    # Auth service not available, skip auth commands
+    pass
+
+# Conditionally register ai command if ai service is available
+try:
+    ai_module = importlib.import_module("app.cli.ai")
+    app.add_typer(ai_module.app, name="ai")
+except ImportError:
+    # AI service not available, skip ai commands
+    pass
+
+
+def main() -> None:
+    """Entry point for the CLI application."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

aegis/templates/copier-aegis-project/{{ project_slug }}/app/cli/marko_terminal_renderer.py

@@ -0,0 +1,489 @@
+"""
+Custom terminal renderer for marko markdown parser.
+
+Renders markdown elements as ANSI-styled strings for beautiful terminal output.
+Integrates with Rich Console for output management while keeping rendering simple.
+"""
+
+from marko.renderer import Renderer
+
+
+class TerminalRenderer(Renderer):
+    """
+    Terminal renderer that outputs ANSI-styled strings.
+
+    Renders markdown elements with ANSI escape codes for colored,
+    styled terminal output. Works with Rich Console for output but
+    doesn't depend on Rich components.
+    """
+
+    def _get_content(self, element) -> str:
+        """
+        Safely get content from element, handling both string and list children.
+
+        Args:
+            element: Element with children attribute
+
+        Returns:
+            String content
+        """
+        # If children is already a string, return it
+        if isinstance(element.children, str):
+            return element.children
+        # Otherwise render children as normal
+        return self.render_children(element)
+
+    def render_document(self, element) -> str:
+        """Render the root document element."""
+        return self.render_children(element)
+
+    def render_heading(self, element) -> str:
+        """
+        Render heading with ANSI color codes based on level.
+
+        Args:
+            element: Heading element with level attribute
+
+        Returns:
+            ANSI-styled heading string
+        """
+        # Extract heading level (h1=1, h2=2, h3=3, etc.)
+        level = int(element.level)
+
+        # Render children to get heading text
+        content = self.render_children(element)
+
+        # Color codes by level
+        colors = {
+            1: "\033[1;32m",  # Bold green
+            2: "\033[1;36m",  # Bold cyan
+            3: "\033[1;34m",  # Bold blue
+        }
+        reset = "\033[0m"
+
+        # Get color for this level (default to bold white)
+        color = colors.get(level, "\033[1;37m")
+
+        # Clean title rendering (no ### prefix)
+        return f"{color}{content}{reset}\n"
+
+    def render_fenced_code(self, element) -> str:
+        """
+        Render fenced code block with syntax highlighting.
+
+        Args:
+            element: Fenced code element with lang and children
+
+        Returns:
+            Code block with syntax highlighting (no background)
+        """
+        # Get code content from children (safely handles string or list)
+        code = self._get_content(element)
+        lang = getattr(element, "lang", "") or "text"
+
+        if not code or not code.strip():
+            return ""
+
+        # Try to use pygments for syntax highlighting if available
+        try:
+            from pygments import highlight
+            from pygments.formatters import Terminal256Formatter
+            from pygments.lexers import get_lexer_by_name
+            from pygments.util import ClassNotFound
+
+            try:
+                lexer = get_lexer_by_name(lang, stripall=True)
+                formatter = Terminal256Formatter(style="monokai")
+                highlighted = highlight(code, lexer, formatter)
+
+                # Process each line: add indentation only
+                lines = highlighted.rstrip("\n").split("\n")
+                formatted_lines = []
+                for line in lines:
+                    # Add 4-space indentation
+                    formatted_lines.append(f"    {line}")
+
+                result = "\n".join(formatted_lines)
+                # Add blank lines before/after
+                return f"\n{result}\n\n"
+
+            except ClassNotFound:
+                # Lexer not found, fall back to plain display
+                pass
+
+        except ImportError:
+            # Pygments not available, use plain display
+            pass
+
+        # Fallback: plain code with indentation
+        lines = code.strip().split("\n")
+        formatted_lines = []
+        for line in lines:
+            formatted_lines.append(f"    {line}")
+
+        result = "\n".join(formatted_lines)
+        return f"\n{result}\n\n"
+
+    def render_code_block(self, element) -> str:
+        """Render indented code block with simple indentation."""
+        code = self._get_content(element)
+
+        if not code or not code.strip():
+            return ""
+
+        # Simple indented code (no background)
+        lines = code.strip().split("\n")
+        formatted_lines = []
+        for line in lines:
+            formatted_lines.append(f"    {line}")
+
+        result = "\n".join(formatted_lines)
+        return f"\n{result}\n\n"
+
+    def render_list(self, element) -> str:
+        """Render bullet or ordered list."""
+        return self.render_children(element)
+
+    def render_list_item(self, element) -> str:
+        """
+        Render list item with styled bullet.
+
+        Args:
+            element: List item element
+
+        Returns:
+            Styled list item string
+        """
+        content = self.render_children(element).strip()
+
+        # Yellow bullet with proper indentation
+        bullet_color = "\033[93m"  # Bright yellow
+        reset = "\033[0m"
+
+        return f"  {bullet_color}•{reset} {content}\n"
+
+    def render_paragraph(self, element) -> str:
+        """
+        Render paragraph as plain text.
+
+        Args:
+            element: Paragraph element
+
+        Returns:
+            Paragraph text with newline
+        """
+        content = self.render_children(element)
+        return f"{content}\n"
+
+    def render_blank_line(self, element) -> str:
+        """
+        Render blank line.
+
+        Args:
+            element: Blank line element
+
+        Returns:
+            Single newline
+        """
+        return "\n"
+
+    def render_emphasis(self, element) -> str:
+        """
+        Render italic text with ANSI codes.
+
+        Args:
+            element: Emphasis element
+
+        Returns:
+            Italic styled string
+        """
+        content = self.render_children(element)
+        return f"\033[3m{content}\033[0m"  # Italic
+
+    def render_strong_emphasis(self, element) -> str:
+        """
+        Render bold text with ANSI codes.
+
+        Args:
+            element: Strong emphasis element
+
+        Returns:
+            Bold styled string
+        """
+        content = self.render_children(element)
+        return f"\033[1m{content}\033[0m"  # Bold
+
+    def render_code_span(self, element) -> str:
+        """
+        Render inline code with background color.
+
+        Args:
+            element: Inline code element
+
+        Returns:
+            Styled inline code string
+        """
+        content = self._get_content(element)
+        # Bright magenta on black background
+        return f"\033[95;40m{content}\033[0m"
+
+    def render_raw_text(self, element) -> str:
+        """
+        Render raw text content.
+
+        Args:
+            element: Raw text element
+
+        Returns:
+            Plain text string
+        """
+        # RawText.children is already a string, not a list
+        # Just return it directly
+        if isinstance(element.children, str):
+            return element.children
+        # Fallback for safety
+        return str(element.children)
+
+    def render_line_break(self, element) -> str:
+        """Render line break."""
+        return "\n"
+
+    def render_link(self, element) -> str:
+        """
+        Render hyperlink.
+
+        Args:
+            element: Link element
+
+        Returns:
+            Link text (URLs hidden in terminal)
+        """
+        content = self.render_children(element)
+        # Just show the link text, not the URL (terminal limitation)
+        return content
+
+    def render_image(self, element) -> str:
+        """
+        Render image placeholder.
+
+        Args:
+            element: Image element
+
+        Returns:
+            Image placeholder text
+        """
+        title = getattr(element, "title", "") or "image"
+        return f"🖼️  [{title}]"
+
+    def render_thematic_break(self, element) -> str:
+        """Render horizontal rule."""
+        return f"\033[2m{'─' * 60}\033[0m\n"
+
+    def render_block_quote(self, element) -> str:
+        """
+        Render block quote with left border.
+
+        Args:
+            element: Block quote element
+
+        Returns:
+            Quoted text with border
+        """
+        content = self.render_children(element)
+        lines = content.strip().split("\n")
+
+        border = "\033[36m│\033[0m"  # Cyan border
+        result = []
+        for line in lines:
+            result.append(f"{border} {line}")
+
+        return "\n".join(result) + "\n"
+
+    def render_table(self, element) -> str:
+        """
+        Render table with aligned columns using two-pass approach.
+
+        Args:
+            element: Table element from GFM
+
+        Returns:
+            Formatted table string
+        """
+        rows = element.children
+        if not rows:
+            return ""
+
+        # First pass: render all cells and collect metadata
+        rendered_rows = []
+        for row in rows:
+            rendered_cells = []
+            for cell in row.children:
+                content = self.render_children(cell)
+                is_header = cell.header
+                rendered_cells.append((content, is_header))
+            rendered_rows.append(rendered_cells)
+
+        # Calculate column widths from rendered content
+        col_widths = self._calculate_widths_from_rendered(rendered_rows)
+
+        # Second pass: format rows with alignment and styling
+        result = []
+        for i, rendered_cells in enumerate(rendered_rows):
+            row_parts = []
+            for j, (content, is_header) in enumerate(rendered_cells):
+                # Strip ANSI for padding calculation
+                clean = self._strip_ansi(content)
+                padding = col_widths[j] - len(clean)
+
+                # Apply header styling
+                styled = f"\033[1;36m{content}\033[0m" if is_header else content
+
+                padded = styled + (" " * padding)
+                row_parts.append(padded)
+
+            row_text = "| " + " | ".join(row_parts) + " |"
+            result.append(row_text)
+
+            # Add separator after header row
+            if i == 0:
+                separator = self._render_table_separator(col_widths)
+                result.append(separator)
+
+        return "\n" + "\n".join(result) + "\n\n"
+
+    def render_table_row(self, element) -> str:
+        """
+        Render table row - return empty as table handles rendering.
+
+        Args:
+            element: TableRow element
+
+        Returns:
+            Empty string (rendering handled by render_table)
+        """
+        # Table rendering is handled entirely by render_table
+        # This method must exist for marko but returns empty
+        return ""
+
+    def render_table_cell(self, element) -> str:
+        """
+        Render cell content without styling.
+
+        Args:
+            element: TableCell element
+
+        Returns:
+            Plain cell content (styling applied by render_table)
+        """
+        # Just render children (safely), styling happens in render_table
+        return self._get_content(element)
+
+    def _calculate_widths_from_rendered(
+        self, rendered_rows: list[list[tuple[str, bool]]]
+    ) -> list[int]:
+        """
+        Calculate column widths from pre-rendered cells.
+
+        Args:
+            rendered_rows: List of rows, each row is list of (content, is_header)
+
+        Returns:
+            List of column widths
+        """
+        col_widths = []
+        max_cols = max(len(row) for row in rendered_rows)
+
+        for col_idx in range(max_cols):
+            max_width = 0
+            for row in rendered_rows:
+                if col_idx < len(row):
+                    content, _ = row[col_idx]
+                    clean = self._strip_ansi(content)
+                    max_width = max(max_width, len(clean))
+            col_widths.append(max_width)
+
+        return col_widths
+
+    def _strip_ansi(self, text: str) -> str:
+        """
+        Strip ANSI escape codes for width calculation.
+
+        Args:
+            text: Text with ANSI codes
+
+        Returns:
+            Clean text without ANSI codes
+        """
+        import re
+
+        ansi_pattern = re.compile(r"\x1b\[[0-9;]*m")
+        return ansi_pattern.sub("", text)
+
+    def _render_table_separator(self, col_widths: list[int]) -> str:
+        """
+        Render separator line between header and body.
+
+        Args:
+            col_widths: List of column widths
+
+        Returns:
+            Separator line string
+        """
+        segments = ["-" * (width + 2) for width in col_widths]
+        return "|" + "|".join(segments) + "|"
+
+    def render_strikethrough(self, element) -> str:
+        """
+        Render strikethrough text (~~text~~) with dim styling.
+
+        Args:
+            element: Strikethrough element from GFM extension
+
+        Returns:
+            Dimmed/faint text string
+        """
+        content = self._get_content(element)
+        return f"\033[2m{content}\033[0m"  # Dim/faint text
+
+    def render_url(self, element) -> str:
+        """
+        Render autolinked URLs.
+
+        Args:
+            element: URL element from GFM extension
+
+        Returns:
+            Cyan-colored URL string
+        """
+        url = element.dest if hasattr(element, "dest") else str(element.children)
+        return f"\033[36m{url}\033[0m"  # Cyan color
+
+    def __getattr__(self, name: str):
+        """
+        Fallback for any missing render methods.
+
+        Prevents crashes from unknown GFM elements by providing a generic
+        renderer that outputs plain text. This ensures compatibility with
+        future GFM extensions or elements we haven't explicitly handled.
+
+        Args:
+            name: Attribute name being accessed
+
+        Returns:
+            Fallback render function for render_* methods
+
+        Raises:
+            AttributeError: If attribute is not a render method
+        """
+        if name.startswith("render_"):
+
+            def fallback_render(element):
+                """Generic fallback - renders as plain text."""
+                if hasattr(element, "children"):
+                    return self.render_children(element)
+                return str(element)
+
+            return fallback_render
+        raise AttributeError(
+            f"'{type(self).__name__}' object has no attribute '{name}'"
+        )