reveal-cli 0.2.0__py3-none-any.whl

reveal/_archive_old_v0.1/analyzers/markdown_analyzer.py

@@ -0,0 +1,116 @@
+"""Markdown file analyzer."""
+
+import re
+from typing import Dict, Any, List
+from .base import BaseAnalyzer
+from ..registry import register
+
+
+@register(['.md', '.markdown', '.mdown'], name='Markdown', icon='📝')
+class MarkdownAnalyzer(BaseAnalyzer):
+    """Analyzer for Markdown documentation files"""
+
+    def analyze_structure(self) -> Dict[str, Any]:
+        """Analyze Markdown structure."""
+        headings = []
+        paragraph_count = 0
+        code_block_count = 0
+        list_count = 0
+
+        in_code_block = False
+        current_paragraph = False
+
+        for line in self.lines:
+            stripped = line.strip()
+
+            # Code blocks
+            if stripped.startswith('```'):
+                in_code_block = not in_code_block
+                if in_code_block:
+                    code_block_count += 1
+                continue
+
+            if in_code_block:
+                continue
+
+            # Headings
+            if stripped.startswith('#'):
+                match = re.match(r'^(#{1,3})\s+(.+)$', stripped)
+                if match:
+                    level = len(match.group(1))
+                    title = match.group(2)
+                    headings.append((level, title))
+                    current_paragraph = False
+                continue
+
+            # Lists
+            if re.match(r'^\s*[-*+]\s+', line) or re.match(r'^\s*\d+\.\s+', line):
+                list_count += 1
+                current_paragraph = False
+                continue
+
+            # Paragraphs
+            if stripped and not current_paragraph:
+                paragraph_count += 1
+                current_paragraph = True
+            elif not stripped:
+                current_paragraph = False
+
+        return {
+            'headings': headings,
+            'paragraph_count': paragraph_count,
+            'code_block_count': code_block_count,
+            'list_count': list_count
+        }
+
+    def generate_preview(self) -> List[tuple[int, str]]:
+        """Generate Markdown preview."""
+        preview = []
+        in_frontmatter = False
+        frontmatter_start = False
+        first_heading_found = False
+        lines_after_heading = 0
+        in_code_block = False
+
+        for i, line in enumerate(self.lines, 1):
+            stripped = line.strip()
+
+            # Frontmatter detection
+            if i == 1 and stripped == '---':
+                in_frontmatter = True
+                frontmatter_start = True
+                preview.append((i, line))
+                continue
+
+            if in_frontmatter:
+                preview.append((i, line))
+                if stripped == '---':
+                    in_frontmatter = False
+                continue
+
+            # Code blocks
+            if stripped.startswith('```'):
+                in_code_block = not in_code_block
+                if in_code_block:
+                    preview.append((i, f"[Code block: {stripped[3:] or 'unknown'}]"))
+                continue
+
+            if in_code_block:
+                continue
+
+            # First heading + paragraph
+            if stripped.startswith('#'):
+                preview.append((i, line))
+                first_heading_found = True
+                lines_after_heading = 0
+                continue
+
+            if first_heading_found and lines_after_heading < 5:
+                if stripped:
+                    preview.append((i, line))
+                lines_after_heading += 1
+
+            if len(preview) >= 20:
+                break
+
+        return preview[:30]

reveal/_archive_old_v0.1/analyzers/php_analyzer.py

@@ -0,0 +1,166 @@
+"""
+PHP file analyzer using tree-sitter.
+
+Extracts:
+- Classes
+- Functions
+- Methods
+- Traits
+- Interfaces
+- Namespaces
+"""
+
+from typing import Dict, Any, List
+from .treesitter_base import TreeSitterAnalyzer, TREE_SITTER_AVAILABLE
+from ..registry import register
+
+
+@register(['.php'], name='PHP', icon='🐘')
+class PHPAnalyzer(TreeSitterAnalyzer):
+    """
+    Analyzer for PHP source files.
+
+    Features:
+    - Classes, interfaces, traits
+    - Functions and methods
+    - Namespaces
+    - Use statements
+
+    All positions are exact (tree-sitter preserves source locations).
+    """
+
+    language_name = 'php'
+
+    def __init__(self, lines: List[str], **kwargs):
+        """Initialize PHP analyzer."""
+        self.node_type_map = {
+            'function': 'function_definition',
+            'class': 'class_declaration',
+            'import': 'namespace_use_declaration',
+        }
+        super().__init__(lines, **kwargs)
+
+    def extract_custom(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract PHP-specific items."""
+        return {
+            'methods': self._extract_nodes('method_declaration', name_field='name'),
+            'interfaces': self._extract_nodes('interface_declaration', name_field='name'),
+            'traits': self._extract_nodes('trait_declaration', name_field='name'),
+            'namespaces': self._extract_namespaces(),
+        }
+
+    def _extract_namespaces(self) -> List[Dict[str, Any]]:
+        """Extract namespace declarations."""
+        if not self.tree:
+            return []
+
+        namespaces = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'namespace_definition':
+                # Get namespace name
+                name_node = node.child_by_field_name('name')
+                if name_node:
+                    line = node.start_point[0] + 1
+                    if self.in_focus_range(line):
+                        namespaces.append({
+                            'name': name_node.text.decode('utf-8'),
+                            'line': line
+                        })
+
+            # Recurse
+            if cursor.goto_first_child():
+                visit(cursor)
+                while cursor.goto_next_sibling():
+                    visit(cursor)
+                cursor.goto_parent()
+
+        visit(cursor)
+        return namespaces
+
+    def format_structure(self, structure: Dict[str, Any]) -> List[str]:
+        """
+        Custom formatting for PHP structure output.
+
+        Groups items logically:
+        1. Namespaces
+        2. Use statements
+        3. Types (classes, interfaces, traits)
+        4. Functions
+        5. Methods
+        """
+        if not TREE_SITTER_AVAILABLE or 'error' in structure:
+            return None
+
+        lines = []
+
+        # Namespaces
+        namespaces = structure.get('namespaces', [])
+        if namespaces:
+            lines.append(f"\nNamespaces ({len(namespaces)}):")
+            for item in namespaces:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+
+        # Use statements
+        imports = structure.get('imports', [])
+        if imports:
+            lines.append(f"\nUse statements ({len(imports)}):")
+            for item in imports[:10]:
+                loc = self.format_location(item['line'])
+                name = item['name']
+                if len(name) > 60:
+                    name = name[:57] + "..."
+                lines.append(f"  {loc:30}  {name}")
+            if len(imports) > 10:
+                lines.append(f"  ... and {len(imports) - 10} more")
+
+        # Types
+        classes = structure.get('classes', [])
+        interfaces = structure.get('interfaces', [])
+        traits = structure.get('traits', [])
+
+        type_count = len(classes) + len(interfaces) + len(traits)
+        if type_count > 0:
+            lines.append(f"\nTypes ({type_count}):")
+
+            if classes:
+                lines.append(f"  Classes ({len(classes)}):")
+                for item in classes:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+            if interfaces:
+                lines.append(f"  Interfaces ({len(interfaces)}):")
+                for item in interfaces:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+            if traits:
+                lines.append(f"  Traits ({len(traits)}):")
+                for item in traits:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+        # Functions
+        functions = structure.get('functions', [])
+        if functions:
+            lines.append(f"\nFunctions ({len(functions)}):")
+            for item in functions:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  function {item['name']}()")
+
+        # Methods
+        methods = structure.get('methods', [])
+        if methods:
+            lines.append(f"\nMethods ({len(methods)}):")
+            for item in methods[:20]:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}()")
+            if len(methods) > 20:
+                lines.append(f"  ... and {len(methods) - 20} more")
+
+        return lines if lines else None

reveal/_archive_old_v0.1/analyzers/python_analyzer.py

@@ -0,0 +1,118 @@
+"""Python file analyzer."""
+
+import ast
+from typing import Dict, Any, List
+from .base import BaseAnalyzer
+from ..registry import register
+
+
+@register(['.py', '.pyx', '.pyi'], name='Python', icon='🐍')
+class PythonAnalyzer(BaseAnalyzer):
+    """Analyzer for Python source files with AST-based analysis"""
+
+    def __init__(self, lines: List[str], **kwargs):
+        super().__init__(lines, **kwargs)
+        self.parse_error = None
+        self.tree = None
+
+        try:
+            content = '\n'.join(lines)
+            self.tree = ast.parse(content)
+        except Exception as e:
+            self.parse_error = str(e)
+
+    def analyze_structure(self) -> Dict[str, Any]:
+        """Analyze Python structure."""
+        if self.parse_error:
+            return {
+                'error': self.parse_error,
+                'imports': [],
+                'classes': [],
+                'functions': [],
+                'assignments': []
+            }
+
+        imports = []
+        classes = []
+        functions = []
+        assignments = []
+
+        for node in ast.walk(self.tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    imports.append(alias.name)
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ''
+                for alias in node.names:
+                    imports.append(f"{module}.{alias.name}" if module else alias.name)
+
+        # Only top-level elements
+        for node in self.tree.body:
+            if isinstance(node, ast.ClassDef):
+                classes.append({'name': node.name, 'line': node.lineno})
+            elif isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
+                functions.append({'name': node.name, 'line': node.lineno})
+            elif isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        assignments.append({'name': target.id, 'line': node.lineno})
+
+        return {
+            'imports': imports,
+            'classes': classes,
+            'functions': functions,
+            'assignments': assignments
+        }
+
+    def generate_preview(self) -> List[tuple[int, str]]:
+        """Generate Python preview."""
+        preview = []
+
+        # Module docstring
+        if self.tree and isinstance(self.tree.body[0], ast.Expr) and isinstance(self.tree.body[0].value, ast.Constant):
+            docstring_node = self.tree.body[0]
+            # Find docstring in lines
+            for i, line in enumerate(self.lines[:20], 1):
+                if '"""' in line or "'''" in line:
+                    preview.append((i, line))
+                    # Add next few lines if multiline docstring
+                    if line.count('"""') == 1 or line.count("'''") == 1:
+                        for j in range(i, min(i + 10, len(self.lines) + 1)):
+                            if j > i:
+                                preview.append((j, self.lines[j - 1]))
+                            if '"""' in self.lines[j - 1][1:] or "'''" in self.lines[j - 1][1:]:
+                                break
+                    break
+
+        if self.parse_error:
+            # Fallback to first 20 lines
+            for i, line in enumerate(self.lines[:20], 1):
+                if (i, line) not in preview:
+                    preview.append((i, line))
+            return preview
+
+        # Class signatures + first docstring line
+        for node in self.tree.body:
+            if isinstance(node, ast.ClassDef):
+                class_line = node.lineno
+                preview.append((class_line, self.lines[class_line - 1]))
+
+                # Get class docstring
+                if node.body and isinstance(node.body[0], ast.Expr) and isinstance(node.body[0].value, ast.Constant):
+                    doc_line = node.body[0].lineno
+                    preview.append((doc_line, self.lines[doc_line - 1]))
+
+        # Function signatures + first docstring line
+        for node in self.tree.body:
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                func_line = node.lineno
+                preview.append((func_line, self.lines[func_line - 1]))
+
+                # Get function docstring
+                if node.body and isinstance(node.body[0], ast.Expr) and isinstance(node.body[0].value, ast.Constant):
+                    doc_line = node.body[0].lineno
+                    preview.append((doc_line, self.lines[doc_line - 1]))
+
+        # Sort by line number and limit
+        preview = sorted(list(set(preview)), key=lambda x: x[0])
+        return preview[:30]

reveal/_archive_old_v0.1/analyzers/rust_analyzer.py

@@ -0,0 +1,202 @@
+"""
+Rust file analyzer using tree-sitter.
+
+Demonstrates how easy it is to add language support using TreeSitterAnalyzer.
+This entire analyzer is ~100 lines including docs and formatting!
+
+Extracts:
+- Functions (fn)
+- Structs
+- Enums
+- Traits
+- Impls (trait implementations)
+- Use statements (imports)
+- Mods (module declarations)
+"""
+
+from typing import Dict, Any, List
+from .treesitter_base import TreeSitterAnalyzer, TREE_SITTER_AVAILABLE
+from ..registry import register
+
+
+@register(['.rs'], name='Rust', icon='🦀')
+class RustAnalyzer(TreeSitterAnalyzer):
+    """
+    Analyzer for Rust source files.
+
+    Features:
+    - Functions, structs, enums, traits with line numbers
+    - Impl blocks (trait implementations)
+    - Module structure
+    - Use statements (imports)
+    - Macro definitions
+
+    All positions are exact (tree-sitter preserves source locations).
+    """
+
+    # Set language for tree-sitter
+    language_name = 'rust'
+
+    def __init__(self, lines: List[str], **kwargs):
+        """Initialize Rust analyzer."""
+        # Map reveal's generic names to Rust's tree-sitter node types
+        self.node_type_map = {
+            'function': 'function_item',
+            'struct': 'struct_item',
+            'class': 'struct_item',  # Rust uses structs, not classes
+            'import': 'use_declaration',
+        }
+        super().__init__(lines, **kwargs)
+
+    def extract_custom(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract Rust-specific items."""
+        return {
+            'enums': self._extract_nodes('enum_item', name_field='name'),
+            'traits': self._extract_nodes('trait_item', name_field='name'),
+            'impls': self._extract_impl_blocks(),
+            'mods': self._extract_nodes('mod_item', name_field='name'),
+            'macros': self._extract_nodes('macro_definition', name_field='name'),
+        }
+
+    def _extract_impl_blocks(self) -> List[Dict[str, Any]]:
+        """
+        Extract impl blocks with special handling.
+
+        Rust impl blocks look like:
+        - impl Foo { ... }           (inherent impl)
+        - impl Trait for Foo { ... } (trait impl)
+        """
+        if not self.tree:
+            return []
+
+        impls = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'impl_item':
+                # Try to get type being implemented
+                type_node = node.child_by_field_name('type')
+                trait_node = node.child_by_field_name('trait')
+
+                if trait_node and type_node:
+                    # impl Trait for Type
+                    trait_name = trait_node.text.decode('utf-8')
+                    type_name = type_node.text.decode('utf-8')
+                    name = f"{trait_name} for {type_name}"
+                elif type_node:
+                    # impl Type
+                    type_name = type_node.text.decode('utf-8')
+                    name = type_name
+                else:
+                    name = "<impl>"
+
+                line = node.start_point[0] + 1
+                if self.in_focus_range(line):
+                    impls.append({
+                        'name': name,
+                        'line': line
+                    })
+
+            # Recurse
+            if cursor.goto_first_child():
+                visit(cursor)
+                while cursor.goto_next_sibling():
+                    visit(cursor)
+                cursor.goto_parent()
+
+        visit(cursor)
+        return impls
+
+    def format_structure(self, structure: Dict[str, Any]) -> List[str]:
+        """
+        Custom formatting for Rust structure output.
+
+        Groups items logically:
+        1. Module/Crate info
+        2. Imports (use statements)
+        3. Types (structs, enums, traits)
+        4. Implementations
+        5. Functions
+        6. Macros
+        """
+        if not TREE_SITTER_AVAILABLE or 'error' in structure:
+            return None  # Use default formatting
+
+        lines = []
+
+        # Use statements
+        imports = structure.get('imports', [])
+        if imports:
+            lines.append(f"\nUse statements ({len(imports)}):")
+            for item in imports[:10]:  # Limit display
+                loc = self.format_location(item['line'])
+                # Shorten long imports
+                name = item['name']
+                if len(name) > 60:
+                    name = name[:57] + "..."
+                lines.append(f"  {loc:30}  {name}")
+            if len(imports) > 10:
+                lines.append(f"  ... and {len(imports) - 10} more")
+
+        # Types section
+        structs = structure.get('structs', [])
+        enums = structure.get('enums', [])
+        traits = structure.get('traits', [])
+
+        type_count = len(structs) + len(enums) + len(traits)
+        if type_count > 0:
+            lines.append(f"\nTypes ({type_count}):")
+
+            if structs:
+                lines.append(f"  Structs ({len(structs)}):")
+                for item in structs:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+            if enums:
+                lines.append(f"  Enums ({len(enums)}):")
+                for item in enums:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+            if traits:
+                lines.append(f"  Traits ({len(traits)}):")
+                for item in traits:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+        # Implementations
+        impls = structure.get('impls', [])
+        if impls:
+            lines.append(f"\nImplementations ({len(impls)}):")
+            for item in impls:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  impl {item['name']}")
+
+        # Functions
+        functions = structure.get('functions', [])
+        if functions:
+            lines.append(f"\nFunctions ({len(functions)}):")
+            for item in functions:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  fn {item['name']}()")
+
+        # Modules
+        mods = structure.get('mods', [])
+        if mods:
+            lines.append(f"\nModules ({len(mods)}):")
+            for item in mods:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  mod {item['name']}")
+
+        # Macros
+        macros = structure.get('macros', [])
+        if macros:
+            lines.append(f"\nMacros ({len(macros)}):")
+            for item in macros:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}!")
+
+        return lines if lines else None