reveal-cli 0.8.0__py3-none-any.whl

reveal/tree_view.py

@@ -0,0 +1,105 @@
+"""Directory tree view for reveal."""
+
+import os
+from pathlib import Path
+from typing import List, Optional
+from .base import get_analyzer
+
+
+def show_directory_tree(path: str, depth: int = 3, show_hidden: bool = False) -> str:
+    """Show directory tree with file info.
+
+    Args:
+        path: Directory path
+        depth: Maximum depth to traverse
+        show_hidden: Whether to show hidden files/dirs
+
+    Returns:
+        Formatted tree string
+    """
+    path = Path(path)
+
+    if not path.is_dir():
+        return f"Error: {path} is not a directory"
+
+    lines = [f"📁 {path.name or path}/\n"]
+    _walk_directory(path, lines, depth=depth, show_hidden=show_hidden)
+
+    # Add navigation hint
+    lines.append(f"\n→ reveal {path}/<file>")
+
+    return '\n'.join(lines)
+
+
+def _walk_directory(path: Path, lines: List[str], prefix: str = '', depth: int = 3, show_hidden: bool = False):
+    """Recursively walk directory and build tree."""
+    if depth <= 0:
+        return
+
+    try:
+        entries = sorted(path.iterdir(), key=lambda p: (not p.is_dir(), p.name))
+    except PermissionError:
+        return
+
+    # Filter hidden files/dirs
+    if not show_hidden:
+        entries = [e for e in entries if not e.name.startswith('.')]
+
+    for i, entry in enumerate(entries):
+        is_last = (i == len(entries) - 1)
+
+        # Tree characters
+        if is_last:
+            connector = '└── '
+            extension = '    '
+        else:
+            connector = '├── '
+            extension = '│   '
+
+        if entry.is_file():
+            # Show file with metadata
+            file_info = _get_file_info(entry)
+            lines.append(f"{prefix}{connector}{file_info}")
+
+        elif entry.is_dir():
+            # Show directory
+            lines.append(f"{prefix}{connector}{entry.name}/")
+            # Recurse into subdirectory
+            _walk_directory(entry, lines, prefix + extension, depth - 1, show_hidden)
+
+
+def _get_file_info(path: Path) -> str:
+    """Get formatted file info for tree display.
+
+    Returns:
+        Formatted string like "app.py (247 lines, Python)"
+    """
+    try:
+        # Try to get analyzer for this file
+        analyzer_class = get_analyzer(str(path))
+
+        if analyzer_class:
+            # Use analyzer to get info
+            analyzer = analyzer_class(str(path))
+            meta = analyzer.get_metadata()
+            file_type = analyzer.type_name
+
+            return f"{path.name} ({meta['lines']} lines, {file_type})"
+        else:
+            # No analyzer - just show basic info
+            stat = os.stat(path)
+            size = _format_size(stat.st_size)
+            return f"{path.name} ({size})"
+
+    except Exception:
+        # If anything fails, just show filename
+        return path.name
+
+
+def _format_size(size: int) -> str:
+    """Format file size in human-readable form."""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size < 1024.0:
+            return f"{size:.1f} {unit}"
+        size /= 1024.0
+    return f"{size:.1f} TB"

reveal/treesitter.py

@@ -0,0 +1,281 @@
+"""Tree-sitter based analyzer for multi-language support."""
+
+import warnings
+from typing import Dict, List, Any, Optional
+from .base import FileAnalyzer
+from tree_sitter_languages import get_parser
+
+
+class TreeSitterAnalyzer(FileAnalyzer):
+    """Base class for tree-sitter based analyzers.
+
+    Provides automatic extraction for ANY tree-sitter language!
+
+    Subclass just needs to set:
+        language (str): tree-sitter language name (e.g., 'python', 'rust', 'go')
+
+    Everything else is automatic:
+    - Structure extraction (imports, functions, classes, structs)
+    - Element extraction (get specific function/class)
+    - Line number tracking
+
+    Usage:
+        @register('.go', name='Go', icon='🔷')
+        class GoAnalyzer(TreeSitterAnalyzer):
+            language = 'go'
+            # Done! Full support in 3 lines.
+    """
+
+    language: str = None  # Set in subclass
+
+    def __init__(self, path: str):
+        super().__init__(path)
+        self.tree = None
+
+        if self.language:
+            self._parse_tree()
+
+    def _parse_tree(self):
+        """Parse file with tree-sitter."""
+        try:
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore', category=FutureWarning, module='tree_sitter')
+                parser = get_parser(self.language)
+                self.tree = parser.parse(self.content.encode('utf-8'))
+        except Exception as e:
+            # Parsing failed - fall back to text analysis
+            self.tree = None
+
+    def get_structure(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract structure using tree-sitter.
+
+        Returns imports, functions, classes, structs, etc.
+        Works for ANY tree-sitter language!
+        """
+        if not self.tree:
+            return {}
+
+        structure = {}
+
+        # Extract common elements
+        structure['imports'] = self._extract_imports()
+        structure['functions'] = self._extract_functions()
+        structure['classes'] = self._extract_classes()
+        structure['structs'] = self._extract_structs()
+
+        # Remove empty categories
+        return {k: v for k, v in structure.items() if v}
+
+    def _extract_imports(self) -> List[Dict[str, Any]]:
+        """Extract import statements."""
+        imports = []
+
+        # Common import node types across languages
+        import_types = [
+            'import_statement',      # Python, JavaScript
+            'import_declaration',    # Go, Java
+            'use_declaration',       # Rust
+            'using_directive',       # C#
+            'import_from_statement', # Python
+        ]
+
+        for import_type in import_types:
+            nodes = self._find_nodes_by_type(import_type)
+            for node in nodes:
+                imports.append({
+                    'line': node.start_point[0] + 1,
+                    'content': self._get_node_text(node),
+                })
+
+        return imports
+
+    def _extract_functions(self) -> List[Dict[str, Any]]:
+        """Extract function definitions."""
+        functions = []
+
+        # Common function node types
+        function_types = [
+            'function_definition',   # Python
+            'function_declaration',  # Go, C, JavaScript
+            'function_item',         # Rust
+            'method_declaration',    # Java, C#
+            'function',              # Generic
+        ]
+
+        for func_type in function_types:
+            nodes = self._find_nodes_by_type(func_type)
+            for node in nodes:
+                name = self._get_function_name(node)
+                if name:
+                    functions.append({
+                        'line': node.start_point[0] + 1,
+                        'name': name,
+                        'signature': self._get_signature(node),
+                    })
+
+        return functions
+
+    def _extract_classes(self) -> List[Dict[str, Any]]:
+        """Extract class definitions."""
+        classes = []
+
+        class_types = [
+            'class_definition',      # Python
+            'class_declaration',     # Java, C#, JavaScript
+            'struct_item',           # Rust (treated as class)
+        ]
+
+        for class_type in class_types:
+            nodes = self._find_nodes_by_type(class_type)
+            for node in nodes:
+                name = self._get_class_name(node)
+                if name:
+                    classes.append({
+                        'line': node.start_point[0] + 1,
+                        'name': name,
+                    })
+
+        return classes
+
+    def _extract_structs(self) -> List[Dict[str, Any]]:
+        """Extract struct definitions (for languages that have them)."""
+        structs = []
+
+        struct_types = [
+            'struct_item',           # Rust
+            'struct_specifier',      # C/C++
+            'struct_declaration',    # Go
+        ]
+
+        for struct_type in struct_types:
+            nodes = self._find_nodes_by_type(struct_type)
+            for node in nodes:
+                name = self._get_struct_name(node)
+                if name:
+                    structs.append({
+                        'line': node.start_point[0] + 1,
+                        'name': name,
+                    })
+
+        return structs
+
+    def extract_element(self, element_type: str, name: str) -> Optional[Dict[str, Any]]:
+        """Extract a specific element using tree-sitter.
+
+        Args:
+            element_type: 'function', 'class', 'struct', etc.
+            name: Name of the element
+
+        Returns:
+            Dict with source, line numbers, etc.
+        """
+        if not self.tree:
+            return super().extract_element(element_type, name)
+
+        # Map element type to node types
+        type_map = {
+            'function': ['function_definition', 'function_declaration', 'function_item', 'method_declaration'],
+            'class': ['class_definition', 'class_declaration'],
+            'struct': ['struct_item', 'struct_specifier', 'struct_declaration'],
+        }
+
+        node_types = type_map.get(element_type, [element_type])
+
+        # Find matching node
+        for node_type in node_types:
+            nodes = self._find_nodes_by_type(node_type)
+            for node in nodes:
+                node_name = self._get_node_name(node)
+                if node_name == name:
+                    return {
+                        'name': name,
+                        'line_start': node.start_point[0] + 1,
+                        'line_end': node.end_point[0] + 1,
+                        'source': self._get_node_text(node),
+                    }
+
+        # Fall back to grep
+        return super().extract_element(element_type, name)
+
+    def _find_nodes_by_type(self, node_type: str) -> List:
+        """Find all nodes of a given type in the tree."""
+        if not self.tree:
+            return []
+
+        nodes = []
+
+        def walk(node):
+            if node.type == node_type:
+                nodes.append(node)
+            for child in node.children:
+                walk(child)
+
+        walk(self.tree.root_node)
+        return nodes
+
+    def _get_node_text(self, node) -> str:
+        """Get the source text for a node.
+
+        IMPORTANT: Tree-sitter uses byte offsets, not character offsets!
+        Must slice the UTF-8 bytes, not the string, to handle multi-byte characters.
+        """
+        start_byte = node.start_byte
+        end_byte = node.end_byte
+        # Convert to bytes, slice, then decode back to string
+        content_bytes = self.content.encode('utf-8')
+        return content_bytes[start_byte:end_byte].decode('utf-8')
+
+    def _get_node_name(self, node) -> Optional[str]:
+        """Get the name of a node (function/class/struct name)."""
+        # Look for 'name' or 'identifier' child
+        for child in node.children:
+            if child.type in ('identifier', 'name'):
+                return self._get_node_text(child)
+
+        return None
+
+    def _get_function_name(self, node) -> Optional[str]:
+        """Extract function name from function node."""
+        return self._get_node_name(node)
+
+    def _get_class_name(self, node) -> Optional[str]:
+        """Extract class name from class node."""
+        return self._get_node_name(node)
+
+    def _get_struct_name(self, node) -> Optional[str]:
+        """Extract struct name from struct node."""
+        return self._get_node_name(node)
+
+    def _get_signature(self, node) -> str:
+        """Get function signature (parameters and return type only)."""
+        # Look for parameters node to extract just signature part
+        params_text = ''
+        return_type = ''
+
+        for child in node.children:
+            if child.type in ('parameters', 'parameter_list', 'formal_parameters'):
+                params_text = self._get_node_text(child)
+            elif child.type in ('return_type', 'type'):
+                return_type = ' -> ' + self._get_node_text(child).strip(': ')
+
+        if params_text:
+            return params_text + return_type
+
+        # Fallback: try to extract from first line
+        text = self._get_node_text(node)
+        first_line = text.split('\n')[0].strip()
+
+        # Remove common prefixes (def, func, fn, function, etc.)
+        for prefix in ['def ', 'func ', 'fn ', 'function ', 'async def ', 'pub fn ', 'fn ', 'async fn ']:
+            if first_line.startswith(prefix):
+                first_line = first_line[len(prefix):]
+                break
+
+        # Extract just the signature part (name + params + return)
+        # Remove the name to leave just params + return type
+        if '(' in first_line:
+            name_end = first_line.index('(')
+            signature = first_line[name_end:].rstrip(':').strip()
+            return signature
+
+        return first_line