reveal-cli 0.8.0__py3-none-any.whl

plugins/c-header.yaml

@@ -0,0 +1,89 @@
+# C/C++ Header File Plugin
+# Provides 4-level progressive disclosure for .h and .hpp files
+
+extension: [.h, .hpp, .hh]
+name: C/C++ Header
+description: C and C++ header files
+icon: 🔧
+
+levels:
+  0:
+    name: metadata
+    description: File statistics and basic info
+    breadcrumb: "File metadata"
+    analyzer: null
+    outputs:
+      - file_size
+      - line_count
+      - encoding
+      - header_guards
+      - include_count
+    next_levels: [1, 2, 3]
+
+  1:
+    name: structure
+    description: Declarations, includes, and definitions
+    breadcrumb: "Includes, defines, declarations"
+    analyzer: c_header_structure
+    outputs:
+      - includes
+      - defines
+      - typedefs
+      - struct_declarations
+      - function_declarations
+      - class_declarations  # C++
+      - namespaces  # C++
+      - template_declarations  # C++
+    next_levels: [0, 2, 3]
+    tips:
+      - "Use --grep to find specific declarations"
+      - "Level 2 shows function signatures"
+
+  2:
+    name: preview
+    description: Declarations with signatures
+    breadcrumb: "Function signatures, struct definitions"
+    analyzer: c_header_preview
+    outputs:
+      - function_signatures
+      - struct_definitions
+      - class_definitions
+      - template_definitions
+      - documentation_comments
+    next_levels: [0, 1, 3]
+    tips:
+      - "See implementation details with --level 3"
+
+  3:
+    name: full
+    description: Complete header content
+    breadcrumb: "Complete header file (paged)"
+    analyzer: null
+    outputs:
+      - full_content
+    next_levels: [0, 1, 2]
+    paging: true
+    page_size: 120
+
+features:
+  grep: true
+  context: true
+  paging: true
+  line_numbers: true
+  syntax_highlighting: true
+
+analyzer_config:
+  parse_comments: true
+  extract_doxygen: true
+  include_private: true
+  detect_extern_c: true
+
+examples:
+  - command: "reveal mylib.h"
+    description: "Show header metadata"
+  - command: "reveal mylib.h -l 1"
+    description: "Show includes and declarations"
+  - command: "reveal mylib.h -l 2 --grep 'process'"
+    description: "Preview process function signatures"
+  - command: "reveal mylib.h -l 3"
+    description: "Show complete header content"

plugins/gdscript.yaml

@@ -0,0 +1,96 @@
+# GDScript File Plugin
+# Provides 4-level progressive disclosure for Godot Engine .gd files
+
+extension: .gd
+name: GDScript
+description: Godot Engine GDScript files with structure analysis
+icon: 🎮
+
+# Hierarchical levels - each level reveals more detail
+levels:
+  0:
+    name: metadata
+    description: File statistics and basic information
+    breadcrumb: "File metadata (size, encoding, line count)"
+    analyzer: null  # Built-in metadata analyzer
+    outputs:
+      - file_size
+      - line_count
+      - encoding
+      - last_modified
+      - file_type
+    next_levels: [1, 2, 3]
+
+  1:
+    name: structure
+    description: Code structure without implementations
+    breadcrumb: "Class, signals, exports, functions (structure only)"
+    analyzer: gdscript_structure
+    outputs:
+      - extends
+      - class_name
+      - signals
+      - exports
+      - constants
+      - variables
+      - functions
+    next_levels: [0, 2, 3]
+    tips:
+      - "Use --grep 'function_name' to filter specific functions"
+      - "Add --context 2 to see surrounding context"
+
+  2:
+    name: preview
+    description: Key elements without full code
+    breadcrumb: "Extends, signals, exports, function signatures"
+    analyzer: gdscript_preview
+    outputs:
+      - class_declaration
+      - signals
+      - exports
+      - function_signatures
+      - constants
+    next_levels: [0, 1, 3]
+    tips:
+      - "See full implementation with --level 3"
+      - "Filter by element name with --grep"
+
+  3:
+    name: full
+    description: Complete source code with paging
+    breadcrumb: "Complete file contents (paged)"
+    analyzer: null  # Built-in full content reader
+    outputs:
+      - full_source
+    next_levels: [0, 1, 2]
+    paging: true
+    page_size: 120
+    tips:
+      - "Use --grep to filter lines"
+      - "Add --context N for surrounding lines"
+
+# Features available at all levels
+features:
+  grep: true
+  context: true
+  paging: true
+  line_numbers: true
+  syntax_highlighting: false
+
+# Analyzer configuration
+analyzer_config:
+  include_lifecycle_funcs: true
+  include_private_vars: true
+  parse_comments: true
+  extract_signals: true
+
+# Examples shown in help text
+examples:
+  - command: "reveal player.gd"
+    description: "Show file metadata (level 0)"
+  - command: "reveal player.gd -l 1"
+    description: "Show code structure (signals, exports, functions)"
+  - command: "reveal player.gd -l 2 --grep '_ready'"
+    description: "Preview _ready function and nearby code"
+  - command: "reveal player.gd -l 3 --grep 'func take_damage' -C 5"
+    description: "Show take_damage function with 5 lines context"

plugins/python.yaml

@@ -0,0 +1,94 @@
+# Python Source File Plugin
+# Provides 4-level progressive disclosure for .py files
+
+extension: .py
+name: Python Source
+description: Python source files with AST-based analysis
+icon: 🐍
+
+# Hierarchical levels - each level reveals more detail
+levels:
+  0:
+    name: metadata
+    description: File statistics and basic information
+    breadcrumb: "File metadata (size, encoding, line count)"
+    analyzer: null  # Built-in metadata analyzer
+    outputs:
+      - file_size
+      - line_count
+      - encoding
+      - last_modified
+      - file_type
+    next_levels: [1, 2, 3]
+
+  1:
+    name: structure
+    description: Code structure without implementations
+    breadcrumb: "Imports, classes, functions (structure only)"
+    analyzer: python_structure
+    outputs:
+      - imports
+      - classes
+      - functions
+      - global_variables
+      - decorators
+    next_levels: [0, 2, 3]
+    tips:
+      - "Use --grep 'ClassName' to filter specific classes"
+      - "Add --context 2 to see surrounding context"
+
+  2:
+    name: preview
+    description: Signatures and docstrings without full code
+    breadcrumb: "Function signatures, docstrings, type hints"
+    analyzer: python_preview
+    outputs:
+      - function_signatures
+      - class_signatures
+      - docstrings
+      - type_hints
+      - decorators_with_args
+    next_levels: [0, 1, 3]
+    tips:
+      - "See full implementation with --level 3"
+      - "Filter by function name with --grep"
+
+  3:
+    name: full
+    description: Complete source code with paging
+    breadcrumb: "Complete file contents (paged)"
+    analyzer: null  # Built-in full content reader
+    outputs:
+      - full_source
+    next_levels: [0, 1, 2]
+    paging: true
+    page_size: 120
+    tips:
+      - "Use --grep to filter lines"
+      - "Add --context N for surrounding lines"
+
+# Features available at all levels
+features:
+  grep: true
+  context: true
+  paging: true
+  line_numbers: true
+  syntax_highlighting: true  # Future
+
+# Analyzer configuration
+analyzer_config:
+  include_private: false
+  include_magic: false
+  parse_docstrings: true
+  extract_type_hints: true
+
+# Examples shown in help text
+examples:
+  - command: "reveal app.py"
+    description: "Show file metadata (level 0)"
+  - command: "reveal app.py -l 1"
+    description: "Show code structure (imports, classes, functions)"
+  - command: "reveal app.py -l 2 --grep 'UserManager'"
+    description: "Preview UserManager class signatures"
+  - command: "reveal app.py -l 3 --grep 'def process' -C 5"
+    description: "Show process functions with 5 lines context"

plugins/yaml.yaml

@@ -0,0 +1,87 @@
+# YAML File Plugin
+# Provides 4-level progressive disclosure for .yaml and .yml files
+
+extension: [.yaml, .yml]
+name: YAML
+description: YAML configuration and data files
+icon: 📝
+
+levels:
+  0:
+    name: metadata
+    description: File statistics and YAML characteristics
+    breadcrumb: "File metadata and YAML info"
+    analyzer: null
+    outputs:
+      - file_size
+      - line_count
+      - encoding
+      - yaml_version
+      - has_anchors
+      - has_aliases
+      - document_count
+    next_levels: [1, 2, 3]
+
+  1:
+    name: structure
+    description: Top-level keys and nested structure
+    breadcrumb: "Top-level keys and nesting depth"
+    analyzer: yaml_structure
+    outputs:
+      - top_level_keys
+      - nesting_depth
+      - key_paths
+      - data_types
+      - anchors
+      - aliases
+    next_levels: [0, 2, 3]
+    tips:
+      - "Use --grep 'database' to find database config"
+      - "See full values with --level 2"
+
+  2:
+    name: preview
+    description: Keys with value summaries
+    breadcrumb: "Keys with abbreviated values"
+    analyzer: yaml_preview
+    outputs:
+      - keys_with_values
+      - value_summaries
+      - list_lengths
+      - object_keys
+    next_levels: [0, 1, 3]
+    tips:
+      - "Long values are truncated - use level 3 for full content"
+
+  3:
+    name: full
+    description: Complete YAML content
+    breadcrumb: "Complete YAML content (paged)"
+    analyzer: null
+    outputs:
+      - full_content
+    next_levels: [0, 1, 2]
+    paging: true
+    page_size: 120
+
+features:
+  grep: true
+  context: true
+  paging: true
+  line_numbers: true
+  syntax_highlighting: true
+
+analyzer_config:
+  max_value_preview_length: 80
+  show_types: true
+  expand_anchors: false
+
+examples:
+  - command: "reveal config.yaml"
+    description: "Show YAML metadata"
+  - command: "reveal config.yaml -l 1"
+    description: "Show top-level structure"
+  - command: "reveal config.yaml -l 2 --grep 'database'"
+    description: "Preview database configuration"
+  - command: "reveal config.yaml -l 3"
+    description: "Show complete YAML content"

reveal/__init__.py

@@ -0,0 +1,26 @@
+"""Reveal - Explore code semantically.
+
+A clean, simple tool for progressive code exploration.
+"""
+
+# Version is read from pyproject.toml at runtime
+try:
+    from importlib.metadata import version
+    __version__ = version("reveal-cli")
+except Exception:
+    # Fallback for development/editable installs
+    __version__ = "0.8.0-dev"
+
+# Import base classes for external use
+from .base import FileAnalyzer, register, get_analyzer
+from .treesitter import TreeSitterAnalyzer
+
+# Import all built-in analyzers to register them
+from .analyzers import *
+
+__all__ = [
+    'FileAnalyzer',
+    'TreeSitterAnalyzer',
+    'register',
+    'get_analyzer',
+]

reveal/analyzers/__init__.py

@@ -0,0 +1,39 @@
+"""Built-in analyzers for reveal.
+
+This package contains reference implementations showing how easy it is
+to add new file type support.
+
+Each analyzer is typically 10-20 lines of code!
+"""
+
+# Import all analyzers to register them
+from .python import PythonAnalyzer
+from .rust import RustAnalyzer
+from .go import GoAnalyzer
+from .markdown import MarkdownAnalyzer
+from .yaml_json import YamlAnalyzer, JsonAnalyzer
+from .gdscript import GDScriptAnalyzer
+from .jupyter_analyzer import JupyterAnalyzer
+from .javascript import JavaScriptAnalyzer
+from .typescript import TypeScriptAnalyzer
+from .bash import BashAnalyzer
+from .nginx import NginxAnalyzer
+from .toml import TomlAnalyzer
+from .dockerfile import DockerfileAnalyzer
+
+__all__ = [
+    'PythonAnalyzer',
+    'RustAnalyzer',
+    'GoAnalyzer',
+    'MarkdownAnalyzer',
+    'YamlAnalyzer',
+    'JsonAnalyzer',
+    'GDScriptAnalyzer',
+    'JupyterAnalyzer',
+    'JavaScriptAnalyzer',
+    'TypeScriptAnalyzer',
+    'BashAnalyzer',
+    'NginxAnalyzer',
+    'TomlAnalyzer',
+    'DockerfileAnalyzer',
+]

reveal/analyzers/bash.py

@@ -0,0 +1,44 @@
+"""Bash/Shell script analyzer - tree-sitter based."""
+
+from typing import Optional
+from ..base import register
+from ..treesitter import TreeSitterAnalyzer
+
+
+@register('.sh', name='Shell Script', icon='🐚')
+@register('.bash', name='Bash Script', icon='🐚')
+class BashAnalyzer(TreeSitterAnalyzer):
+    """Bash/Shell script analyzer.
+
+    Full shell script support via tree-sitter!
+    Extracts:
+    - Function definitions
+    - Variable assignments
+    - Command invocations
+
+    Cross-platform compatible:
+    - Analyzes bash scripts on any OS (Windows/Linux/macOS)
+    - Does NOT execute scripts, only parses syntax
+    - Useful for DevOps/deployment script exploration
+    - Works with WSL, Git Bash, and native Unix shells
+
+    Note: This analyzes bash script SYNTAX, regardless of the host OS.
+    """
+    language = 'bash'
+
+    def _get_function_name(self, node) -> Optional[str]:
+        """Extract function name from bash function_definition node.
+
+        Bash tree-sitter uses 'word' for function names, not 'identifier'.
+
+        Bash function syntax:
+        - function name() { ... }  # 'function' keyword, then 'word'
+        - name() { ... }           # just 'word'
+        """
+        # Look for 'word' child (bash uses this instead of 'identifier')
+        for child in node.children:
+            if child.type == 'word':
+                return self._get_node_text(child)
+
+        # Fallback to parent implementation
+        return super()._get_function_name(node)

reveal/analyzers/dockerfile.py

@@ -0,0 +1,179 @@
+"""Dockerfile analyzer."""
+
+import re
+from typing import Dict, List, Any, Optional
+from ..base import FileAnalyzer, register
+
+
+@register('Dockerfile', name='Dockerfile', icon='🐳')
+class DockerfileAnalyzer(FileAnalyzer):
+    """Dockerfile analyzer.
+
+    Extracts Docker directives (FROM, RUN, COPY, ENV, EXPOSE, etc.).
+    """
+
+    def get_structure(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Extract Dockerfile directives."""
+        from_images = []
+        runs = []
+        copies = []
+        envs = []
+        exposes = []
+        workdirs = []
+        entrypoints = []
+        cmds = []
+        labels = []
+        args = []
+
+        # Track multi-line continuations
+        continued_line = ""
+        continued_start = 0
+
+        for i, line in enumerate(self.lines, 1):
+            stripped = line.strip()
+
+            # Handle line continuations (\)
+            if continued_line:
+                continued_line += " " + stripped.rstrip('\\')
+                if not stripped.endswith('\\'):
+                    # Process the complete continued line
+                    self._process_directive(
+                        continued_line, continued_start,
+                        from_images, runs, copies, envs, exposes,
+                        workdirs, entrypoints, cmds, labels, args
+                    )
+                    continued_line = ""
+                continue
+
+            # Skip empty lines and comments
+            if not stripped or stripped.startswith('#'):
+                continue
+
+            # Check for line continuation
+            if stripped.endswith('\\'):
+                continued_line = stripped.rstrip('\\')
+                continued_start = i
+                continue
+
+            # Process single-line directive
+            self._process_directive(
+                stripped, i,
+                from_images, runs, copies, envs, exposes,
+                workdirs, entrypoints, cmds, labels, args
+            )
+
+        # Build result
+        result = {}
+        if from_images:
+            result['from'] = from_images
+        if runs:
+            result['run'] = runs
+        if copies:
+            result['copy'] = copies
+        if envs:
+            result['env'] = envs
+        if exposes:
+            result['expose'] = exposes
+        if workdirs:
+            result['workdir'] = workdirs
+        if entrypoints:
+            result['entrypoint'] = entrypoints
+        if cmds:
+            result['cmd'] = cmds
+        if labels:
+            result['label'] = labels
+        if args:
+            result['arg'] = args
+
+        return result
+
+    def _process_directive(self, line: str, line_num: int,
+                          from_images, runs, copies, envs, exposes,
+                          workdirs, entrypoints, cmds, labels, args):
+        """Process a single Dockerfile directive."""
+        # Match directive at start of line
+        directive_match = re.match(r'^([A-Z]+)\s+(.+)$', line)
+        if not directive_match:
+            return
+
+        directive = directive_match.group(1)
+        args_str = directive_match.group(2).strip()
+
+        if directive == 'FROM':
+            # Extract base image
+            from_images.append({
+                'line': line_num,
+                'name': args_str,
+            })
+
+        elif directive == 'RUN':
+            # Truncate long commands
+            display = args_str[:80] + '...' if len(args_str) > 80 else args_str
+            runs.append({
+                'line': line_num,
+                'content': display,
+            })
+
+        elif directive in ['COPY', 'ADD']:
+            # Extract source -> dest
+            copies.append({
+                'line': line_num,
+                'content': args_str,
+            })
+
+        elif directive == 'ENV':
+            # Extract environment variable
+            envs.append({
+                'line': line_num,
+                'content': args_str,
+            })
+
+        elif directive == 'EXPOSE':
+            # Extract port
+            exposes.append({
+                'line': line_num,
+                'content': args_str,
+            })
+
+        elif directive == 'WORKDIR':
+            workdirs.append({
+                'line': line_num,
+                'content': args_str,
+            })
+
+        elif directive == 'ENTRYPOINT':
+            entrypoints.append({
+                'line': line_num,
+                'content': args_str,
+            })
+
+        elif directive == 'CMD':
+            cmds.append({
+                'line': line_num,
+                'content': args_str,
+            })
+
+        elif directive == 'LABEL':
+            labels.append({
+                'line': line_num,
+                'content': args_str,
+            })
+
+        elif directive == 'ARG':
+            args.append({
+                'line': line_num,
+                'content': args_str,
+            })
+
+    def extract_element(self, element_type: str, name: str) -> Optional[Dict[str, Any]]:
+        """Extract a specific directive or stage.
+
+        Args:
+            element_type: 'from', 'run', etc.
+            name: Search term
+
+        Returns:
+            Dict with directive content
+        """
+        # Fall back to grep-based search
+        return super().extract_element(element_type, name)