reveal-cli 0.8.0__py3-none-any.whl

reveal/analyzers/gdscript.py

@@ -0,0 +1,176 @@
+"""GDScript file analyzer - for Godot game engine scripts."""
+
+import re
+from typing import Dict, List, Any, Optional
+from ..base import FileAnalyzer, register
+
+
+@register('.gd', name='GDScript', icon='🎮')
+class GDScriptAnalyzer(FileAnalyzer):
+    """GDScript file analyzer for Godot Engine.
+
+    Extracts classes, functions, signals, and variables.
+    """
+
+    def get_structure(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract GDScript structure."""
+        classes = []
+        functions = []
+        signals = []
+        variables = []
+
+        for i, line in enumerate(self.lines, 1):
+            # Match class definition: class ClassName:
+            class_match = re.match(r'^\s*class\s+(\w+)\s*:', line)
+            if class_match:
+                classes.append({
+                    'line': i,
+                    'name': class_match.group(1),
+                })
+                continue
+
+            # Match function definition: func function_name(...):
+            func_match = re.match(r'^\s*func\s+(\w+)\s*\((.*?)\)\s*(?:->\s*(.+?))?\s*:', line)
+            if func_match:
+                name = func_match.group(1)
+                params = func_match.group(2).strip()
+                return_type = func_match.group(3).strip() if func_match.group(3) else None
+
+                signature = f"({params})"
+                if return_type:
+                    signature += f" -> {return_type}"
+
+                functions.append({
+                    'line': i,
+                    'name': name,
+                    'signature': signature,
+                })
+                continue
+
+            # Match signal: signal signal_name or signal signal_name(params)
+            signal_match = re.match(r'^\s*signal\s+(\w+)(?:\((.*?)\))?\s*$', line)
+            if signal_match:
+                name = signal_match.group(1)
+                params = signal_match.group(2) if signal_match.group(2) else ''
+
+                signals.append({
+                    'line': i,
+                    'name': name,
+                    'signature': f"({params})" if params else "()",
+                })
+                continue
+
+            # Match variables: var/const/export
+            var_match = re.match(r'^\s*(?:(export|onready)\s+)?(?:(var|const)\s+)?(\w+)(?:\s*:\s*(\w+))?(?:\s*=\s*(.+?))?\s*(?:#.*)?$', line)
+            if var_match and var_match.group(2) in ('var', 'const'):
+                modifier = var_match.group(1) or ''
+                var_type = var_match.group(2)
+                name = var_match.group(3)
+                type_hint = var_match.group(4) or ''
+
+                # Skip if this looks like a function call or other syntax
+                if name and not name.startswith('_'):
+                    var_kind = f"{modifier} {var_type}".strip()
+                    type_info = f": {type_hint}" if type_hint else ""
+
+                    variables.append({
+                        'line': i,
+                        'name': name,
+                        'kind': var_kind,
+                        'type': type_hint or 'Variant',
+                    })
+
+        result = {}
+        if classes:
+            result['classes'] = classes
+        if functions:
+            result['functions'] = functions
+        if signals:
+            result['signals'] = signals
+        if variables:
+            result['variables'] = variables
+
+        return result
+
+    def extract_element(self, element_type: str, name: str) -> Optional[Dict[str, Any]]:
+        """Extract a specific GDScript element.
+
+        Args:
+            element_type: 'function', 'class', 'signal', or 'variable'
+            name: Name of the element
+
+        Returns:
+            Dict with element info and source
+        """
+        # Find the element
+        for i, line in enumerate(self.lines, 1):
+            # Check for function
+            if element_type == 'function':
+                func_match = re.match(r'^\s*func\s+(\w+)\s*\(', line)
+                if func_match and func_match.group(1) == name:
+                    return self._extract_function(i)
+
+            # Check for class
+            elif element_type == 'class':
+                class_match = re.match(r'^\s*class\s+(\w+)\s*:', line)
+                if class_match and class_match.group(1) == name:
+                    return self._extract_class(i)
+
+            # Check for signal or variable (single line)
+            elif re.search(rf'\b{re.escape(name)}\b', line):
+                return {
+                    'name': name,
+                    'line_start': i,
+                    'line_end': i,
+                    'source': line,
+                }
+
+        # Fallback to grep-based search
+        return super().extract_element(element_type, name)
+
+    def _extract_function(self, start_line: int) -> Dict[str, Any]:
+        """Extract a complete function definition."""
+        # Find the end of the function (next func/class/end of file)
+        indent_level = len(self.lines[start_line - 1]) - len(self.lines[start_line - 1].lstrip())
+        end_line = len(self.lines)
+
+        for i in range(start_line, len(self.lines)):
+            line = self.lines[i]
+            # Check if we've hit another function/class at same or lower indent
+            if line.strip() and not line.startswith('#'):
+                current_indent = len(line) - len(line.lstrip())
+                if current_indent <= indent_level and (line.strip().startswith('func ') or line.strip().startswith('class ')):
+                    end_line = i
+                    break
+
+        source = '\n'.join(self.lines[start_line - 1:end_line])
+
+        return {
+            'name': re.search(r'func\s+(\w+)', self.lines[start_line - 1]).group(1),
+            'line_start': start_line,
+            'line_end': end_line,
+            'source': source,
+        }
+
+    def _extract_class(self, start_line: int) -> Dict[str, Any]:
+        """Extract a complete class definition."""
+        # Find the end of the class (next class at same level or end of file)
+        indent_level = len(self.lines[start_line - 1]) - len(self.lines[start_line - 1].lstrip())
+        end_line = len(self.lines)
+
+        for i in range(start_line, len(self.lines)):
+            line = self.lines[i]
+            if line.strip() and not line.startswith('#'):
+                current_indent = len(line) - len(line.lstrip())
+                if current_indent <= indent_level and line.strip().startswith('class '):
+                    end_line = i
+                    break
+
+        source = '\n'.join(self.lines[start_line - 1:end_line])
+
+        return {
+            'name': re.search(r'class\s+(\w+)', self.lines[start_line - 1]).group(1),
+            'line_start': start_line,
+            'line_end': end_line,
+            'source': source,
+        }

reveal/analyzers/go.py

@@ -0,0 +1,13 @@
+"""Go file analyzer - tree-sitter based."""
+
+from ..base import register
+from ..treesitter import TreeSitterAnalyzer
+
+
+@register('.go', name='Go', icon='🔷')
+class GoAnalyzer(TreeSitterAnalyzer):
+    """Go file analyzer.
+
+    Full Go support in 3 lines!
+    """
+    language = 'go'

reveal/analyzers/javascript.py

@@ -0,0 +1,21 @@
+"""JavaScript file analyzer - tree-sitter based."""
+
+from ..base import register
+from ..treesitter import TreeSitterAnalyzer
+
+
+@register('.js', name='JavaScript', icon='📜')
+class JavaScriptAnalyzer(TreeSitterAnalyzer):
+    """JavaScript file analyzer.
+
+    Full JavaScript support via tree-sitter!
+    Extracts:
+    - Import/export statements
+    - Function declarations
+    - Class definitions
+    - Arrow functions
+    - Object methods
+
+    Works on all platforms (Windows, Linux, macOS).
+    """
+    language = 'javascript'

reveal/analyzers/jupyter_analyzer.py

@@ -0,0 +1,230 @@
+"""Jupyter Notebook (.ipynb) analyzer."""
+
+import json
+from typing import Dict, Any, List, Optional
+from ..base import FileAnalyzer, register
+
+
+@register('.ipynb', name='Jupyter', icon='📓')
+class JupyterAnalyzer(FileAnalyzer):
+    """Analyzer for Jupyter Notebook files"""
+
+    def __init__(self, path: str):
+        super().__init__(path)
+        self.parse_error = None
+        self.notebook_data = None
+        self.cells = []
+        self.metadata = {}
+
+        try:
+            self.notebook_data = json.loads(self.content)
+            self.cells = self.notebook_data.get('cells', [])
+            self.metadata = self.notebook_data.get('metadata', {})
+        except Exception as e:
+            self.parse_error = str(e)
+
+    def get_structure(self) -> Dict[str, Any]:
+        """Analyze Jupyter notebook structure."""
+        if self.parse_error:
+            return {
+                'error': self.parse_error,
+                'cells': [],
+                'cell_counts': {},
+                'kernel': 'unknown',
+                'language': 'unknown',
+                'total_cells': 0
+            }
+
+        # Count cells by type
+        cell_counts = {}
+        for cell in self.cells:
+            cell_type = cell.get('cell_type', 'unknown')
+            cell_counts[cell_type] = cell_counts.get(cell_type, 0) + 1
+
+        # Get kernel info
+        kernelspec = self.metadata.get('kernelspec', {})
+        kernel_name = kernelspec.get('display_name', kernelspec.get('name', 'unknown'))
+
+        # Get language info
+        language_info = self.metadata.get('language_info', {})
+        language = language_info.get('name', 'unknown')
+
+        # Get cell summaries with line numbers
+        cell_summaries = []
+        current_line = 1
+
+        # Navigate through JSON to find approximate line numbers
+        # This is approximate since JSON formatting varies
+        for idx, cell in enumerate(self.cells):
+            cell_type = cell.get('cell_type', 'unknown')
+            source = cell.get('source', [])
+
+            # Calculate approximate line in source file
+            # Look for cell marker in original lines
+            cell_line = self._find_cell_line(idx)
+
+            # Get first line of content
+            first_line = ""
+            if source:
+                first_line = (source[0] if isinstance(source, list) else source).strip()
+                if len(first_line) > 50:
+                    first_line = first_line[:50] + "..."
+
+            # Count execution info for code cells
+            execution_count = cell.get('execution_count', None)
+            outputs_count = len(cell.get('outputs', []))
+
+            # Create a descriptive name for the cell
+            if cell_type == 'markdown':
+                name = first_line if first_line else f"Markdown cell #{idx + 1}"
+            elif cell_type == 'code':
+                exec_info = f"[{execution_count}]" if execution_count else "[not executed]"
+                name = f"Code {exec_info}: {first_line}" if first_line else f"Code cell #{idx + 1}"
+            else:
+                name = f"{cell_type} cell #{idx + 1}"
+
+            cell_summaries.append({
+                'line': cell_line,
+                'name': name,
+                'type': cell_type,
+                'execution_count': execution_count,
+                'outputs_count': outputs_count,
+            })
+
+        # Return only the cells list for display
+        # The structure format expects dict[str, List[Dict]]
+        result = {}
+        if cell_summaries:
+            result['cells'] = cell_summaries
+
+        return result
+
+    def _find_cell_line(self, cell_index: int) -> int:
+        """
+        Find approximate line number where a cell starts in the JSON.
+
+        This searches for cell markers in the original source.
+        """
+        # Look for "cell_type" string followed by the type for this cell
+        if cell_index < len(self.cells):
+            cell = self.cells[cell_index]
+            cell_type = cell.get('cell_type', '')
+
+            # Count how many cells of this type we've seen before
+            cells_before = sum(1 for c in self.cells[:cell_index] if c.get('cell_type') == cell_type)
+
+            # Search for the nth occurrence of this cell_type in the file
+            count = 0
+            search_str = f'"cell_type": "{cell_type}"'
+            for i, line in enumerate(self.lines, 1):
+                if search_str in line:
+                    if count == cells_before:
+                        return i
+                    count += 1
+
+        return 1  # Fallback
+
+    def generate_preview(self) -> List[tuple[int, str]]:
+        """Generate Jupyter notebook preview."""
+        preview = []
+
+        if self.parse_error:
+            # Fallback to first 20 lines of JSON
+            for i, line in enumerate(self.lines[:20], 1):
+                preview.append((i, line))
+            return preview
+
+        # Show metadata section
+        if self.metadata:
+            kernelspec = self.metadata.get('kernelspec', {})
+            kernel = kernelspec.get('display_name', kernelspec.get('name', 'unknown'))
+            lang_info = self.metadata.get('language_info', {})
+            language = lang_info.get('name', 'unknown')
+
+            preview.append((1, f"Kernel: {kernel}"))
+            preview.append((1, f"Language: {language}"))
+            preview.append((1, ""))
+
+        # Show preview of each cell
+        for idx, cell in enumerate(self.cells[:10]):  # Limit to first 10 cells
+            cell_type = cell.get('cell_type', 'unknown')
+            source = cell.get('source', [])
+            execution_count = cell.get('execution_count', None)
+
+            # Cell header
+            cell_line = self._find_cell_line(idx)
+            header = f"[{idx + 1}] {cell_type.upper()}"
+            if execution_count is not None:
+                header += f" (exec: {execution_count})"
+            preview.append((cell_line, header))
+            preview.append((cell_line, "─" * 60))
+
+            # Cell content (first 5 lines)
+            if source:
+                source_lines = source if isinstance(source, list) else [source]
+                for i, line in enumerate(source_lines[:5]):
+                    # Remove trailing newlines for display
+                    clean_line = line.rstrip('\n')
+                    preview.append((cell_line + i + 1, clean_line))
+
+                if len(source_lines) > 5:
+                    preview.append((cell_line + 6, f"... ({len(source_lines) - 5} more lines)"))
+
+            # Show output summary for code cells
+            outputs = cell.get('outputs', [])
+            if outputs:
+                preview.append((cell_line, f"Outputs: {len(outputs)} items"))
+                # Show first output if available
+                if outputs[0]:
+                    output_type = outputs[0].get('output_type', 'unknown')
+                    preview.append((cell_line, f"  └─ {output_type}"))
+
+            preview.append((cell_line, ""))  # Blank line between cells
+
+        if len(self.cells) > 10:
+            preview.append((1, f"... ({len(self.cells) - 10} more cells)"))
+
+        return preview
+
+    def format_structure(self, structure: Dict[str, Any]) -> List[str]:
+        """Format structure output for Jupyter notebooks."""
+        if structure.get('error'):
+            return [f"Error parsing notebook: {structure['error']}"]
+
+        lines = []
+
+        # Overview
+        lines.append(f"Kernel: {structure['kernel']}")
+        lines.append(f"Language: {structure['language']}")
+        lines.append(f"Total Cells: {structure['total_cells']}")
+        lines.append("")
+
+        # Cell type breakdown
+        if structure['cell_counts']:
+            lines.append("Cell Types:")
+            for cell_type, count in sorted(structure['cell_counts'].items()):
+                lines.append(f"  {cell_type}: {count}")
+            lines.append("")
+
+        # Cell listing
+        if structure['cells']:
+            lines.append("Cells:")
+            for cell in structure['cells']:
+                loc = self.format_location(cell['line'])
+                cell_info = f"[{cell['index'] + 1}] {cell['type']}"
+
+                if cell['execution_count'] is not None:
+                    cell_info += f" (exec: {cell['execution_count']})"
+                if cell['outputs_count'] > 0:
+                    cell_info += f" [{cell['outputs_count']} outputs]"
+
+                # Show first line of content
+                if cell['first_line']:
+                    cell_info += f" - {cell['first_line']}"
+
+                if loc:
+                    lines.append(f"  {loc:<30}  {cell_info}")
+                else:
+                    lines.append(f"  {cell_info}")
+
+        return lines

reveal/analyzers/markdown.py

@@ -0,0 +1,79 @@
+"""Markdown file analyzer."""
+
+import re
+from typing import Dict, List, Any, Optional
+from ..base import FileAnalyzer, register
+
+
+@register('.md', '.markdown', name='Markdown', icon='📝')
+class MarkdownAnalyzer(FileAnalyzer):
+    """Markdown file analyzer.
+
+    Extracts sections based on headings.
+    """
+
+    def get_structure(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract markdown headings."""
+        headings = []
+
+        for i, line in enumerate(self.lines, 1):
+            # Match heading syntax: # Heading, ## Heading, etc.
+            match = re.match(r'^(#{1,6})\s+(.+)$', line)
+            if match:
+                level = len(match.group(1))
+                title = match.group(2).strip()
+
+                headings.append({
+                    'line': i,
+                    'level': level,
+                    'name': title,
+                })
+
+        return {'headings': headings}
+
+    def extract_element(self, element_type: str, name: str) -> Optional[Dict[str, Any]]:
+        """Extract a markdown section.
+
+        Args:
+            element_type: 'section' or 'heading'
+            name: Heading text to find
+
+        Returns:
+            Dict with section content
+        """
+        # Find the heading
+        start_line = None
+        heading_level = None
+
+        for i, line in enumerate(self.lines, 1):
+            match = re.match(r'^(#{1,6})\s+(.+)$', line)
+            if match:
+                title = match.group(2).strip()
+                if title.lower() == name.lower():
+                    start_line = i
+                    heading_level = len(match.group(1))
+                    break
+
+        if not start_line:
+            return super().extract_element(element_type, name)
+
+        # Find the end of this section (next heading of same or higher level)
+        end_line = len(self.lines)
+        for i in range(start_line, len(self.lines)):
+            line = self.lines[i]
+            match = re.match(r'^(#{1,6})\s+', line)
+            if match:
+                level = len(match.group(1))
+                if level <= heading_level:
+                    end_line = i
+                    break
+
+        # Extract the section
+        source = '\n'.join(self.lines[start_line-1:end_line])
+
+        return {
+            'name': name,
+            'line_start': start_line,
+            'line_end': end_line,
+            'source': source,
+        }