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

skylos/__init__.py

@@ -1,6 +1,6 @@
 from skylos.analyzer import analyze
 
-__version__ = "1.0.22"
+__version__ = "2.0.0"
 
 def debug_test():
     return "debug-ok"

skylos/analyzer.py

@@ -11,10 +11,6 @@ from skylos.test_aware import TestAwareVisitor
 import os
 import traceback
 from skylos.framework_aware import FrameworkAwareVisitor, detect_framework_usage
-import io
-import tokenize
-import re
-import warnings
 
 logging.basicConfig(level=logging.INFO,format='%(asctime)s - %(levelname)s - %(message)s')
 logger=logging.getLogger('Skylos')
@@ -34,33 +30,20 @@ def parse_exclude_folders(user_exclude_folders, use_defaults=True, include_folde
     
     return exclude_set
 
-IGNORE_PATTERNS = (
-    r"#\s*pragma:\s*no\s+skylos", ## our own pragma
-    r"#\s*pragma:\s*no\s+cover",
-    r"#\s*noqa(?:\b|:)", # flake8 style
-)
-
-def _collect_ignored_lines(source: str) -> set[int]:
-    ignores = set()
-    for tok in tokenize.generate_tokens(io.StringIO(source).readline):
-        if tok.type == tokenize.COMMENT:
-            if any(re.search(pat, tok.string, flags=re.I) for pat in IGNORE_PATTERNS):
-                ignores.add(tok.start[0])
-    return ignores
-
 class Skylos:
     def __init__(self):
         self.defs={}
         self.refs=[]
         self.dynamic=set()
         self.exports=defaultdict(set)
-        self.ignored_lines:set[int]=set()
 
     def _module(self,root,f):
-        p=list(f.relative_to(root).parts)
-        if p[-1].endswith(".py"):p[-1]=p[-1][:-3]
-        if p[-1]=="__init__":p.pop()
-        return".".join(p)
+        p = list(f.relative_to(root).parts)
+        if p[-1].endswith(".py"):
+            p[-1] = p[-1][:-3]
+        if p[-1] == "__init__":
+            p.pop()
+        return ".".join(p)
     
     def _should_exclude_file(self, file_path, root_path, exclude_folders):
         if not exclude_folders:
@@ -111,9 +94,9 @@ class Skylos:
         return all_files, root
     
     def _mark_exports(self):
-        for name, d in self.defs.items():
-            if d.in_init and not d.simple_name.startswith('_'):
-                d.is_exported = True
+        for name, definition in self.defs.items():
+            if definition.in_init and not definition.simple_name.startswith('_'):
+                definition.is_exported = True
         
         for mod, export_names in self.exports.items():
             for name in export_names:
@@ -137,8 +120,8 @@ class Skylos:
                         break
 
         simple_name_lookup = defaultdict(list)
-        for d in self.defs.values():
-            simple_name_lookup[d.simple_name].append(d)
+        for definition in self.defs.values():
+            simple_name_lookup[definition.simple_name].append(definition)
         
         for ref, _ in self.refs:
             if ref in self.defs:
@@ -151,8 +134,8 @@ class Skylos:
             
             simple = ref.split('.')[-1]
             matches = simple_name_lookup.get(simple, [])
-            for d in matches:
-                d.references += 1
+            for definition in matches:
+                definition.references += 1
  
         for module_name in self.dynamic:
             for def_name, def_obj in self.defs.items():
@@ -172,59 +155,58 @@ class Skylos:
         return []
     
     def _apply_penalties(self, def_obj, visitor, framework):
-        c = 100
-        
+        confidence=100
         if def_obj.simple_name.startswith("_") and not def_obj.simple_name.startswith("__"):
-            c -= PENALTIES["private_name"] 
+            confidence -= PENALTIES["private_name"] 
         if def_obj.simple_name.startswith("__") and def_obj.simple_name.endswith("__"):
-            c -= PENALTIES["dunder_or_magic"]
+            confidence -= PENALTIES["dunder_or_magic"]
         if def_obj.type == "variable" and def_obj.simple_name == "_":
-            c -= PENALTIES["underscored_var"]
+            confidence -= PENALTIES["underscored_var"]
         if def_obj.in_init and def_obj.type in ("function", "class"):
-            c -= PENALTIES["in_init_file"]
+            confidence -= PENALTIES["in_init_file"]
         if def_obj.name.split(".")[0] in self.dynamic:
-            c -= PENALTIES["dynamic_module"]
+            confidence -= PENALTIES["dynamic_module"]
         if visitor.is_test_file or def_obj.line in visitor.test_decorated_lines:
-            c -= PENALTIES["test_related"]
+            confidence -= PENALTIES["test_related"]
         
         framework_confidence = detect_framework_usage(def_obj, visitor=framework)
         if framework_confidence is not None:
-            c = min(c, framework_confidence)
+            confidence = min(confidence, framework_confidence)
 
         if (def_obj.simple_name.startswith("__") and def_obj.simple_name.endswith("__")):
-            c = 0
+            confidence = 0
 
         if def_obj.type == "parameter":
             if def_obj.simple_name in ("self", "cls"):
-                c = 0
+                confidence = 0
             elif "." in def_obj.name:
                 method_name = def_obj.name.split(".")[-2]
                 if method_name.startswith("__") and method_name.endswith("__"):
-                    c = 0
+                    confidence = 0
         
         if visitor.is_test_file or def_obj.line in visitor.test_decorated_lines:
-            c = 0
+            confidence = 0
         
         if (def_obj.type == "import" and def_obj.name.startswith("__future__.") and
             def_obj.simple_name in ("annotations", "absolute_import", "division", 
                                 "print_function", "unicode_literals", "generator_stop")):
-            c = 0
+            confidence = 0
         
-        def_obj.confidence = max(c, 0)
+        def_obj.confidence = max(confidence, 0)
 
     def _apply_heuristics(self):
         class_methods = defaultdict(list)
-        for d in self.defs.values():
-            if d.type in ("method", "function") and "." in d.name:
-                cls = d.name.rsplit(".", 1)[0]
+        for definition in self.defs.values():
+            if definition.type in ("method", "function") and "." in definition.name:
+                cls = definition.name.rsplit(".", 1)[0]
                 if cls in self.defs and self.defs[cls].type == "class":
-                    class_methods[cls].append(d)
+                    class_methods[cls].append(definition)
         
         for cls, methods in class_methods.items():
             if self.defs[cls].references > 0:
-                for m in methods:
-                    if m.simple_name in AUTO_CALLED:  # __init__, __enter__, __exit__
-                        m.references += 1
+                for method in methods:
+                    if method.simple_name in AUTO_CALLED:
+                        method.references += 1
 
     def analyze(self, path, thr=60, exclude_folders=None):
         files, root = self._get_python_files(path, exclude_folders)
@@ -251,25 +233,11 @@ class Skylos:
         
         for file in files:
             mod = modmap[file]
+            defs, refs, dyn, exports, test_flags, framework_flags = proc_file(file, mod)
 
-            result = proc_file(file, mod)
-
-            if len(result) == 7: ##new
-                defs, refs, dyn, exports, test_flags, framework_flags, ignored = result
-                self.ignored_lines.update(ignored)
-            else: ##legacy
-                warnings.warn(
-                    "proc_file() now returns 7 values (added ignored_lines). "
-                    "The 6-value form is deprecated and will disappear.",
-                    DeprecationWarning,
-                    stacklevel=2,
-                )
-                defs, refs, dyn, exports, test_flags, framework_flags = result
-
-            # apply penalties while we still have the file-specific flags
-            for d in defs:
-                self._apply_penalties(d, test_flags, framework_flags) 
-                self.defs[d.name] = d
+            for definition in defs:
+                self._apply_penalties(definition, test_flags, framework_flags) 
+                self.defs[definition.name] = definition
 
             self.refs.extend(refs)
             self.dynamic.update(dyn)
@@ -282,14 +250,9 @@ class Skylos:
         thr = max(0, thr)
 
         unused = []
-        for d in self.defs.values():
-            # skip anything on line that carries ignore pragma
-            if d.line in self.ignored_lines:
-                continue
-
-            if (d.references == 0 and not d.is_exported
-                and d.confidence >= thr):
-                    unused.append(d.to_dict())
+        for definition in self.defs.values():
+                if definition.references == 0 and not definition.is_exported and definition.confidence > 0 and definition.confidence >= thr:
+                    unused.append(definition.to_dict())
 
         result = {
             "unused_functions": [], 
@@ -325,7 +288,6 @@ def proc_file(file_or_args, mod=None):
 
     try:
         source = Path(file).read_text(encoding="utf-8")
-        ignored = _collect_ignored_lines(source)   
         tree   = ast.parse(source)
 
         tv = TestAwareVisitor(filename=file)
@@ -337,7 +299,7 @@ def proc_file(file_or_args, mod=None):
         v  = Visitor(mod, file)
         v.visit(tree)
 
-        return v.defs, v.refs, v.dyn, v.exports, tv, fv, ignored
+        return v.defs, v.refs, v.dyn, v.exports, tv, fv
     except Exception as e:
         logger.error(f"{file}: {e}")
         if os.getenv("SKYLOS_DEBUG"):
@@ -345,55 +307,56 @@ def proc_file(file_or_args, mod=None):
         dummy_visitor = TestAwareVisitor(filename=file)
         dummy_framework_visitor = FrameworkAwareVisitor(filename=file)
 
-        return [], [], set(), set(), dummy_visitor, dummy_framework_visitor, set()
+        return [], [], set(), set(), dummy_visitor, dummy_framework_visitor
 
 def analyze(path,conf=60, exclude_folders=None):
     return Skylos().analyze(path,conf, exclude_folders)
 
-if __name__=="__main__":
+if __name__ == "__main__":
     if len(sys.argv)>1:
-        p=sys.argv[1];c=int(sys.argv[2])if len(sys.argv)>2 else 60
-        result = analyze(p,c)
+        p = sys.argv[1]
+        confidence = int(sys.argv[2]) if len(sys.argv) >2 else 60
+        result = analyze(p,confidence)
         
         data = json.loads(result)
-        print("\n🔍 Python Static Analysis Results")
+        print("\n Python Static Analysis Results")
         print("===================================\n")
         
         total_items = sum(len(items) for items in data.values())
         
         print("Summary:")
         if data["unused_functions"]:
-            print(f"  • Unreachable functions: {len(data['unused_functions'])}")
+            print(f" * Unreachable functions: {len(data['unused_functions'])}")
         if data["unused_imports"]:
-            print(f"  • Unused imports: {len(data['unused_imports'])}")
+            print(f" * Unused imports: {len(data['unused_imports'])}")
         if data["unused_classes"]:
-            print(f"  • Unused classes: {len(data['unused_classes'])}")
+            print(f" * Unused classes: {len(data['unused_classes'])}")
         if data["unused_variables"]:
-            print(f"  • Unused variables: {len(data['unused_variables'])}")
+            print(f" * Unused variables: {len(data['unused_variables'])}")
         
         if data["unused_functions"]:
-            print("\n📦 Unreachable Functions")
+            print("\n - Unreachable Functions")
             print("=======================")
             for i, func in enumerate(data["unused_functions"], 1):
                 print(f" {i}. {func['name']}")
                 print(f"    └─ {func['file']}:{func['line']}")
         
         if data["unused_imports"]:
-            print("\n📥 Unused Imports")
+            print("\n - Unused Imports")
             print("================")
             for i, imp in enumerate(data["unused_imports"], 1):
                 print(f" {i}. {imp['simple_name']}")
                 print(f"    └─ {imp['file']}:{imp['line']}")
         
         if data["unused_classes"]:
-            print("\n📋 Unused Classes")
+            print("\n - Unused Classes")
             print("=================")
             for i, cls in enumerate(data["unused_classes"], 1):
                 print(f" {i}. {cls['name']}")
                 print(f"    └─ {cls['file']}:{cls['line']}")
                 
         if data["unused_variables"]:
-            print("\n📊 Unused Variables")
+            print("\n - Unused Variables")
             print("==================")
             for i, var in enumerate(data["unused_variables"], 1):
                 print(f" {i}. {var['name']}")
@@ -406,7 +369,7 @@ if __name__=="__main__":
         print(f"```")
         
         print("\nNext steps:")
-        print("  • Use --interactive to select specific items to remove")
-        print("  • Use --dry-run to preview changes before applying them")
+        print("  * Use --interactive to select specific items to remove")
+        print("  * Use --dry-run to preview changes before applying them")
     else:
         print("Usage: python Skylos.py <path> [confidence_threshold]")

skylos/cli.py

@@ -4,7 +4,8 @@ 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
 
 try:
     import inquirer
@@ -19,14 +20,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()
 
@@ -62,6 +60,7 @@ def remove_unused_import(file_path: str, import_name: str, line_number: int) ->
         
         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]
@@ -69,6 +68,7 @@ def remove_unused_import(file_path: str, import_name: str, line_number: int) ->
                 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] = ''
@@ -90,7 +90,6 @@ def remove_unused_import(file_path: str, import_name: str, line_number: int) ->
         return False
 
 def remove_unused_function(file_path: str, function_name: str, line_number: int) -> bool:
-    # remove the entire def from the source code
     try:
         with open(file_path, 'r') as f:
             content = f.read()
@@ -130,8 +129,8 @@ def remove_unused_function(file_path: str, function_name: str, line_number: int)
                     return True
         
         return False
-    except Exception as e:
-        logging.error(f"Failed to remove function {function_name} from {file_path}: {e}")
+    except:
+        logging.error(f"Failed to remove function {function_name}")
         return False
 
 def interactive_selection(logger, unused_functions, unused_imports):
@@ -146,6 +145,7 @@ def interactive_selection(logger, unused_functions, unused_imports):
         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))
@@ -165,6 +165,7 @@ def interactive_selection(logger, unused_functions, 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))
@@ -183,11 +184,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 +198,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 +237,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 +260,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 +292,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}")
 
@@ -317,15 +327,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 +368,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 +389,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 +407,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 +416,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 +438,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/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