skylos 0.0.5__cp39-cp39-win_amd64.whl

skylos/__init__.py

@@ -0,0 +1,30 @@
+from importlib import metadata as _md
+
+try:
+    __version__ = _md.version(__name__)
+except _md.PackageNotFoundError:
+    __version__ = "0.0.0.dev0"
+
+
+from ._core import analyze as _analyze 
+
+def analyze(path: str) -> str:
+    """Return the JSON produced by Rust's ``analyze``."""
+    return _analyze(path)
+
+# ------------------------------------------------------------------ #
+# helpers the tests expect
+# ------------------------------------------------------------------ #
+def debug_test() -> str:
+    return "debug-ok"
+
+__all__ = ["analyze", "debug_test", "__version__"]
+
+def _patch_metadata() -> None:
+    orig_version = _md.version
+    def _fake_version(name: str):                # type: ignore
+        if name == __name__:
+            return __version__
+        return orig_version(name)
+    _md.version = _fake_version
+_patch_metadata()

skylos/cli.py

@@ -0,0 +1,332 @@
+import argparse
+import json
+import sys
+import logging
+import ast
+import skylos
+
+try:
+    import inquirer
+    INTERACTIVE_AVAILABLE = True
+except ImportError:
+    INTERACTIVE_AVAILABLE = False
+
+class Colors:
+    RED = '\033[91m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    BLUE = '\033[94m'
+    MAGENTA = '\033[95m'
+    CYAN = '\033[96m'
+    WHITE = '\033[97m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+    RESET = '\033[0m'
+    GRAY = '\033[90m'
+
+class ColoredFormatter(logging.Formatter):
+    def format(self, record):
+        return super().format(record)
+
+def setup_logger(output_file=None):
+    logger = logging.getLogger('skylos')
+    logger.setLevel(logging.INFO)
+    
+    logger.handlers.clear()
+    
+    formatter = ColoredFormatter('%(message)s')
+    
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    if output_file:
+        file_handler = logging.FileHandler(output_file)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+def remove_unused_import(file_path: str, import_name: str, line_number: int) -> bool:
+    try:
+        with open(file_path, 'r') as f:
+            lines = f.readlines()
+        
+        line_idx = line_number - 1
+        original_line = lines[line_idx].strip()
+        
+        if original_line.startswith(f'import {import_name}'):
+            lines[line_idx] = ''
+        elif original_line.startswith('import ') and f' {import_name}' in original_line:
+            parts = original_line.split(' ', 1)[1].split(',')
+            new_parts = [p.strip() for p in parts if p.strip() != import_name]
+            if new_parts:
+                lines[line_idx] = f'import {", ".join(new_parts)}\n'
+            else:
+                lines[line_idx] = ''
+        elif original_line.startswith('from ') and import_name in original_line:
+            if f'import {import_name}' in original_line and ',' not in original_line:
+                lines[line_idx] = ''
+            else:
+                parts = original_line.split('import ', 1)[1].split(',')
+                new_parts = [p.strip() for p in parts if p.strip() != import_name]
+                if new_parts:
+                    prefix = original_line.split(' import ')[0]
+                    lines[line_idx] = f'{prefix} import {", ".join(new_parts)}\n'
+                else:
+                    lines[line_idx] = ''
+        
+        with open(file_path, 'w') as f:
+            f.writelines(lines)
+        
+        return True
+    except Exception as e:
+        logging.error(f"Failed to remove import {import_name} from {file_path}: {e}")
+        return False
+
+def remove_unused_function(file_path: str, function_name: str, line_number: int) -> bool:
+    try:
+        with open(file_path, 'r') as f:
+            content = f.read()
+        
+        tree = ast.parse(content)
+        
+        lines = content.splitlines()
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                if (node.name in function_name and 
+                    node.lineno == line_number):
+                    
+                    start_line = node.lineno - 1
+                    
+                    if node.decorator_list:
+                        start_line = node.decorator_list[0].lineno - 1
+                    
+                    end_line = len(lines)
+                    base_indent = len(lines[start_line]) - len(lines[start_line].lstrip())
+                    
+                    for i in range(node.end_lineno, len(lines)):
+                        if lines[i].strip() == '':
+                            continue
+                        current_indent = len(lines[i]) - len(lines[i].lstrip())
+                        if current_indent <= base_indent and lines[i].strip():
+                            end_line = i
+                            break
+                    
+                    while end_line < len(lines) and lines[end_line].strip() == '':
+                        end_line += 1
+                    
+                    new_lines = lines[:start_line] + lines[end_line:]
+                    
+                    with open(file_path, 'w') as f:
+                        f.write('\n'.join(new_lines) + '\n')
+                    
+                    return True
+        
+        return False
+    except Exception as e:
+        logging.error(f"Failed to remove function {function_name} from {file_path}: {e}")
+        return False
+
+def interactive_selection(logger, unused_functions, unused_imports):
+    if not INTERACTIVE_AVAILABLE:
+        logger.error("Interactive mode requires 'inquirer' package. Install with: pip install inquirer")
+        return [], []
+    
+    selected_functions = []
+    selected_imports = []
+    
+    if unused_functions:
+        logger.info(f"\n{Colors.CYAN}{Colors.BOLD}Select unused functions to remove:{Colors.RESET}")
+        
+        function_choices = []
+        for item in unused_functions:
+            choice_text = f"{item['name']} ({item['file']}:{item['line']})"
+            function_choices.append((choice_text, item))
+        
+        questions = [
+            inquirer.Checkbox('functions',
+                            message="Select functions to remove",
+                            choices=function_choices,
+                            )
+        ]
+        
+        answers = inquirer.prompt(questions)
+        if answers:
+            selected_functions = answers['functions']
+    
+    if unused_imports:
+        logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}Select unused imports to remove:{Colors.RESET}")
+        
+        import_choices = []
+        for item in unused_imports:
+            choice_text = f"{item['name']} ({item['file']}:{item['line']})"
+            import_choices.append((choice_text, item))
+        
+        questions = [
+            inquirer.Checkbox('imports',
+                            message="Select imports to remove",
+                            choices=import_choices,
+                            )
+        ]
+        
+        answers = inquirer.prompt(questions)
+        if answers:
+            selected_imports = answers['imports']
+    
+    return selected_functions, selected_imports
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Detect unreachable functions and unused imports in a Python project"
+    )
+    parser.add_argument("path", help="Path to the Python project to analyze")
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output raw JSON instead of formatted text",
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        help="Write output to file instead of stdout",
+    )
+    parser.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        help="Enable verbose output"
+    )
+    parser.add_argument(
+        "--interactive", "-i",
+        action="store_true",
+        help="Interactively select items to remove (requires inquirer)"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be removed without actually modifying files"
+    )
+
+    args = parser.parse_args()
+    logger = setup_logger(args.output)
+    
+    if args.verbose:
+        logger.setLevel(logging.DEBUG)
+        logger.debug(f"Analyzing path: {args.path}")
+
+    try:
+        result_json = skylos.analyze(args.path)
+        result = json.loads(result_json)
+    except Exception as e:
+        logger.error(f"Error during analysis: {e}")
+        sys.exit(1)
+
+    if args.json:
+        logger.info(result_json)
+    else:
+        unused_functions = result.get("unused_functions", [])
+        unused_imports = result.get("unused_imports", [])
+        
+        logger.info(f"\n{Colors.CYAN}{Colors.BOLD}🔍 Python Static Analysis Results{Colors.RESET}")
+        logger.info(f"{Colors.CYAN}{'=' * 35}{Colors.RESET}")
+        
+        logger.info(f"\n{Colors.BOLD}Summary:{Colors.RESET}")
+        logger.info(f"  • Unreachable functions: {Colors.YELLOW}{len(unused_functions)}{Colors.RESET}")
+        logger.info(f"  • Unused imports: {Colors.YELLOW}{len(unused_imports)}{Colors.RESET}")
+        
+        if args.interactive and (unused_functions or unused_imports):
+            logger.info(f"\n{Colors.BOLD}Interactive Mode:{Colors.RESET}")
+            selected_functions, selected_imports = interactive_selection(logger, unused_functions, unused_imports)
+            
+            if selected_functions or selected_imports:
+                logger.info(f"\n{Colors.BOLD}Selected items to remove:{Colors.RESET}")
+                
+                if selected_functions:
+                    logger.info(f"  Functions: {len(selected_functions)}")
+                    for func in selected_functions:
+                        logger.info(f"    - {func['name']} ({func['file']}:{func['line']})")
+                
+                if selected_imports:
+                    logger.info(f"  Imports: {len(selected_imports)}")
+                    for imp in selected_imports:
+                        logger.info(f"    - {imp['name']} ({imp['file']}:{imp['line']})")
+                
+                if not args.dry_run:
+                    questions = [
+                        inquirer.Confirm('confirm',
+                                       message="Are you sure you want to remove these items?",
+                                       default=False)
+                    ]
+                    answers = inquirer.prompt(questions)
+                    
+                    if answers and answers['confirm']:
+                        logger.info(f"\n{Colors.YELLOW}Removing selected items...{Colors.RESET}")
+                        
+                        for func in selected_functions:
+                            success = remove_unused_function(func['file'], func['name'], func['line'])
+                            if success:
+                                logger.info(f"  {Colors.GREEN}✓{Colors.RESET} Removed function: {func['name']}")
+                            else:
+                                logger.error(f"  {Colors.RED}✗{Colors.RESET} Failed to remove: {func['name']}")
+                        
+                        for imp in selected_imports:
+                            success = remove_unused_import(imp['file'], imp['name'], imp['line'])
+                            if success:
+                                logger.info(f"  {Colors.GREEN}✓{Colors.RESET} Removed import: {imp['name']}")
+                            else:
+                                logger.error(f"  {Colors.RED}✗{Colors.RESET} Failed to remove: {imp['name']}")
+                        
+                        logger.info(f"\n{Colors.GREEN}Cleanup complete!{Colors.RESET}")
+                    else:
+                        logger.info(f"\n{Colors.YELLOW}Operation cancelled.{Colors.RESET}")
+                else:
+                    logger.info(f"\n{Colors.YELLOW}Dry run - no files were modified.{Colors.RESET}")
+            else:
+                logger.info(f"\n{Colors.BLUE}No items selected.{Colors.RESET}")
+        
+        else:
+            if unused_functions:
+                logger.info(f"\n{Colors.RED}{Colors.BOLD}📦 Unreachable Functions{Colors.RESET}")
+                logger.info(f"{Colors.RED}{'=' * 23}{Colors.RESET}")
+                for i, item in enumerate(unused_functions, 1):
+                    logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.RED}{item['name']}{Colors.RESET}")
+                    logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
+            else:
+                logger.info(f"\n{Colors.GREEN}✓ All functions are reachable!{Colors.RESET}")
+            
+            if unused_imports:
+                logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}📥 Unused Imports{Colors.RESET}")
+                logger.info(f"{Colors.MAGENTA}{'=' * 16}{Colors.RESET}")
+                for i, item in enumerate(unused_imports, 1):
+                    logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.MAGENTA}{item['name']}{Colors.RESET}")
+                    logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
+            else:
+                logger.info(f"\n{Colors.GREEN}✓ All imports are being used!{Colors.RESET}")
+            
+            logger.info(f"\n{Colors.GRAY}{'─' * 50}{Colors.RESET}")
+            logger.info(f"{Colors.GRAY}Analysis complete.{Colors.RESET}")
+
+            logger.info(f"\n{Colors.GRAY}{'─' * 50}{Colors.RESET}")
+            logger.info(f"{Colors.GRAY}Analysis complete.{Colors.RESET}")
+
+            dead_code_count = len(unused_functions) + len(unused_imports)
+
+            if dead_code_count == 0:
+                logger.info(f"\n✨ Your code is 100% dead code free! Add this badge to your README:")
+                logger.info("```markdown")
+                logger.info("![Dead Code Free](https://img.shields.io/badge/Dead_Code-Free-brightgreen?logo=moleculer&logoColor=white)")
+                logger.info("```")
+            else:
+                logger.info(f"Found {dead_code_count} dead code items. Add this badge to your README:")
+                logger.info("```markdown")  
+                logger.info(f"![Dead Code: {dead_code_count}](https://img.shields.io/badge/Dead_Code-{dead_code_count}_detected-orange?logo=codacy&logoColor=red)")
+                logger.info("```")
+
+            if unused_functions or unused_imports:
+                logger.info(f"\n{Colors.BOLD}Next steps:{Colors.RESET}")
+                logger.info(f"  • Use --interactive to select specific items to remove")
+                logger.info(f"  • Use --dry-run to preview changes before applying them")
+
+if __name__ == "__main__":
+    main()

skylos-0.0.5.dist-info/METADATA

@@ -0,0 +1,306 @@
+Metadata-Version: 2.4
+Name: skylos
+Version: 0.0.5
+Requires-Dist: inquirer>=3.0.0
+Summary: A static analysis tool for Python codebases
+Author-email: oha <aaronoh2015@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# Skylos 🔍
+
+![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)
+![100% Local](https://img.shields.io/badge/privacy-100%25%20local-brightgreen)
+![PyPI version](https://img.shields.io/pypi/v/tacz)
+![100% Dead Code Free](https://img.shields.io/badge/Dead%20Code-100%25%20Free-brightgreen)
+
+<div align="center">
+   <img src="assets/SKYLOS.png" alt="Skylos Logo" width="200">
+</div>
+
+> A static analysis tool for Python codebases written in Rust that detects unreachable functions and unused imports, aka dead code. 
+
+## Features
+
+- **Unreachable Function Detection**: Find functions and methods that are never called aka dead code
+- **Unused Import Detection**: Imports that are never used
+- **High Performance**: Built with Rust
+- **Nice Output**: Colorized CLI output
+- **Interactive Mode**: Select and remove specific items interactively
+- **Dry Run Support**: Preview changes before applying them
+- **Auto-removal**: Auto clean up
+- **Cross-module Analysis**: Tracks imports and calls across your entire project
+- **Nice badges!!**: Pin your badge if you get 100% clean code! 
+
+## Benchmark (You can find this benchmark test in `test/sample_project`)
+
+| Tool | Time (s) | Functions | Imports | Total |
+|------|----------|-----------|---------|-------|
+| Skylos | 0.039 | 48 | 8 | 56 |
+| Vulture (100%) | 0.040 | 0 | 3 | 3 |
+| Vulture (60%) | 0.041 | 28 | 3 | 31 |
+| Vulture (0%) | 0.041 | 28 | 3 | 31 |
+| Flake8 | 0.274 | 0 | 8 | 8 |
+| Pylint | 0.285 | 0 | 6 | 6 |
+| Dead | 0.035 | 0 | 0 | 0 |
+
+## Installation
+
+### Basic Installation
+
+```bash
+pip install skylos
+```
+
+### With Interactive Features
+
+For the interactive selection mode, install with:
+
+```bash
+pip install skylos[interactive]
+```
+
+### From Source
+
+```bash
+# Clone the repository
+git clone https://github.com/duriantaco/skylos.git
+cd skylos
+
+# Install maturin (if not already installed)
+pip install maturin
+
+# Build and install
+maturin develop
+```
+
+## Quick Start
+
+```bash
+# Analyze a project
+skylos /path/to/your/project
+
+# Interactive mode - select items to remove
+skylos /path/to/your/project --interactive
+
+# Dry run - see what would be removed
+skylos /path/to/your/project --interactive --dry-run
+
+# Output to JSON
+skylos /path/to/your/project --json
+```
+
+## CLI Options
+
+```
+Usage: skylos [OPTIONS] PATH
+
+Arguments:
+  PATH  Path to the Python project to analyze
+
+Options:
+  -h, --help              Show this help message and exit
+  -j, --json             Output raw JSON instead of formatted text
+  -o, --output FILE      Write output to file instead of stdout
+  -v, --verbose          Enable verbose output
+  -i, --interactive      Interactively select items to remove
+  --dry-run              Show what would be removed without modifying files
+```
+
+## Example Output
+
+```
+🔍 Python Static Analysis Results
+===================================
+
+Summary:
+  • Unreachable functions: 48
+  • Unused imports: 8
+
+📦 Unreachable Functions
+========================
+ 1. module_13.test_function
+    └─ /Users/oha/project/module_13.py:5
+ 2. module_13.unused_function
+    └─ /Users/oha/project/module_13.py:13
+...
+
+📥 Unused Imports
+=================
+ 1. os
+    └─ /Users/oha/project/module_13.py:1
+ 2. json
+    └─ /Users/oha/project/module_13.py:3
+...
+
+Next steps:
+  • Use --interactive to select specific items to remove
+  • Use --dry-run to preview changes before applying them
+```
+
+## Interactive Mode
+
+The interactive mode lets you select specific functions and imports to remove:
+
+![Interactive Demo](docs/interactive-demo.gif)
+
+1. **Select items**: Use arrow keys and space to select/deselect
+2. **Confirm changes**: Review selected items before applying
+3. **Auto-cleanup**: Files are automatically updated
+
+## Architecture
+
+Skylos uses a hybrid architecture combining Rust and Python:
+
+- **Rust Core**: Fast tree-sitter based parsing and analysis
+- **Python CLI**: User-friendly interface and file manipulation
+- **maturin**: Seamless Python-Rust integration
+
+### Core Components
+
+```
+skylos/
+├── src/lib.rs          # Main Rust analysis engine
+├── src/queries.rs      # Tree-sitter query definitions
+├── src/types.rs       # Data structures for results
+├── src/utils.rs       # Helper functions
+├── skylos/
+│   └── cli.py         # Python CLI interface
+└── pyproject.toml     # Project configuration
+```
+
+## Development
+
+### Prerequisites
+
+- Python ≥3.8
+- Rust and Cargo
+- maturin
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/duriantaco/skylos.git
+cd skylos
+
+# Create a virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install development dependencies
+pip install maturin inquirer pytest
+
+# Build in development mode
+maturin develop
+```
+
+### Running Tests
+
+```bash
+# Run Rust tests
+cd src
+cargo test
+
+# Run Python tests
+python -m pytest tests/
+```
+
+### Adding New Features
+
+1. **Rust Analysis**: Add new queries in `src/queries.rs`
+2. **Python CLI**: Extend functionality in `skylos/cli.py`
+3. **Documentation**: Update this README and add docstrings
+
+## Configuration
+
+Skylos supports configuration via `.skylos.toml` (coming soon):
+
+```toml
+[analysis]
+# Exclude patterns
+exclude = [
+    "*/migrations/*",
+    "*/tests/*",
+    "__pycache__"
+]
+
+# Custom patterns for dead code detection
+patterns = [
+    "test_*",      # Test functions
+    "_*_internal"  # Internal functions
+]
+
+[output]
+# Default output format
+format = "colored"  # Options: colored, plain, json
+
+# Color scheme
+colors = "default"  # Options: default, dark, light
+```
+
+## Limitations 
+
+- Occassionally there will be false positives and false negatives especially for extreme edge cases 
+
+- The library is currently available **ONLY** for python
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Tree-sitter Errors**
+   ```
+   Error: tree-sitter parse failed
+   ```
+   Ensure your Python files have valid syntax.
+
+2. **Permission Errors**
+   ```
+   Error: Permission denied when removing function
+   ```
+   Check file permissions before running in interactive mode.
+
+3. **Missing Dependencies**
+   ```
+   Interactive mode requires 'inquirer' package
+   ```
+   Install with: `pip install skylos[interactive]`
+
+## Contributing
+
+We welcome contributions! Please read our [Contributing Guidelines](CONTRIBUTING.md) before submitting pull requests.
+
+### Quick Contribution Guide
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Roadmap
+
+- [ ] Configuration file support (White lists etc)
+- [ ] Custom analysis rules
+- [ ] Git hooks integration
+- [ ] CI/CD integration examples
+- [ ] Web interface
+- [ ] Support for other languages
+- [ ] Further optimization
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- [tree-sitter](https://tree-sitter.github.io/) for the powerful parsing framework
+- [maturin](https://github.com/PyO3/maturin) for seamless Rust-Python integration
+- [inquirer](https://github.com/magmax/python-inquirer) for the interactive CLI
+
+## Contact
+
+- **Author**: oha
+- **Email**: aaronoh2015@gmail.com
+- **GitHub**: [@duriantaco](https://github.com/duriantaco)

skylos-0.0.5.dist-info/RECORD

@@ -0,0 +1,7 @@
+skylos-0.0.5.dist-info/METADATA,sha256=VZs_urOw-5xWDP6rR4tLhpJQmogN8ynm59ORTTz8gZ8,7939
+skylos-0.0.5.dist-info/WHEEL,sha256=0kWP4A00z5y7dQaPOt93HDVSEu9o_Xh01gZkicHYRtk,94
+skylos-0.0.5.dist-info/entry_points.txt,sha256=0_aXKDSaSH1REotD0g5GU419ykfL-S5H0XFtmDwRHyU,41
+skylos/__init__.py,sha256=vFcb-Dn-GhTC-3XBytd4FV4U11BNQ-1S4RMvBjqfl3g,876
+skylos/_core.cp39-win_amd64.pyd,sha256=Yg6hQ7CKV9SPz1CJ28HgdZ-YpkIja3YfKpAaNEmzgLc,2816512
+skylos/cli.py,sha256=C1Nm6g1S2aHqUul9xZSqbq_dAPZHXQfomEn67pGHfvU,14152
+skylos-0.0.5.dist-info/RECORD,,

skylos-0.0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.6)
+Root-Is-Purelib: false
+Tag: cp39-cp39-win_amd64

skylos-0.0.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+skylos=skylos.cli:main