reveal-cli 0.2.0__py3-none-any.whl

reveal/_archive_old_v0.1/analyzers/go_analyzer.py

@@ -0,0 +1,230 @@
+"""
+Go file analyzer using tree-sitter.
+
+Extracts:
+- Functions
+- Structs
+- Interfaces
+- Methods
+- Imports
+"""
+
+from typing import Dict, Any, List
+from .treesitter_base import TreeSitterAnalyzer, TREE_SITTER_AVAILABLE
+from ..registry import register
+
+
+@register(['.go'], name='Go', icon='🐹')
+class GoAnalyzer(TreeSitterAnalyzer):
+    """
+    Analyzer for Go source files.
+
+    Features:
+    - Functions, methods, structs, interfaces
+    - Package and import statements
+    - Type definitions
+
+    All positions are exact (tree-sitter preserves source locations).
+    """
+
+    language_name = 'go'
+
+    def __init__(self, lines: List[str], **kwargs):
+        """Initialize Go analyzer."""
+        self.node_type_map = {
+            'function': 'function_declaration',
+            'import': 'import_declaration',
+        }
+        super().__init__(lines, **kwargs)
+
+    def extract_custom(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract Go-specific items."""
+        return {
+            'methods': self._extract_nodes('method_declaration', name_field='name'),
+            'interfaces': self._extract_interfaces(),
+            'structs': self._extract_structs(),
+            'types': self._extract_types(),
+        }
+
+    def _extract_structs(self) -> List[Dict[str, Any]]:
+        """Extract struct declarations."""
+        if not self.tree:
+            return []
+
+        structs = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'type_spec':
+                # Check if this type_spec contains a struct_type
+                for child in node.children:
+                    if child.type == 'struct_type':
+                        # Get the name from type_identifier
+                        name_node = node.child_by_field_name('name')
+                        if name_node:
+                            line = node.start_point[0] + 1
+                            if self.in_focus_range(line):
+                                structs.append({
+                                    'name': name_node.text.decode('utf-8'),
+                                    'line': line
+                                })
+                        break
+
+            # Recurse
+            if cursor.goto_first_child():
+                visit(cursor)
+                while cursor.goto_next_sibling():
+                    visit(cursor)
+                cursor.goto_parent()
+
+        visit(cursor)
+        return structs
+
+    def _extract_interfaces(self) -> List[Dict[str, Any]]:
+        """Extract interface declarations."""
+        if not self.tree:
+            return []
+
+        interfaces = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'type_spec':
+                # Check if this type_spec contains an interface_type
+                for child in node.children:
+                    if child.type == 'interface_type':
+                        name_node = node.child_by_field_name('name')
+                        if name_node:
+                            line = node.start_point[0] + 1
+                            if self.in_focus_range(line):
+                                interfaces.append({
+                                    'name': name_node.text.decode('utf-8'),
+                                    'line': line
+                                })
+                        break
+
+            # Recurse
+            if cursor.goto_first_child():
+                visit(cursor)
+                while cursor.goto_next_sibling():
+                    visit(cursor)
+                cursor.goto_parent()
+
+        visit(cursor)
+        return interfaces
+
+    def _extract_types(self) -> List[Dict[str, Any]]:
+        """Extract type declarations (excluding interfaces and structs)."""
+        if not self.tree:
+            return []
+
+        types = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'type_spec':
+                # Check that it's not a struct or interface (handled separately)
+                has_struct_or_interface = False
+                for child in node.children:
+                    if child.type in ('interface_type', 'struct_type'):
+                        has_struct_or_interface = True
+                        break
+
+                if not has_struct_or_interface:
+                    name_node = node.child_by_field_name('name')
+                    if name_node:
+                        line = node.start_point[0] + 1
+                        if self.in_focus_range(line):
+                            types.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 types
+
+    def format_structure(self, structure: Dict[str, Any]) -> List[str]:
+        """
+        Custom formatting for Go structure output.
+
+        Groups items logically:
+        1. Package/Imports
+        2. Types (structs, interfaces)
+        3. Functions
+        4. Methods
+        """
+        if not TREE_SITTER_AVAILABLE or 'error' in structure:
+            return None  # Use default formatting
+
+        lines = []
+
+        # Imports
+        imports = structure.get('imports', [])
+        if imports:
+            lines.append(f"\nImports ({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 section
+        types = structure.get('types', [])
+        structs = structure.get('structs', [])
+        interfaces = structure.get('interfaces', [])
+
+        type_count = len(types) + len(structs) + len(interfaces)
+        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 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 types:
+                lines.append(f"  Other Types ({len(types)}):")
+                for item in types:
+                    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}  func {item['name']}()")
+
+        # Methods
+        methods = structure.get('methods', [])
+        if methods:
+            lines.append(f"\nMethods ({len(methods)}):")
+            for item in methods:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  func {item['name']}()")
+
+        return lines if lines else None

reveal/_archive_old_v0.1/analyzers/javascript_analyzer.py

@@ -0,0 +1,272 @@
+"""
+JavaScript/JSX file analyzer using tree-sitter.
+
+Extracts:
+- Functions (regular, arrow, async)
+- Classes
+- Imports/Exports
+- Variables (const, let, var)
+"""
+
+from typing import Dict, Any, List
+from .treesitter_base import TreeSitterAnalyzer, TREE_SITTER_AVAILABLE
+from ..registry import register
+
+
+@register(['.js', '.jsx', '.mjs', '.cjs'], name='JavaScript', icon='📜')
+class JavaScriptAnalyzer(TreeSitterAnalyzer):
+    """
+    Analyzer for JavaScript source files.
+
+    Features:
+    - Functions (declarations, expressions, arrow functions)
+    - Classes and methods
+    - Import/export statements
+    - Variable declarations
+
+    All positions are exact (tree-sitter preserves source locations).
+    """
+
+    language_name = 'javascript'
+
+    def __init__(self, lines: List[str], **kwargs):
+        """Initialize JavaScript analyzer."""
+        self.node_type_map = {
+            'function': 'function_declaration',
+            'class': 'class_declaration',
+            'import': 'import_statement',
+        }
+        super().__init__(lines, **kwargs)
+
+    def extract_custom(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract JavaScript-specific items."""
+        return {
+            'arrow_functions': self._extract_arrow_functions(),
+            'function_expressions': self._extract_function_expressions(),
+            'exports': self._extract_exports(),
+            'variables': self._extract_variables(),
+        }
+
+    def _extract_arrow_functions(self) -> List[Dict[str, Any]]:
+        """Extract arrow function expressions."""
+        if not self.tree:
+            return []
+
+        arrow_funcs = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'arrow_function':
+                # Try to get the variable name it's assigned to
+                parent = node.parent
+                name = '<arrow>'
+
+                if parent and parent.type == 'variable_declarator':
+                    name_node = parent.child_by_field_name('name')
+                    if name_node:
+                        name = name_node.text.decode('utf-8')
+
+                line = node.start_point[0] + 1
+                if self.in_focus_range(line):
+                    arrow_funcs.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 arrow_funcs
+
+    def _extract_function_expressions(self) -> List[Dict[str, Any]]:
+        """Extract function expressions (const fn = function() {})."""
+        if not self.tree:
+            return []
+
+        func_exprs = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'function' and node.parent:
+                parent = node.parent
+                if parent.type == 'variable_declarator':
+                    name_node = parent.child_by_field_name('name')
+                    if name_node:
+                        line = node.start_point[0] + 1
+                        if self.in_focus_range(line):
+                            func_exprs.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 func_exprs
+
+    def _extract_exports(self) -> List[Dict[str, Any]]:
+        """Extract export statements."""
+        if not self.tree:
+            return []
+
+        exports = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            if node.type == 'export_statement':
+                # Get exported name or use full statement text
+                name = node.text.decode('utf-8').strip()
+                if len(name) > 60:
+                    name = name[:57] + "..."
+
+                line = node.start_point[0] + 1
+                if self.in_focus_range(line):
+                    exports.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 exports
+
+    def _extract_variables(self) -> List[Dict[str, Any]]:
+        """Extract top-level variable declarations."""
+        if not self.tree:
+            return []
+
+        variables = []
+        cursor = self.tree.walk()
+
+        def visit(cursor):
+            node = cursor.node
+
+            # Only get top-level variables
+            if node.type == 'variable_declaration' and node.parent.type == 'program':
+                for child in node.children:
+                    if child.type == 'variable_declarator':
+                        name_node = child.child_by_field_name('name')
+                        if name_node:
+                            line = child.start_point[0] + 1
+                            if self.in_focus_range(line):
+                                variables.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 variables
+
+    def format_structure(self, structure: Dict[str, Any]) -> List[str]:
+        """
+        Custom formatting for JavaScript structure output.
+
+        Groups items logically:
+        1. Imports/Exports
+        2. Classes
+        3. Functions (declarations, expressions, arrow)
+        4. Variables
+        """
+        if not TREE_SITTER_AVAILABLE or 'error' in structure:
+            return None
+
+        lines = []
+
+        # Imports
+        imports = structure.get('imports', [])
+        if imports:
+            lines.append(f"\nImports ({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")
+
+        # Exports
+        exports = structure.get('exports', [])
+        if exports:
+            lines.append(f"\nExports ({len(exports)}):")
+            for item in exports[:10]:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+            if len(exports) > 10:
+                lines.append(f"  ... and {len(exports) - 10} more")
+
+        # Classes
+        classes = structure.get('classes', [])
+        if classes:
+            lines.append(f"\nClasses ({len(classes)}):")
+            for item in classes:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  class {item['name']}")
+
+        # Functions
+        functions = structure.get('functions', [])
+        arrow_functions = structure.get('arrow_functions', [])
+        func_expressions = structure.get('function_expressions', [])
+
+        func_count = len(functions) + len(arrow_functions) + len(func_expressions)
+        if func_count > 0:
+            lines.append(f"\nFunctions ({func_count}):")
+
+            if functions:
+                lines.append(f"  Declarations ({len(functions)}):")
+                for item in functions:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  function {item['name']}()")
+
+            if arrow_functions:
+                lines.append(f"  Arrow Functions ({len(arrow_functions)}):")
+                for item in arrow_functions:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']} =>")
+
+            if func_expressions:
+                lines.append(f"  Expressions ({len(func_expressions)}):")
+                for item in func_expressions:
+                    loc = self.format_location(item['line'])
+                    lines.append(f"    {loc:28}  {item['name']}")
+
+        # Variables
+        variables = structure.get('variables', [])
+        if variables:
+            lines.append(f"\nVariables ({len(variables)}):")
+            for item in variables[:15]:
+                loc = self.format_location(item['line'])
+                lines.append(f"  {loc:30}  {item['name']}")
+            if len(variables) > 15:
+                lines.append(f"  ... and {len(variables) - 15} more")
+
+        return lines if lines else None

reveal/_archive_old_v0.1/analyzers/json_analyzer.py

@@ -0,0 +1,143 @@
+"""JSON file analyzer."""
+
+import json
+from typing import Dict, Any, List
+from .base import BaseAnalyzer
+from ..registry import register
+
+
+@register(['.json', '.jsonc', '.json5'], name='JSON', icon='📊')
+class JSONAnalyzer(BaseAnalyzer):
+    """Analyzer for JSON data files"""
+
+    def __init__(self, lines: List[str], **kwargs):
+        super().__init__(lines, **kwargs)
+        self.parse_error = None
+        self.parsed_data = None
+
+        try:
+            content = '\n'.join(lines)
+            self.parsed_data = json.loads(content)
+        except Exception as e:
+            self.parse_error = str(e)
+
+    def analyze_structure(self) -> Dict[str, Any]:
+        """Analyze JSON structure."""
+        if self.parse_error:
+            return {
+                'error': self.parse_error,
+                'top_level_keys': [],
+                'object_count': 0,
+                'array_count': 0,
+                'max_depth': 0,
+                'value_types': {}
+            }
+
+        # Get top-level keys with line numbers
+        top_level_keys = []
+        if isinstance(self.parsed_data, dict):
+            for key in self.parsed_data.keys():
+                # Find where this key is defined in the source file
+                # Look for the key as a quoted string (JSON format)
+                line_num = self.find_definition(f'"{key}"', case_sensitive=True)
+                if line_num is None:
+                    # Fallback: try without quotes (for malformed JSON)
+                    line_num = self.find_definition(key, case_sensitive=True)
+
+                top_level_keys.append({
+                    'name': key,
+                    'line': line_num if line_num is not None else 1
+                })
+
+        # Count objects and arrays
+        object_count, array_count = self._count_structures(self.parsed_data)
+
+        # Calculate max depth
+        max_depth = self._calculate_depth(self.parsed_data)
+
+        # Count value types
+        value_types = self._count_value_types(self.parsed_data)
+
+        return {
+            'top_level_keys': top_level_keys,
+            'object_count': object_count,
+            'array_count': array_count,
+            'max_depth': max_depth,
+            'value_types': value_types
+        }
+
+    def _count_structures(self, obj: Any) -> tuple[int, int]:
+        """Count objects and arrays recursively."""
+        object_count = 0
+        array_count = 0
+
+        if isinstance(obj, dict):
+            object_count += 1
+            for value in obj.values():
+                obj_c, arr_c = self._count_structures(value)
+                object_count += obj_c
+                array_count += arr_c
+        elif isinstance(obj, list):
+            array_count += 1
+            for item in obj:
+                obj_c, arr_c = self._count_structures(item)
+                object_count += obj_c
+                array_count += arr_c
+
+        return object_count, array_count
+
+    def _calculate_depth(self, obj: Any, current_depth: int = 0) -> int:
+        """Calculate maximum nesting depth."""
+        if isinstance(obj, dict):
+            if not obj:
+                return current_depth
+            return max(self._calculate_depth(v, current_depth + 1) for v in obj.values())
+        elif isinstance(obj, list):
+            if not obj:
+                return current_depth
+            return max(self._calculate_depth(item, current_depth + 1) for item in obj)
+        else:
+            return current_depth
+
+    def _count_value_types(self, obj: Any) -> Dict[str, int]:
+        """Count value types in JSON."""
+        types = {}
+
+        def count_type(value):
+            type_name = type(value).__name__
+            if type_name == 'NoneType':
+                type_name = 'null'
+            elif type_name == 'bool':
+                type_name = 'boolean'
+            elif type_name == 'int' or type_name == 'float':
+                type_name = 'number'
+            types[type_name] = types.get(type_name, 0) + 1
+
+        def traverse(item):
+            if isinstance(item, dict):
+                for value in item.values():
+                    traverse(value)
+            elif isinstance(item, list):
+                for element in item:
+                    traverse(element)
+            else:
+                count_type(item)
+
+        traverse(obj)
+        return types
+
+    def generate_preview(self) -> List[tuple[int, str]]:
+        """Generate JSON preview (first 10 key/value pairs or 20 lines)."""
+        preview = []
+
+        if self.parse_error:
+            # Fallback to first 20 lines
+            for i, line in enumerate(self.lines[:20], 1):
+                preview.append((i, line))
+            return preview
+
+        # Show first 20 lines
+        for i, line in enumerate(self.lines[:20], 1):
+            preview.append((i, line))
+
+        return preview