mdx-viewer 0.1.0__tar.gz

mdx_viewer-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: mdx-viewer
+Version: 0.1.0
+Summary: A beautiful Markdown viewer for terminal with code execution support
+Author-email: Your Name <you@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mmx8lb/mdx
+Project-URL: Repository, https://github.com/mmx8lb/mdx
+Keywords: markdown,terminal,cli,viewer
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+
+# MDX - Markdown Viewer for Terminal
+
+<p align="center">
+  <img src="https://img.shields.io/pypi/v/mdx" alt="PyPI">
+  <img src="https://img.shields.io/pypi/l/mdx" alt="License">
+  <img src="https://img.shields.io/pypi/pyversions/mdx" alt="Python">
+</p>
+
+A beautiful Markdown viewer for terminal with code execution support.
+
+## Features
+
+- 🎨 Beautiful syntax highlighting with multiple themes
+- 📑 Table of contents navigation
+- ⚡ Execute code blocks directly (bash, python)
+- 🔍 Search within documents
+- 📖 Multiple rendering modes
+
+## Installation
+
+```bash
+pip install mdx
+```
+
+## Usage
+
+```bash
+# View a markdown file
+mdx README.md
+
+# Show table of contents
+mdx README.md --toc
+
+# Execute code blocks
+mdx README.md --execute
+
+# Jump to specific line
+mdx README.md --line 100
+
+# Use different theme
+mdx README.md --theme dracula
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `-e, --execute` | Execute code blocks |
+| `-t, --toc` | Show table of contents |
+| `-l, --line` | Jump to specific line |
+| `-m, --theme` | Syntax highlighting theme |
+
+## Themes
+
+Available syntax highlighting themes:
+- monokai (default)
+- dracula
+- github-dark
+- nord
+- solarized-dark
+
+## Example
+
+```bash
+# Read documentation
+mdx docs/linux-0.11-filesystem-analysis.md --toc
+
+# Execute tutorial code blocks
+mdx docs/tutorial.md --execute
+```
+
+## License
+
+MIT License

mdx_viewer-0.1.0/README.md

@@ -0,0 +1,74 @@
+# MDX - Markdown Viewer for Terminal
+
+<p align="center">
+  <img src="https://img.shields.io/pypi/v/mdx" alt="PyPI">
+  <img src="https://img.shields.io/pypi/l/mdx" alt="License">
+  <img src="https://img.shields.io/pypi/pyversions/mdx" alt="Python">
+</p>
+
+A beautiful Markdown viewer for terminal with code execution support.
+
+## Features
+
+- 🎨 Beautiful syntax highlighting with multiple themes
+- 📑 Table of contents navigation
+- ⚡ Execute code blocks directly (bash, python)
+- 🔍 Search within documents
+- 📖 Multiple rendering modes
+
+## Installation
+
+```bash
+pip install mdx
+```
+
+## Usage
+
+```bash
+# View a markdown file
+mdx README.md
+
+# Show table of contents
+mdx README.md --toc
+
+# Execute code blocks
+mdx README.md --execute
+
+# Jump to specific line
+mdx README.md --line 100
+
+# Use different theme
+mdx README.md --theme dracula
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `-e, --execute` | Execute code blocks |
+| `-t, --toc` | Show table of contents |
+| `-l, --line` | Jump to specific line |
+| `-m, --theme` | Syntax highlighting theme |
+
+## Themes
+
+Available syntax highlighting themes:
+- monokai (default)
+- dracula
+- github-dark
+- nord
+- solarized-dark
+
+## Example
+
+```bash
+# Read documentation
+mdx docs/linux-0.11-filesystem-analysis.md --toc
+
+# Execute tutorial code blocks
+mdx docs/tutorial.md --execute
+```
+
+## License
+
+MIT License

mdx_viewer-0.1.0/mdx/__init__.py

@@ -0,0 +1,9 @@
+"""MDX - A beautiful Markdown viewer for terminal"""
+
+__version__ = "0.1.0"
+
+from .cli import main
+from .parser import MarkdownParser
+from .renderer import TerminalRenderer
+
+__all__ = ["main", "MarkdownParser", "TerminalRenderer"]

mdx_viewer-0.1.0/mdx/cli.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+MDX - A beautiful Markdown viewer for terminal
+"""
+
+import click
+import curses
+from pathlib import Path
+from .parser import MarkdownParser
+from .renderer import TerminalRenderer
+
+
+class MDXViewer:
+    """Main MDX viewer class"""
+    
+    def __init__(self, filepath: str):
+        self.filepath = Path(filepath)
+        self.content = self.filepath.read_text()
+        self.parser = MarkdownParser(self.content)
+        self.parsed_content = self.parser.parse()
+        self.renderer = TerminalRenderer()
+        self.scroll = 0
+    
+    def run(self):
+        """Run the viewer"""
+        def run_curses(stdscr):
+            self._run_interactive(stdscr)
+        
+        curses.wrapper(run_curses)
+    
+    def _run_interactive(self, stdscr):
+        """Run interactive mode with curses"""
+        import time
+        
+        try:
+            stdscr.nodelay(True)
+            last_scroll = -1
+            last_screen_size = (0, 0)
+            
+            # Initial render
+            self.renderer.render(stdscr, self.parsed_content, self.scroll)
+            last_scroll = self.scroll
+            
+            while True:
+                try:
+                    # Get key press
+                    key = stdscr.getch()
+                    
+                    # Handle keys (less-style)
+                    if key == ord('q'):
+                        break
+                    elif key in [ord('j'), ord('J'), curses.KEY_DOWN]:
+                        self.scroll_down()
+                        # Force render on key press
+                        self.renderer.render(stdscr, self.parsed_content, self.scroll)
+                        last_scroll = self.scroll
+                    elif key in [ord('k'), ord('K'), curses.KEY_UP]:
+                        self.scroll_up()
+                        # Force render on key press
+                        self.renderer.render(stdscr, self.parsed_content, self.scroll)
+                        last_scroll = self.scroll
+                    elif key in [ord('g')]:
+                        self.scroll_to_top()
+                        # Force render on key press
+                        self.renderer.render(stdscr, self.parsed_content, self.scroll)
+                        last_scroll = self.scroll
+                    elif key in [ord('G')]:
+                        self.scroll_to_bottom()
+                        # Force render on key press
+                        self.renderer.render(stdscr, self.parsed_content, self.scroll)
+                        last_scroll = self.scroll
+                    elif key in [ord(' '), ord('f')]:
+                        self.scroll_down(10)
+                        # Force render on key press
+                        self.renderer.render(stdscr, self.parsed_content, self.scroll)
+                        last_scroll = self.scroll
+                    elif key in [ord('b')]:
+                        self.scroll_up(10)
+                        # Force render on key press
+                        self.renderer.render(stdscr, self.parsed_content, self.scroll)
+                        last_scroll = self.scroll
+                    elif key in [ord('/')]:
+                        # Simple search (to be implemented)
+                        pass
+                    elif key in [ord('n')]:
+                        # Next search result (to be implemented)
+                        pass
+                    elif key in [ord('N')]:
+                        # Previous search result (to be implemented)
+                        pass
+                    
+                    # Small delay to reduce CPU usage but maintain responsiveness
+                    time.sleep(0.005)
+                    
+                except KeyboardInterrupt:
+                    # Handle Ctrl+C gracefully
+                    break
+                except Exception as e:
+                    # Display error
+                    try:
+                        stdscr.clear()
+                        stdscr.addstr(0, 0, f"Error: {str(e)}", curses.A_REVERSE | curses.A_BOLD)
+                        stdscr.addstr(2, 0, "Press q to exit", curses.A_DIM)
+                        stdscr.refresh()
+                        time.sleep(2)
+                    except:
+                        pass
+                    break
+        except KeyboardInterrupt:
+            # Handle Ctrl+C at the outer level
+            pass
+        except Exception as e:
+            # Display overall error
+            try:
+                stdscr.clear()
+                stdscr.addstr(0, 0, f"Fatal error: {str(e)}", curses.A_REVERSE | curses.A_BOLD)
+                stdscr.addstr(2, 0, "Press any key to exit", curses.A_DIM)
+                stdscr.refresh()
+                stdscr.getch()  # Wait for user input
+            except:
+                pass
+    
+    def scroll_down(self, n: int = 1):
+        """Scroll down by n lines"""
+        # Get actual terminal height for dynamic calculation
+        import shutil
+        try:
+            height = shutil.get_terminal_size().lines
+            content_height = max(10, height - 5)  # Reserve space for header and status
+        except:
+            content_height = 20  # Fallback to reasonable default
+        max_scroll = max(0, len(self.parsed_content) - content_height)
+        self.scroll = min(max_scroll, self.scroll + n)
+    
+    def scroll_up(self, n: int = 1):
+        """Scroll up by n lines"""
+        self.scroll = max(0, self.scroll - n)
+    
+    def scroll_to_top(self):
+        """Scroll to top"""
+        self.scroll = 0
+    
+    def scroll_to_bottom(self):
+        """Scroll to bottom"""
+        # Get actual terminal height for dynamic calculation
+        import shutil
+        try:
+            height = shutil.get_terminal_size().lines
+            content_height = max(10, height - 5)  # Reserve space for header and status
+        except:
+            content_height = 20  # Fallback to reasonable default
+        self.scroll = max(0, len(self.parsed_content) - content_height)
+
+
+def main():
+    """Main entry point"""
+    @click.command()
+    @click.argument('file', type=click.Path(exists=True))
+    @click.version_option(version='1.0.0', prog_name='mdx')
+    def cli(file):
+        """MDX - Markdown Viewer for Terminal
+        
+        View Markdown files in the terminal with beautiful formatting.
+        """
+        viewer = MDXViewer(file)
+        viewer.run()
+    
+    cli()
+
+
+if __name__ == '__main__':
+    main()

mdx_viewer-0.1.0/mdx/parser.py

@@ -0,0 +1,158 @@
+"""Markdown parser module"""
+
+import re
+from typing import List, Tuple, Dict, Any
+
+
+class MarkdownParser:
+    """Markdown parser class"""
+    
+    def __init__(self, content: str):
+        self.content = content
+        self.lines = content.split('\n')
+    
+    def parse(self) -> List[Tuple[str, Any]]:
+        """Parse markdown content into structured data"""
+        result = []
+        in_code = False
+        code_lang = ""
+        code_lines = []
+        in_table = False
+        table_lines = []
+        
+        try:
+            for line in self.lines:
+                try:
+                    stripped = line.strip()
+                    
+                    # Code block handling
+                    if stripped.startswith('```'):
+                        if not in_code:
+                            in_code = True
+                            code_lang = stripped[3:].strip() or "text"
+                            code_lines = []
+                        else:
+                            in_code = False
+                            result.append(('code_block', (code_lang, code_lines)))
+                        continue
+                    
+                    if in_code:
+                        code_lines.append(line)
+                        continue
+                    
+                    # Table handling
+                    if stripped.startswith('|') and '|' in stripped:
+                        if not in_table:
+                            in_table = True
+                            table_lines = []
+                        table_lines.append(line)
+                        continue
+                    elif in_table:
+                        in_table = False
+                        result.append(('table', table_lines))
+                        table_lines = []
+                    
+                    # Header
+                    if stripped.startswith('#'):
+                        level = len(stripped) - len(stripped.lstrip('#'))
+                        if level <= 6:
+                            title = stripped.lstrip('#').strip()
+                            result.append(('header', (level, title)))
+                        continue
+                    
+                    # Horizontal rule
+                    if stripped in ['---', '***', '___']:
+                        result.append(('hr', None))
+                        continue
+                    
+                    # List item
+                    if stripped.startswith(('- ', '* ', '+ ')):
+                        content = stripped[2:]
+                        result.append(('list_item', ('unordered', content)))
+                        continue
+                    
+                    # Numbered list
+                    m = re.match(r'^\d+\.\s+(.*)', stripped)
+                    if m:
+                        result.append(('list_item', ('ordered', m.group(1))))
+                        continue
+                    
+                    # Blockquote
+                    if stripped.startswith('>'):
+                        content = stripped[1:].strip()
+                        result.append(('blockquote', content))
+                        continue
+                    
+                    # Bold and italic
+                    if '**' in line or '*' in line:
+                        result.append(('text', line))
+                        continue
+                    
+                    # Regular text
+                    result.append(('text', line))
+                except Exception as e:
+                    # Handle line-level parsing errors
+                    result.append(('text', line))  # Fallback to plain text
+        except Exception as e:
+            # Handle major parsing errors
+            result = [('text', f"Error parsing markdown: {str(e)}")]
+        
+        # Handle any remaining table
+        if in_table and table_lines:
+            try:
+                result.append(('table', table_lines))
+            except:
+                # Fallback if table parsing fails
+                for line in table_lines:
+                    result.append(('text', line))
+        
+        return result
+    
+    def parse_table(self, table_lines: List[str]) -> Dict[str, Any]:
+        """Parse table lines into structured data"""
+        if not table_lines:
+            return {}
+        
+        # Parse header
+        header = table_lines[0].strip().split('|')
+        header = [h.strip() for h in header if h.strip()]
+        num_columns = len(header)
+        
+        # Parse alignment
+        alignment = []
+        if len(table_lines) > 1:
+            align_line = table_lines[1].strip().split('|')
+            for i, cell in enumerate(align_line):
+                if i == 0 or i == len(align_line) - 1:
+                    continue
+                cell = cell.strip()
+                if cell.startswith(':') and cell.endswith(':'):
+                    alignment.append('center')
+                elif cell.startswith(':'):
+                    alignment.append('left')
+                elif cell.endswith(':'):
+                    alignment.append('right')
+                else:
+                    alignment.append('left')
+        
+        # Parse rows
+        rows = []
+        # Start from index 2 if there's an alignment line and data rows
+        # Skip processing if there are no data rows
+        if len(table_lines) > 2:
+            for line in table_lines[2:]:
+                cells = line.strip().split('|')
+                cells = [c.strip() for c in cells if c.strip()]
+                # Ensure each row has the same number of columns as header
+                while len(cells) < num_columns:
+                    cells.append('')
+                if len(cells) > num_columns:
+                    cells = cells[:num_columns]
+                if cells:
+                    rows.append(cells)
+        
+        return {
+            'header': header,
+            'alignment': alignment,
+            'rows': rows
+        }