skylos 1.2.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

skylos/cli.py

@@ -2,9 +2,14 @@ import argparse
 import json
 import sys
 import logging
-import ast
-import skylos
-from skylos.analyzer import parse_exclude_folders, DEFAULT_EXCLUDE_FOLDERS
+from skylos.constants import parse_exclude_folders, DEFAULT_EXCLUDE_FOLDERS
+from skylos.server import start_server
+from skylos.analyzer import analyze as run_analyze
+from skylos.codemods import (
+    remove_unused_import_cst,
+    remove_unused_function_cst,
+)
+import pathlib
 
 try:
     import inquirer
@@ -19,14 +24,11 @@ class Colors:
     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 CleanFormatter(logging.Formatter):
-    """Custom formatter that removes timestamps and log levels for clean output"""
     def format(self, record):
         return record.getMessage()
 
@@ -52,84 +54,28 @@ def setup_logger(output_file=None):
     
     return logger
 
-def remove_unused_import(file_path: str, import_name: str, line_number: int) -> bool:
+def remove_unused_import(file_path, import_name, line_number):
+    path = pathlib.Path(file_path)
     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)
-        
+        src = path.read_text(encoding="utf-8")
+        new_code, changed = remove_unused_import_cst(src, import_name, line_number)
+        if not changed:
+            return False
+        path.write_text(new_code, encoding="utf-8")
         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:
-    # remove the entire def from the source code
+def remove_unused_function(file_path, function_name, line_number):
+    path = pathlib.Path(file_path)
     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
+        src = path.read_text(encoding="utf-8")
+        new_code, changed = remove_unused_function_cst(src, function_name, line_number)
+        if not changed:
+            return False
+        path.write_text(new_code, encoding="utf-8")
+        return True
     except Exception as e:
         logging.error(f"Failed to remove function {function_name} from {file_path}: {e}")
         return False
@@ -143,9 +89,10 @@ def interactive_selection(logger, unused_functions, unused_imports):
     selected_imports = []
     
     if unused_functions:
-        logger.info(f"\n{Colors.CYAN}{Colors.BOLD}Select unused functions to remove:{Colors.RESET}")
+        logger.info(f"\n{Colors.CYAN}{Colors.BOLD}Select unused functions to remove (hit spacebar to select):{Colors.RESET}")
         
         function_choices = []
+
         for item in unused_functions:
             choice_text = f"{item['name']} ({item['file']}:{item['line']})"
             function_choices.append((choice_text, item))
@@ -162,9 +109,10 @@ def interactive_selection(logger, unused_functions, unused_imports):
             selected_functions = answers['functions']
     
     if unused_imports:
-        logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}Select unused imports to remove:{Colors.RESET}")
+        logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}Select unused imports to remove (hit spacebar to select):{Colors.RESET}")
         
         import_choices = []
+
         for item in unused_imports:
             choice_text = f"{item['name']} ({item['file']}:{item['line']})"
             import_choices.append((choice_text, item))
@@ -183,11 +131,10 @@ def interactive_selection(logger, unused_functions, unused_imports):
     return selected_functions, selected_imports
 
 def print_badge(dead_code_count: int, logger):
-    """Print appropriate badge based on dead code count"""
     logger.info(f"\n{Colors.GRAY}{'─' * 50}{Colors.RESET}")
     
     if dead_code_count == 0:
-        logger.info(f"✨ Your code is 100% dead code free! Add this badge to your README:")
+        logger.info(f" 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("```")
@@ -198,25 +145,34 @@ def print_badge(dead_code_count: int, logger):
         logger.info("```")
 
 def main() -> None:
+    if len(sys.argv) > 1 and sys.argv[1] == 'run':
+        try:
+            start_server()
+            return
+        except ImportError:
+            print(f"{Colors.RED}Error: Flask is required {Colors.RESET}")
+            print(f"{Colors.YELLOW}Install with: pip install flask flask-cors{Colors.RESET}")
+            sys.exit(1)
+
     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("path", help="Path to the Python project")
     parser.add_argument(
         "--json",
         action="store_true",
-        help="Output raw JSON instead of formatted text",
+        help="Output raw JSON",
     )
     parser.add_argument(
         "--output",
         "-o",
         type=str,
-        help="Write output to file instead of stdout",
+        help="Write output to file",
     )
     parser.add_argument(
         "--verbose", "-v",
         action="store_true",
-        help="Enable verbose output"
+        help="Enable verbose"
     )
     parser.add_argument(
         "--confidence",
@@ -228,12 +184,12 @@ def main() -> None:
     parser.add_argument(
         "--interactive", "-i",
         action="store_true",
-        help="Interactively select items to remove (requires inquirer)"
+        help="Select items to remove"
     )
     parser.add_argument(
         "--dry-run",
         action="store_true",
-        help="Show what would be removed without actually modifying files"
+        help="Show what would be removed"
     )
     
     parser.add_argument(
@@ -251,14 +207,14 @@ def main() -> None:
         dest="include_folders",
         help="Force include a folder that would otherwise be excluded "
              "(overrides both default and custom exclusions). "
-             "Example: --include-folder venv to scan your venv folder."
+             "Example: --include-folder venv"
     )
     
     parser.add_argument(
         "--no-default-excludes",
         action="store_true",
         help="Don't exclude default folders (__pycache__, .git, venv, etc.). "
-             "Only exclude folders specified with --exclude-folder."
+             "Only exclude folders with --exclude-folder."
     )
     
     parser.add_argument(
@@ -283,6 +239,7 @@ def main() -> None:
     if args.verbose:
         logger.setLevel(logging.DEBUG)
         logger.debug(f"Analyzing path: {args.path}")
+        
         if args.exclude_folders:
             logger.debug(f"Excluding folders: {args.exclude_folders}")
 
@@ -300,7 +257,7 @@ def main() -> None:
             logger.info(f"{Colors.GREEN}📁 No folders excluded{Colors.RESET}")
 
     try:
-        result_json = skylos.analyze(args.path, conf=args.confidence, exclude_folders=list(final_exclude_folders))
+        result_json = run_analyze(args.path, conf=args.confidence, exclude_folders=list(final_exclude_folders))
         result = json.loads(result_json)
 
     except Exception as e:
@@ -317,15 +274,15 @@ def main() -> None:
     unused_variables = result.get("unused_variables", [])
     unused_classes = result.get("unused_classes", [])
     
-    logger.info(f"{Colors.CYAN}{Colors.BOLD}🔍 Python Static Analysis Results{Colors.RESET}")
+    logger.info(f"{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}")
-    logger.info(f"  • Unused parameters: {Colors.YELLOW}{len(unused_parameters)}{Colors.RESET}")
-    logger.info(f"  • Unused variables: {Colors.YELLOW}{len(unused_variables)}{Colors.RESET}")
-    logger.info(f"  • Unused classes: {Colors.YELLOW}{len(unused_classes)}{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}")
+    logger.info(f" * Unused parameters: {Colors.YELLOW}{len(unused_parameters)}{Colors.RESET}")
+    logger.info(f" * Unused variables: {Colors.YELLOW}{len(unused_variables)}{Colors.RESET}")
+    logger.info(f" * Unused classes: {Colors.YELLOW}{len(unused_classes)}{Colors.RESET}")
 
     if args.interactive and (unused_functions or unused_imports):
         logger.info(f"\n{Colors.BOLD}Interactive Mode:{Colors.RESET}")
@@ -358,16 +315,16 @@ def main() -> None:
                     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']}")
+                            logger.info(f"  {Colors.GREEN} {Colors.RESET} Removed function: {func['name']}")
                         else:
-                            logger.error(f"  {Colors.RED}✗{Colors.RESET} Failed to remove: {func['name']}")
+                            logger.error(f"  {Colors.RED} x {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']}")
+                            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.error(f"  {Colors.RED} x {Colors.RESET} Failed to remove: {imp['name']}")
                     
                     logger.info(f"\n{Colors.GREEN}Cleanup complete!{Colors.RESET}")
                 else:
@@ -379,16 +336,16 @@ def main() -> None:
     
     else:
         if unused_functions:
-            logger.info(f"\n{Colors.RED}{Colors.BOLD}📦 Unreachable Functions{Colors.RESET}")
+            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}")
+            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"\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}")
@@ -397,7 +354,7 @@ def main() -> None:
             logger.info(f"\n{Colors.GREEN}✓ All imports are being used!{Colors.RESET}")
         
         if unused_parameters:
-            logger.info(f"\n{Colors.BLUE}{Colors.BOLD}🔧 Unused Parameters{Colors.RESET}")
+            logger.info(f"\n{Colors.BLUE}{Colors.BOLD} - Unused Parameters{Colors.RESET}")
             logger.info(f"{Colors.BLUE}{'=' * 18}{Colors.RESET}")
             for i, item in enumerate(unused_parameters, 1):
                 logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.BLUE}{item['name']}{Colors.RESET}")
@@ -406,14 +363,14 @@ def main() -> None:
             logger.info(f"\n{Colors.GREEN}✓ All parameters are being used!{Colors.RESET}")
         
         if unused_variables:
-            logger.info(f"\n{Colors.YELLOW}{Colors.BOLD}📊 Unused Variables{Colors.RESET}")
+            logger.info(f"\n{Colors.YELLOW}{Colors.BOLD} - Unused Variables{Colors.RESET}")
             logger.info(f"{Colors.YELLOW}{'=' * 18}{Colors.RESET}")
             for i, item in enumerate(unused_variables, 1):
                 logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.YELLOW}{item['name']}{Colors.RESET}")
                 logger.info(f"    {Colors.GRAY}└─ {item['file']}:{item['line']}{Colors.RESET}")
                 
         if unused_classes:
-            logger.info(f"\n{Colors.YELLOW}{Colors.BOLD}📚 Unused Classes{Colors.RESET}")
+            logger.info(f"\n{Colors.YELLOW}{Colors.BOLD} - Unused Classes{Colors.RESET}")
             logger.info(f"{Colors.YELLOW}{'=' * 18}{Colors.RESET}")
             for i, item in enumerate(unused_classes, 1):
                 logger.info(f"{Colors.GRAY}{i:2d}. {Colors.RESET}{Colors.YELLOW}{item['name']}{Colors.RESET}")
@@ -428,9 +385,9 @@ def main() -> None:
 
         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")
-            logger.info(f" • Use --exclude-folder to skip directories like node_modules, .git")
+            logger.info(f" * Use --select specific items to remove")
+            logger.info(f" * Use --dry-run to preview changes")
+            logger.info(f" * Use --exclude-folder to skip directories")
 
 if __name__ == "__main__":
     main()

skylos/codemods.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+import libcst as cst
+from libcst.metadata import PositionProvider
+
+def _bound_name_for_import_alias(alias: cst.ImportAlias):
+    if alias.asname:
+        return alias.asname.name.value
+    node = alias.name
+    while isinstance(node, cst.Attribute):
+        node = node.value
+    return node.value 
+
+class _RemoveImportAtLine(cst.CSTTransformer):
+    METADATA_DEPENDENCIES = (PositionProvider,)
+
+    def __init__(self, target_name, target_line):
+        self.target_name = target_name
+        self.target_line = target_line
+        self.changed = False
+
+    def _is_target_line(self, node: cst.CSTNode):
+        pos = self.get_metadata(PositionProvider, node, None)
+        return bool(pos and pos.start.line == self.target_line)
+
+    def _filter_aliases(self, aliases):
+        kept = []
+        for alias in aliases:
+            bound = _bound_name_for_import_alias(alias)
+            if bound == self.target_name:
+                self.changed = True
+                continue
+            kept.append(alias)
+        return kept
+
+    def leave_Import(self, orig: cst.Import, updated: cst.Import):
+        if not self._is_target_line(orig):
+            return updated
+        kept = self._filter_aliases(updated.names)
+        if not kept:
+            return cst.RemoveFromParent()
+        return updated.with_changes(names=tuple(kept))
+
+    def leave_ImportFrom(self, orig: cst.ImportFrom, updated: cst.ImportFrom):
+        if not self._is_target_line(orig):
+            return updated
+        if isinstance(updated.names, cst.ImportStar):
+            return updated 
+        kept = self._filter_aliases(list(updated.names))
+        if not kept:
+            return cst.RemoveFromParent()
+
+        return updated.with_changes(names=tuple(kept))
+
+class _RemoveFunctionAtLine(cst.CSTTransformer):
+    METADATA_DEPENDENCIES = (PositionProvider,)
+
+    def __init__(self, func_name, target_line):
+        self.func_name = func_name
+        self.target_line = target_line
+        self.changed = False
+
+    def _is_target(self, node: cst.CSTNode):
+        pos = self.get_metadata(PositionProvider, node, None)
+        return bool(pos and pos.start.line == self.target_line)
+
+    def leave_FunctionDef(self, orig: cst.FunctionDef, updated: cst.FunctionDef):
+        if self._is_target(orig) and (orig.name.value in self.func_name):
+            self.changed = True
+            return cst.RemoveFromParent()
+        return updated
+
+    def leave_AsyncFunctionDef(self, orig: cst.AsyncFunctionDef, updated: cst.AsyncFunctionDef):
+        if self._is_target(orig) and (orig.name.value in self.func_name):
+            self.changed = True
+            return cst.RemoveFromParent()
+
+        return updated
+
+def remove_unused_import_cst(code, import_name, line_number):
+    wrapper = cst.MetadataWrapper(cst.parse_module(code))
+    tx = _RemoveImportAtLine(import_name, line_number)
+    new_mod = wrapper.visit(tx)
+    return new_mod.code, tx.changed
+
+def remove_unused_function_cst(code, func_name, line_number):
+    wrapper = cst.MetadataWrapper(cst.parse_module(code))
+    tx = _RemoveFunctionAtLine(func_name, line_number)
+    new_mod = wrapper.visit(tx)
+    return new_mod.code, tx.changed

skylos/constants.py

@@ -2,18 +2,18 @@ import re
 from pathlib import Path
 
 PENALTIES = {
-    "private_name":       80,   
-    "dunder_or_magic":    100, 
-    "underscored_var":    100, 
-    "in_init_file":       15, 
-    "dynamic_module":     40,
-    "test_related":       100,
-     "framework_magic":    40,
+    "private_name": 80,   
+    "dunder_or_magic": 100, 
+    "underscored_var": 100, 
+    "in_init_file": 15, 
+    "dynamic_module": 40,
+    "test_related": 100,
+    "framework_magic": 40,
 }
 
-TEST_FILE_RE   = re.compile(r"(?:^|[/\\])tests?[/\\]|_test\.py$", re.I)
+TEST_FILE_RE = re.compile(r"(?:^|[/\\])tests?[/\\]|_test\.py$", re.I)
 TEST_IMPORT_RE = re.compile(r"^(pytest|unittest|nose|mock|responses)(\.|$)")
-TEST_DECOR_RE  = re.compile(r"""^(
+TEST_DECOR_RE = re.compile(r"""^(
     pytest\.(fixture|mark) |
     patch(\.|$) |
     responses\.activate |
@@ -39,4 +39,19 @@ def is_test_path(p: Path | str) -> bool:
     return bool(TEST_FILE_RE.search(str(p)))
 
 def is_framework_path(p: Path | str) -> bool:
-    return bool(FRAMEWORK_FILE_RE.search(str(p)))
+    return bool(FRAMEWORK_FILE_RE.search(str(p)))
+
+def parse_exclude_folders(user_exclude_folders= None, use_defaults= True, include_folders= None):
+    exclude_folders = set()
+    
+    if use_defaults:
+        exclude_folders.update(DEFAULT_EXCLUDE_FOLDERS)
+    
+    if user_exclude_folders:
+        exclude_folders.update(user_exclude_folders)
+    
+    if include_folders:
+        for folder in include_folders:
+            exclude_folders.discard(folder)
+    
+    return exclude_folders