fancy-tree 0.1.0__tar.gz

fancy_tree-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: fancy-tree
+Version: 0.1.0
+Summary: Git-enabled, cross-language code analysis that makes tree-sitter as easy as the tree command
+Author: Antoine Descamps, Ishan Tiwari
+License: MIT
+Project-URL: Homepage, https://github.com/dant2021/fancy-tree
+Project-URL: Bug Reports, https://github.com/dant2021/fancy-tree/issues
+Project-URL: Source, https://github.com/dant2021/fancy-tree
+Keywords: git,tree-sitter,code-analysis,multi-language,ast
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: tree-sitter>=0.20.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: tree-sitter-language-pack>=0.9.0
+Provides-Extra: python
+Requires-Dist: tree-sitter-python>=0.20.0; extra == "python"
+Provides-Extra: typescript
+Requires-Dist: tree-sitter-typescript>=0.20.0; extra == "typescript"
+Provides-Extra: java
+Requires-Dist: tree-sitter-java>=0.20.0; extra == "java"
+Provides-Extra: javascript
+Requires-Dist: tree-sitter-javascript>=0.20.0; extra == "javascript"
+Provides-Extra: rust
+Requires-Dist: tree-sitter-rust>=0.20.0; extra == "rust"
+Provides-Extra: go
+Requires-Dist: tree-sitter-go>=0.20.0; extra == "go"
+Provides-Extra: cpp
+Requires-Dist: tree-sitter-cpp>=0.20.0; extra == "cpp"
+Provides-Extra: all-languages
+Requires-Dist: tree-sitter-python>=0.20.0; extra == "all-languages"
+Requires-Dist: tree-sitter-typescript>=0.20.0; extra == "all-languages"
+Requires-Dist: tree-sitter-java>=0.20.0; extra == "all-languages"
+Requires-Dist: tree-sitter-javascript>=0.20.0; extra == "all-languages"
+Requires-Dist: tree-sitter-rust>=0.20.0; extra == "all-languages"
+Requires-Dist: tree-sitter-go>=0.20.0; extra == "all-languages"
+Requires-Dist: tree-sitter-cpp>=0.20.0; extra == "all-languages"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Provides-Extra: build
+Requires-Dist: build>=0.8.0; extra == "build"
+Requires-Dist: twine>=4.0.0; extra == "build"

fancy_tree-0.1.0/fancy_tree/cli.py

@@ -0,0 +1,160 @@
+"""Command-line interface for fancy_tree."""
+
+import sys
+import json
+from pathlib import Path
+from typing import Optional, List
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from .core.extraction import process_repository
+from .core.formatter import format_repository_tree
+
+app = typer.Typer(name="fancy-tree", help="Git-enabled, cross-language code analysis with tree-sitter")
+console = Console()
+
+
+@app.command()
+def scan(
+    path: Optional[Path] = typer.Argument(None, help="Repository path to scan (default: current directory)"),
+    languages: Optional[List[str]] = typer.Option(None, "--lang", "-l", help="Filter by specific languages"),
+    max_files: Optional[int] = typer.Option(None, "--max-files", "-m", help="Maximum number of files to process"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file path (default: stdout)"),
+    format: str = typer.Option("tree", "--format", "-f", help="Output format: tree, json"),
+    group_by_language: bool = typer.Option(True, "--group-by-lang/--group-by-structure", help="Group output by language or directory structure"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Suppress progress output"),
+):
+    """Scan a repository and extract code structure."""
+    
+    # Default to current directory
+    if path is None:
+        path = Path.cwd()
+    
+    # Validate path
+    if not path.exists():
+        console.print(f"Error: Path '{path}' does not exist", style="red")
+        raise typer.Exit(1)
+    
+    if not path.is_dir():
+        console.print(f"Error: Path '{path}' is not a directory", style="red")
+        raise typer.Exit(1)
+    
+    if not quiet:
+        console.print(f"Scanning repository: {path}")
+        if languages:
+            console.print(f"Language filter: {', '.join(languages)}")
+        if max_files:
+            console.print(f"Max files: {max_files}")
+    
+    try:
+        # Process repository
+        repo_summary = process_repository(
+            repo_path=path,
+            language_filter=languages,
+            max_files=max_files
+        )
+        
+        # Format output
+        if format == "json":
+            output_content = json.dumps(repo_summary.to_dict(), indent=2)
+        elif format == "tree":
+            output_content = format_repository_tree(
+                repo_summary, 
+                group_by_language=group_by_language
+            )
+        else:
+            console.print(f"Error: Unknown format '{format}'. Use 'tree' or 'json'", style="red")
+            raise typer.Exit(1)
+        
+        # Output results
+        if output:
+            output.write_text(output_content, encoding='utf-8')
+            if not quiet:
+                console.print(f"Results written to: {output}")
+        else:
+            console.print(output_content)
+        
+        if not quiet:
+            console.print(f"\nProcessed {repo_summary.total_files} files in {len(repo_summary.languages)} languages")
+    
+    except Exception as e:
+        console.print(f"Error processing repository: {e}", style="red")
+        if not quiet:
+            import traceback
+            console.print(traceback.format_exc())
+        raise typer.Exit(1)
+
+
+@app.command()
+def languages():
+    """List supported languages and their status."""
+    from .extractors import list_supported_languages
+    from .core.config import detect_available_languages
+    
+    console.print(Panel("Fancy Tree - Supported Languages", style="bold blue"))
+    
+    # Show implemented extractors
+    supported = list_supported_languages()
+    console.print(f"\nImplemented extractors: {len(supported)}")
+    for lang in sorted(supported):
+        console.print(f"  ✓ {lang}")
+    
+    # Try to detect language availability in current directory
+    try:
+        current_path = Path.cwd()
+        availability = detect_available_languages(current_path)
+        
+        if availability:
+            console.print(f"\nLanguages detected in {current_path}:")
+            for lang, info in availability.items():
+                status = "AVAILABLE" if info.get("parser_available", False) else "PARSER MISSING"
+                file_count = info.get("file_count", 0)
+                console.print(f"  {lang}: {file_count} files ({status})")
+        
+    except Exception as e:
+        console.print(f"\nNote: Could not detect languages in current directory: {e}")
+
+
+@app.command()
+def version():
+    """Show version information."""
+    try:
+        from . import __version__
+    except ImportError:
+        __version__ = "1.0.0"
+    console.print(f"fancy-tree version {__version__}")
+
+
+@app.command()
+def test(
+    path: Optional[Path] = typer.Argument(None, help="Path to test (default: current directory)")
+):
+    """Test fancy_tree functionality on a directory."""
+    if path is None:
+        path = Path.cwd()
+    
+    console.print(Panel(f"Testing fancy_tree on: {path}", style="bold green"))
+    
+    try:
+        # Quick test
+        repo_summary = process_repository(path, max_files=10)
+        
+        console.print(f"✓ Successfully processed {repo_summary.total_files} files")
+        console.print(f"✓ Found {len(repo_summary.languages)} languages: {list(repo_summary.languages.keys())}")
+        
+        # Show supported vs unsupported
+        supported_count = sum(1 for supported in repo_summary.supported_languages.values() if supported)
+        total_langs = len(repo_summary.supported_languages)
+        console.print(f"✓ Language support: {supported_count}/{total_langs} languages supported")
+        
+        console.print("\nTest completed successfully!")
+        
+    except Exception as e:
+        console.print(f"✗ Test failed: {e}", style="red")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app() 

fancy_tree-0.1.0/fancy_tree/config/__init__.py

@@ -0,0 +1,8 @@
+"""Configuration management for fancy_tree."""
+
+from pathlib import Path
+
+# Path to the languages configuration
+LANGUAGES_CONFIG_PATH = Path(__file__).parent / "languages.yaml"
+
+__all__ = ["LANGUAGES_CONFIG_PATH"]

fancy_tree-0.1.0/fancy_tree/config/languages.yaml

@@ -0,0 +1,95 @@
+# Extended language configuration for fancy_tree
+# Multi-language symbol extraction with tree-sitter
+
+python:
+  extensions: [".py"]
+  function_nodes: ["function_definition"]
+  class_nodes: ["class_definition"] 
+  name_nodes: ["identifier"]
+  signature_templates:
+    function: "def {name}({params})"
+    method: "def {name}({params})"
+    class: "class {name}"
+  tree_sitter_package: "tree-sitter-python"
+  
+typescript:
+  extensions: [".ts", ".tsx"]
+  function_nodes: ["function_declaration", "method_definition", "arrow_function"]
+  class_nodes: ["class_declaration"]
+  interface_nodes: ["interface_declaration"]
+  name_nodes: ["identifier", "type_identifier"]
+  signature_templates:
+    function: "function {name}({params}): {return_type}"
+    method: "{name}({params}): {return_type}"
+    class: "class {name}"
+    interface: "interface {name}"
+  tree_sitter_package: "tree-sitter-typescript"
+
+java:
+  extensions: [".java"]
+  function_nodes: ["method_declaration", "constructor_declaration"]
+  class_nodes: ["class_declaration", "interface_declaration", "enum_declaration"]
+  name_nodes: ["identifier"]
+  signature_templates:
+    method: "{visibility} {return_type} {name}({params})"
+    constructor: "{visibility} {name}({params})"
+    class: "{visibility} class {name}"
+    interface: "{visibility} interface {name}"
+    enum: "{visibility} enum {name}"
+  tree_sitter_package: "tree-sitter-java"
+
+# Placeholder configurations for future languages
+javascript:
+  extensions: [".js", ".jsx"]
+  function_nodes: ["function_declaration", "method_definition", "arrow_function"]
+  class_nodes: ["class_declaration"]
+  name_nodes: ["identifier"]
+  signature_templates:
+    function: "function {name}({params})"
+    method: "{name}({params})"
+    class: "class {name}"
+  tree_sitter_package: "tree-sitter-javascript"
+
+rust:
+  extensions: [".rs"]
+  function_nodes: ["function_item"]
+  class_nodes: ["struct_item", "impl_item", "trait_item"]
+  name_nodes: ["identifier", "type_identifier"]
+  signature_templates:
+    function: "fn {name}({params}) -> {return_type}"
+    struct: "struct {name}"
+    trait: "trait {name}"
+  tree_sitter_package: "tree-sitter-rust"
+
+go:
+  extensions: [".go"]
+  function_nodes: ["function_declaration", "method_declaration"]
+  class_nodes: ["type_declaration"]
+  name_nodes: ["identifier"]
+  signature_templates:
+    function: "func {name}({params}) {return_type}"
+    method: "func ({receiver}) {name}({params}) {return_type}"
+    type: "type {name}"
+  tree_sitter_package: "tree-sitter-go"
+
+# Build files and special configurations
+build_files:
+  - "build.gradle"
+  - "build.gradle.kts" 
+  - "pom.xml"
+  - "package.json"
+  - "Cargo.toml"
+  - "go.mod"
+  - "pyproject.toml"
+  - "requirements.txt"
+
+# File patterns to ignore
+ignore_patterns:
+  - "__pycache__"
+  - "node_modules"
+  - ".git"
+  - "dist"
+  - "build"
+  - "target"
+  - "*.pyc"
+  - "*.class"

fancy_tree-0.1.0/fancy_tree/core/__init__.py

@@ -0,0 +1,45 @@
+"""Core functionality for fancy_tree."""
+
+from .config import (
+    get_language_config, 
+    detect_language, 
+    detect_available_languages,
+    show_language_status_and_install
+)
+from .discovery import (
+    discover_files, 
+    classify_files, 
+    scan_repository,
+    get_repository_info
+)
+from .extraction import (
+    extract_symbols_generic,
+    extract_symbols_from_file,
+    process_repository,
+    get_parser_for_language
+)
+from .formatter import (
+    format_repository_tree,
+    EnhancedTreeFormatter
+)
+
+__all__ = [
+    # Config
+    "get_language_config",
+    "detect_language", 
+    "detect_available_languages",
+    "show_language_status_and_install",
+    # Discovery
+    "discover_files",
+    "classify_files",
+    "scan_repository", 
+    "get_repository_info",
+    # Extraction
+    "extract_symbols_generic",
+    "extract_symbols_from_file",
+    "process_repository",
+    "get_parser_for_language",
+    # Formatting
+    "format_repository_tree",
+    "EnhancedTreeFormatter"
+]

fancy_tree-0.1.0/fancy_tree/core/config.py

@@ -0,0 +1,258 @@
+"""Configuration management and dynamic dependency detection."""
+
+import subprocess
+import sys
+import yaml
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Any
+from rich.console import Console
+import typer
+
+console = Console()
+
+class LanguageConfig:
+    """Configuration for a single language."""
+    
+    def __init__(self, language: str, config_dict: Dict[str, Any]):
+        self.language = language
+        self.extensions = config_dict.get("extensions", [])
+        self.function_nodes = config_dict.get("function_nodes", [])
+        self.class_nodes = config_dict.get("class_nodes", [])
+        self.interface_nodes = config_dict.get("interface_nodes", [])
+        self.name_nodes = config_dict.get("name_nodes", ["identifier"])
+        self.signature_templates = config_dict.get("signature_templates", {})
+        self.tree_sitter_package = config_dict.get("tree_sitter_package", f"tree-sitter-{language}")
+        self.language_function = config_dict.get("language_function", "language")
+    
+    def get_template(self, symbol_type: str) -> str:
+        """Get signature template for symbol type with fallback."""
+        return self.signature_templates.get(symbol_type, f"{symbol_type} {{name}}")
+    
+    def __repr__(self):
+        return f"LanguageConfig({self.language}, {len(self.extensions)} extensions)"
+
+
+class ConfigManager:
+    """Manages language configurations and dependencies."""
+    
+    def __init__(self, config_path: Optional[Path] = None):
+        if config_path is None:
+            config_path = Path(__file__).parent.parent / "config" / "languages.yaml"
+        
+        self.config_path = config_path
+        self.languages: Dict[str, LanguageConfig] = {}
+        self.build_files: List[str] = []
+        self.ignore_patterns: List[str] = []
+        self._loaded = False
+    
+    def load_config(self) -> None:
+        """Load language configuration from YAML."""
+        if self._loaded:
+            return
+        
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config = yaml.safe_load(f)
+            
+            # Load language configurations
+            for lang_name, lang_config in config.items():
+                if lang_name in ['build_files', 'ignore_patterns']:
+                    continue
+                
+                if isinstance(lang_config, dict) and 'extensions' in lang_config:
+                    self.languages[lang_name] = LanguageConfig(lang_name, lang_config)
+            
+            # Load special configurations
+            self.build_files = config.get('build_files', [])
+            self.ignore_patterns = config.get('ignore_patterns', [])
+            
+            self._loaded = True
+            
+        except (FileNotFoundError, yaml.YAMLError) as e:
+            console.print(f"Warning: Could not load language config: {e}")
+    
+    def get_language_config(self, language: str) -> Optional[LanguageConfig]:
+        """Get configuration for specific language."""
+        self.load_config()
+        return self.languages.get(language)
+    
+    def detect_language_from_extension(self, file_path: Path) -> Optional[str]:
+        """Detect language from file extension."""
+        self.load_config()
+        file_ext = file_path.suffix.lower()
+        
+        for lang_name, lang_config in self.languages.items():
+            if file_ext in lang_config.extensions:
+                return lang_name
+        
+        return None
+    
+    def scan_file_extensions(self, repo_path: Path) -> Set[str]:
+        """Scan repository for file extensions."""
+        extensions = set()
+        
+        try:
+            # Use git ls-files if available
+            result = subprocess.run(
+                ['git', 'ls-files'], 
+                cwd=repo_path, 
+                capture_output=True, 
+                text=True,
+                timeout=30
+            )
+            
+            if result.returncode == 0:
+                for file_line in result.stdout.strip().split('\n'):
+                    if file_line.strip():
+                        ext = Path(file_line).suffix.lower()
+                        if ext:
+                            extensions.add(ext)
+            else:
+                # Fallback to file system scan
+                for file_path in repo_path.rglob('*'):
+                    if file_path.is_file():
+                        ext = file_path.suffix.lower()
+                        if ext:
+                            extensions.add(ext)
+                            
+        except (subprocess.TimeoutExpired, subprocess.SubprocessError, Exception):
+            # Fallback to file system scan
+            for file_path in repo_path.rglob('*'):
+                if file_path.is_file():
+                    ext = file_path.suffix.lower()
+                    if ext:
+                        extensions.add(ext)
+        
+        return extensions
+    
+    def detect_available_languages(self, repo_path: Path) -> Dict[str, Dict[str, Any]]:
+        """Detect which languages exist in repo and which parsers are available."""
+        self.load_config()
+        file_extensions = self.scan_file_extensions(repo_path)
+        language_availability = {}
+        
+        for lang_name, lang_config in self.languages.items():
+            # Check if files of this language exist
+            has_files = any(ext in file_extensions for ext in lang_config.extensions)
+            
+            if has_files:
+                # Check if tree-sitter package is available
+                package_name = lang_config.tree_sitter_package
+                module_name = package_name.replace('-', '_')
+                
+                try:
+                    __import__(module_name)
+                    parser_available = True
+                except ImportError:
+                    parser_available = False
+                
+                language_availability[lang_name] = {
+                    "has_files": has_files,
+                    "parser_available": parser_available,
+                    "package_name": package_name,
+                    "file_count": len([ext for ext in file_extensions if ext in lang_config.extensions])
+                }
+        
+        return language_availability
+    
+    def install_missing_packages(self, missing_packages: List[str]) -> bool:
+        """Attempt auto-installation with user permission."""
+        if not missing_packages:
+            return True
+        
+        console.print(f"Missing tree-sitter packages for optimal support:")
+        for package in missing_packages:
+            console.print(f"  - {package}")
+        
+        install = typer.confirm("Install missing packages automatically?")
+        
+        if install:
+            console.print("Installing packages...")
+            success_count = 0
+            
+            for package in missing_packages:
+                try:
+                    console.print(f"Installing {package}...")
+                    result = subprocess.run(
+                        [sys.executable, "-m", "pip", "install", package],
+                        capture_output=True,
+                        text=True,
+                        timeout=120
+                    )
+                    
+                    if result.returncode == 0:
+                        console.print(f"SUCCESS: {package} installed successfully")
+                        success_count += 1
+                    else:
+                        console.print(f"ERROR: Failed to install {package}: {result.stderr}")
+                        
+                except (subprocess.TimeoutExpired, subprocess.SubprocessError) as e:
+                    console.print(f"ERROR: Error installing {package}: {e}")
+            
+            if success_count == len(missing_packages):
+                console.print("SUCCESS: All packages installed successfully!")
+                return True
+            else:
+                console.print(f"WARNING: {success_count}/{len(missing_packages)} packages installed")
+                return False
+        else:
+            console.print("INFO: Continuing with available languages only")
+            return False
+    
+    def show_language_status(self, language_availability: Dict[str, Dict[str, Any]]) -> None:
+        """Display language support status."""
+        console.print("Language Support Status:")
+        
+        if not language_availability:
+            console.print("  No supported languages detected in repository")
+            return
+        
+        missing_packages = []
+        
+        for lang, info in language_availability.items():
+            has_files = info["has_files"]
+            parser_available = info["parser_available"] 
+            file_count = info.get("file_count", 0)
+            
+            if has_files:
+                if parser_available:
+                    console.print(f"  SUPPORTED: {lang}: {file_count} files (parser available)")
+                else:
+                    console.print(f"  NOT_SUPPORTED: {lang}: {file_count} files (parser missing)")
+                    missing_packages.append(info["package_name"])
+        
+        if missing_packages:
+            console.print(f"\nTIP: To enable full support: pip install {' '.join(missing_packages)}")
+            return missing_packages
+        else:
+            console.print("\nSUCCESS: All detected languages have parser support!")
+            return []
+
+
+# Global config manager instance
+config_manager = ConfigManager()
+
+# Convenience functions
+def get_language_config(language: str) -> Optional[LanguageConfig]:
+    """Get language configuration."""
+    return config_manager.get_language_config(language)
+
+def detect_language(file_path: Path) -> Optional[str]:
+    """Detect language from file path."""
+    return config_manager.detect_language_from_extension(file_path)
+
+def detect_available_languages(repo_path: Path) -> Dict[str, Dict[str, Any]]:
+    """Detect available languages in repository."""
+    return config_manager.detect_available_languages(repo_path)
+
+def show_language_status_and_install(repo_path: Path) -> Dict[str, Dict[str, Any]]:
+    """Show language status and offer to install missing packages."""
+    availability = config_manager.detect_available_languages(repo_path)
+    missing_packages = config_manager.show_language_status(availability)
+    
+    if missing_packages:
+        config_manager.install_missing_packages(missing_packages)
+        # Re-check availability after installation
+        availability = config_manager.detect_available_languages(repo_path)
+    
+    return availability