skylos 1.0.10__py3-none-any.whl → 2.5.2__py3-none-any.whl

skylos/cli.py

@@ -2,335 +2,819 @@ import argparse
 import json
 import sys
 import logging
-import ast
+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,
+    comment_out_unused_import_cst,
+    comment_out_unused_function_cst,
+)
+from skylos.config import load_config
+from skylos.gatekeeper import run_gate_interaction
+import pathlib
 import skylos
+from collections import defaultdict
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.theme import Theme
+from rich.logging import RichHandler
+from rich.rule import Rule
+from rich.tree import Tree
 
 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'
+    # kept for compatibility with some strings. rich styles are primary use
+    RED = "\033[91m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    BLUE = "\033[94m"
+    MAGENTA = "\033[95m"
+    CYAN = "\033[96m"
+    BOLD = "\033[1m"
+    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()
 
+
 def setup_logger(output_file=None):
-    logger = logging.getLogger('skylos')
+    theme = Theme(
+        {
+            "good": "bold green",
+            "warn": "bold yellow",
+            "bad": "bold red",
+            "muted": "dim",
+            "brand": "bold cyan",
+        }
+    )
+    console = Console(theme=theme)
+
+    logger = logging.getLogger("skylos")
     logger.setLevel(logging.INFO)
-    
     logger.handlers.clear()
-    
-    formatter = CleanFormatter()
-    
-    console_handler = logging.StreamHandler(sys.stdout)
-    console_handler.setFormatter(formatter)
-    logger.addHandler(console_handler)
-    
+
+    rich_handler = RichHandler(
+        console=console, show_time=False, show_path=False, markup=True
+    )
+    rich_handler.setFormatter(CleanFormatter())
+    logger.addHandler(rich_handler)
+
     if output_file:
-        file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+        file_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
         file_handler = logging.FileHandler(output_file)
         file_handler.setFormatter(file_formatter)
         logger.addHandler(file_handler)
-    
+
     logger.propagate = False
-    
+    logger.console = console
     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:
+
+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
-        
+        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
+
+
+def comment_out_unused_import(
+    file_path, import_name, line_number, marker="SKYLOS DEADCODE"
+):
+    path = pathlib.Path(file_path)
+
+    try:
+        src = path.read_text(encoding="utf-8")
+        new_code, changed = comment_out_unused_import_cst(
+            src, import_name, line_number, marker=marker
+        )
+        if not changed:
+            return False
+        path.write_text(new_code, encoding="utf-8")
+        return True
+
+    except Exception as e:
+        logging.error(
+            f"Failed to comment out import {import_name} from {file_path}: {e}"
+        )
         return False
+
+
+def comment_out_unused_function(
+    file_path, function_name, line_number, marker="SKYLOS DEADCODE"
+):
+    path = pathlib.Path(file_path)
+
+    try:
+        src = path.read_text(encoding="utf-8")
+        new_code, changed = comment_out_unused_function_cst(
+            src, function_name, line_number, marker=marker
+        )
+        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}")
+        logging.error(
+            f"Failed to comment out function {function_name} from {file_path}: {e}"
+        )
         return False
 
-def interactive_selection(logger, unused_functions, unused_imports):
+
+def _shorten_path(file_path, root_path=None):
+    if not file_path:
+        return "?"
+
+    try:
+        p = pathlib.Path(file_path)
+    except TypeError:
+        return str(file_path)
+
+    if root_path is not None:
+        try:
+            root = pathlib.Path(root_path)
+            if root.is_file():
+                root = root.parent
+            p = p.resolve()
+            root = root.resolve()
+            rel = p.relative_to(root)
+            return str(rel)
+        except Exception:
+            return p.name
+
+    return str(p)
+
+
+def interactive_selection(
+    console: Console, unused_functions, unused_imports, root_path=None
+):
     if not INTERACTIVE_AVAILABLE:
-        logger.error("Interactive mode requires 'inquirer' package. Install with: pip install inquirer")
+        console.print(
+            "[bad]Interactive mode requires 'inquirer'. Install with: pip install inquirer[/bad]"
+        )
         return [], []
-    
+
     selected_functions = []
     selected_imports = []
-    
+
     if unused_functions:
-        logger.info(f"\n{Colors.CYAN}{Colors.BOLD}Select unused functions to remove:{Colors.RESET}")
-        
+        console.print(
+            "\n[brand][bold]Select unused functions to remove (space to select):[/bold][/brand]"
+        )
+
         function_choices = []
         for item in unused_functions:
-            choice_text = f"{item['name']} ({item['file']}:{item['line']})"
+            short = _shorten_path(item.get("file"), root_path)
+            choice_text = f"{item['name']} ({short}:{item['line']})"
             function_choices.append((choice_text, item))
-        
+
         questions = [
-            inquirer.Checkbox('functions',
-                            message="Select functions to remove",
-                            choices=function_choices,
-                            )
+            inquirer.Checkbox(
+                "functions",
+                message="Select functions to remove",
+                choices=function_choices,
+            )
         ]
-        
         answers = inquirer.prompt(questions)
         if answers:
-            selected_functions = answers['functions']
-    
+            selected_functions = answers["functions"]
+
     if unused_imports:
-        logger.info(f"\n{Colors.MAGENTA}{Colors.BOLD}Select unused imports to remove:{Colors.RESET}")
-        
+        console.print(
+            "\n[brand][bold]Select unused imports to act on (space to select):[/bold][/brand]"
+        )
+
         import_choices = []
         for item in unused_imports:
-            choice_text = f"{item['name']} ({item['file']}:{item['line']})"
+            short = _shorten_path(item.get("file"), root_path)
+            choice_text = f"{item['name']} ({short}:{item['line']})"
             import_choices.append((choice_text, item))
-        
+
         questions = [
-            inquirer.Checkbox('imports',
-                            message="Select imports to remove",
-                            choices=import_choices,
-                            )
+            inquirer.Checkbox(
+                "imports", message="Select imports to remove", choices=import_choices
+            )
         ]
-        
         answers = inquirer.prompt(questions)
         if answers:
-            selected_imports = answers['imports']
-    
+            selected_imports = answers["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}")
+
+def print_badge(
+    dead_code_count,
+    logger,
+    *,
+    danger_enabled=False,
+    danger_count=0,
+    quality_enabled=False,
+    quality_count=0,
+):
+    console: Console = logger.console
+    console.print(Rule(style="muted"))
+
+    has_dead_code = dead_code_count > 0
+    has_danger = danger_enabled and danger_count > 0
+    has_quality = quality_enabled and quality_count > 0
+
+    if not has_dead_code and not has_danger and not has_quality:
+        console.print(
+            Panel.fit(
+                "[good]Your code is 100% dead-code free![/good]\nAdd this badge to your README:",
+                border_style="good",
+            )
+        )
+        console.print("```markdown")
+        console.print(
+            "![Dead Code Free](https://img.shields.io/badge/Dead_Code-Free-brightgreen?logo=moleculer&logoColor=white)"
+        )
+        console.print("```")
+        return
+
+    headline = f"Found {dead_code_count} dead-code items"
+    if danger_enabled:
+        headline += f" and {danger_count} security issues"
+    if quality_enabled:
+        headline += f" and {quality_count} quality issues"
+    headline += ". Add this badge to your README:"
+
+    console.print(Panel.fit(headline, border_style="warn"))
+    console.print("```markdown")
+    console.print(
+        f"![Dead Code: {dead_code_count}](https://img.shields.io/badge/Dead_Code-{dead_code_count}_detected-orange?logo=codacy&logoColor=red)"
+    )
+    console.print("```")
+
+
+def render_results(console: Console, result, tree=False, root_path=None):
+    summ = result.get("analysis_summary", {})
+    console.print(
+        Panel.fit(
+            f"[brand]Python Static Analysis Results[/brand]\n[muted]Analyzed {summ.get('total_files', '?')} file(s)[/muted]",
+            border_style="brand",
+        )
+    )
+
+    def _pill(label, n, ok_style="good", bad_style="bad"):
+        if n == 0:
+            style = ok_style
+        else:
+            style = bad_style
+        return f"[{style}]{label}: {n}[/{style}]"
+
+    console.print(
+        " ".join(
+            [
+                _pill("Unreachable", len(result.get("unused_functions", []))),
+                _pill("Unused imports", len(result.get("unused_imports", []))),
+                _pill("Unused params", len(result.get("unused_parameters", []))),
+                _pill("Unused vars", len(result.get("unused_variables", []))),
+                _pill("Unused classes", len(result.get("unused_classes", []))),
+                _pill(
+                    "Quality", len(result.get("quality", []) or []), bad_style="warn"
+                ),
+            ]
+        )
+    )
+    console.print()
+
+    def _render_unused(title, items, name_key="name"):
+        if not items:
+            return
+
+        console.rule(f"[bold]{title}")
+
+        table = Table(expand=True)
+        table.add_column("#", style="muted", width=3)
+        table.add_column("Name", style="bold")
+        table.add_column("Location", style="muted", overflow="fold")
+
+        for i, item in enumerate(items, 1):
+            nm = item.get(name_key) or item.get("simple_name") or "<?>"
+            short = _shorten_path(item.get("file"), root_path)
+            loc = f"{short}:{item.get('line', item.get('lineno', '?'))}"
+            table.add_row(str(i), nm, loc)
+
+        console.print(table)
+        console.print()
+
+    def _render_quality(items):
+        if not items:
+            return
+
+        console.rule("[bold red]Quality Issues")
+        table = Table(expand=True)
+        table.add_column("#", style="muted", width=3)
+        table.add_column("Type", style="yellow", width=12)
+        table.add_column("Function", style="bold")
+        table.add_column("Detail")
+        table.add_column("Location", style="muted", width=36)
+
+        for i, quality in enumerate(items, 1):
+            kind = (quality.get("kind") or quality.get("metric") or "quality").title()
+            func = quality.get("name") or quality.get("simple_name") or "<?>"
+            loc = f"{quality.get('basename', '?')}:{quality.get('line', '?')}"
+            value = quality.get("value") or quality.get("complexity")
+            thr = quality.get("threshold")
+            length = quality.get("length")
+
+            if quality.get("kind") == "nesting":
+                detail = f"Deep nesting: depth {value}"
+            else:
+                detail = f"Cyclomatic complexity: {value}"
+            if thr is not None:
+                detail += f" (target ≤ {thr})"
+            if length is not None:
+                detail += f", {length} lines"
+            table.add_row(str(i), kind, func, detail, loc)
+
+        console.print(table)
+        console.print(
+            "[muted]Tip: split helpers, add early returns, flatten branches.[/muted]\n"
+        )
+
+    def _render_secrets(items):
+        if not items:
+            return
+
+        console.rule("[bold red]Secrets")
+        table = Table(expand=True)
+        table.add_column("#", style="muted", width=3)
+        table.add_column("Provider", style="yellow", width=14)
+        table.add_column("Message")
+        table.add_column("Preview", style="muted", width=18)
+        table.add_column("Location", style="muted", overflow="fold")
+
+        for i, s in enumerate(items[:100], 1):
+            prov = s.get("provider") or "generic"
+            msg = s.get("message") or "Secret detected"
+            prev = s.get("preview") or "****"
+            short = _shorten_path(s.get("file"), root_path)
+            loc = f"{short}:{s.get('line', '?')}"
+            table.add_row(str(i), prov, msg, prev, loc)
+
+        console.print(table)
+        console.print()
+
+    def render_tree(console: Console, result, root_path=None):
+        by_file = defaultdict(list)
+
+        def _add_unused(items, kind):
+            for u in items or []:
+                file = u.get("file")
+                if not file:
+                    continue
+                line = u.get("line") or u.get("lineno") or 1
+                name = u.get("name") or u.get("simple_name") or "<?>"
+                msg = f"Unused {kind}: {name}"
+                by_file[file].append((line, "info", msg))
+
+        def _add_findings(items, kind, default_sev="medium"):
+            for f in items or []:
+                file = f.get("file")
+                if not file:
+                    continue
+                line = f.get("line") or 1
+                sev = (f.get("severity") or default_sev).lower()
+                rule = f.get("rule_id")
+                msg = f.get("message") or kind
+                if rule:
+                    msg = f"[{rule}] {msg}"
+                by_file[file].append((line, sev, msg))
+
+        _add_unused(result.get("unused_functions"), "function")
+        _add_unused(result.get("unused_imports"), "import")
+        _add_unused(result.get("unused_classes"), "class")
+        _add_unused(result.get("unused_variables"), "variable")
+        _add_unused(result.get("unused_parameters"), "parameter")
+
+        _add_findings(result.get("danger"), "security", default_sev="high")
+        _add_findings(result.get("secrets"), "secret", default_sev="high")
+        _add_findings(result.get("quality"), "quality", default_sev="medium")
+
+        if not by_file:
+            console.print("[good]No findings to display.[/good]")
+            return
+
+        root_label = str(root_path) if root_path is not None else "Skylos results"
+        tree = Tree(f"[brand]{root_label}[/brand]")
+
+        for file in sorted(by_file.keys()):
+            short = _shorten_path(file, root_path)
+            file_node = tree.add(f"[bold]{short}[/bold]")
+
+            for line, sev, msg in sorted(by_file[file], key=lambda t: t[0]):
+                if sev == "high" or sev == "critical":
+                    style = "bad"
+                elif sev == "medium":
+                    style = "warn"
+                else:
+                    style = "muted"
+                file_node.add(f"[{style}]L{line}[/{style}] {msg}")
+
+        console.print(tree)
+
+    def _render_danger(items):
+        if not items:
+            return
+
+        console.rule("[bold red]Security Issues")
+        table = Table(expand=True)
+        table.add_column("#", style="muted", width=3)
+        table.add_column("Rule", style="yellow", width=18)
+        table.add_column("Severity", width=10)
+        table.add_column("Message", overflow="fold")
+        table.add_column("Location", style="muted", width=36, overflow="fold")
+
+        for i, d in enumerate(items[:100], 1):
+            rule = d.get("rule_id") or "UNKNOWN"
+            sev = (d.get("severity") or "UNKNOWN").title()
+            msg = d.get("message") or "Issue detected"
+            short = _shorten_path(d.get("file"), root_path)
+            loc = f"{short}:{d.get('line', '?')}"
+            table.add_row(str(i), rule, sev, msg, loc)
+
+        console.print(table)
+        console.print()
+
+    if tree:
+        render_tree(console, result, root_path=root_path)
+    else:
+        _render_unused(
+            "Unreachable Functions", result.get("unused_functions", []), name_key="name"
+        )
+        _render_unused(
+            "Unused Imports", result.get("unused_imports", []), name_key="name"
+        )
+        _render_unused(
+            "Unused Parameters", result.get("unused_parameters", []), name_key="name"
+        )
+        _render_unused(
+            "Unused Variables", result.get("unused_variables", []), name_key="name"
+        )
+        _render_unused(
+            "Unused Classes", result.get("unused_classes", []), name_key="name"
+        )
+        _render_secrets(result.get("secrets", []) or [])
+        _render_danger(result.get("danger", []) or [])
+        _render_quality(result.get("quality", []) or [])
+
+def run_init():
+
+    console = Console()
+    path = pathlib.Path("pyproject.toml")
     
-    if dead_code_count == 0:
-        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("```")
+    template = """
+[tool.skylos]
+# Analysis Settings
+complexity = 10
+nesting = 3
+max_args = 5
+max_lines = 50
+ignore = []  # e.g. ["SKY-L002", "SKY-C304"]
+
+[tool.skylos.gate]
+# Gatekeeper Settings (skylos --gate)
+fail_on_critical = true
+max_security = 0
+max_quality = 10
+strict = false
+"""
+
+    if path.exists():
+        content = path.read_text(encoding="utf-8")
+        if "[tool.skylos]" in content:
+            console.print("[warn]pyproject.toml already contains [tool.skylos] configuration.[/warn]")
+            return
+        
+        console.print("[brand]Appending Skylos configuration to existing pyproject.toml...[/brand]")
+        with open(path, "a", encoding="utf-8") as f:
+            f.write("\n" + template)
     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("```")
+        console.print("[brand]Creating new pyproject.toml...[/brand]")
+        path.write_text(template.strip(), encoding="utf-8")
+
+    console.print("[good] ** Configuration initialized! You can now edit pyproject.toml[/good]")
+
+def main():
+
+    if len(sys.argv) > 1 and sys.argv[1] == "init":
+        run_init()
+        sys.exit(0)
+
+    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)
 
-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("path", help="Path to the Python project")
+    parser.add_argument(
+        "--gate", 
+        action="store_true", 
+        help="Run as a quality gate (block deployment on failure)"
+    )
+    parser.add_argument(
+        "--table", action="store_true", help="(deprecated) Show findings in table"
+    )
+    parser.add_argument(
+        "--tree", action="store_true", help="Show findings in tree format"
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"skylos {skylos.__version__}",
+        help="Show version and exit",
+    )
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
     parser.add_argument(
-        "--json",
+        "--comment-out",
         action="store_true",
-        help="Output raw JSON instead of formatted text",
+        help="Comment out selected dead code instead of deleting item",
+    )
+    parser.add_argument("--output", "-o", type=str, help="Write output to file")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose")
+    parser.add_argument(
+        "--confidence",
+        "-c",
+        type=int,
+        default=60,
+        help="Confidence threshold (0-100). Lower = include more. Default: 60",
     )
     parser.add_argument(
-        "--output",
-        "-o",
-        type=str,
-        help="Write output to file instead of stdout",
+        "--interactive", "-i", action="store_true", help="Select items to remove"
     )
     parser.add_argument(
-        "--verbose", "-v",
+        "--dry-run", action="store_true", help="Show what would be removed"
+    )
+
+    parser.add_argument(
+        "--exclude-folder",
+        action="append",
+        dest="exclude_folders",
+        help=(
+            "Exclude a folder from analysis (can be used multiple times). By default, common folders like __pycache__, "
+            ".git, venv are excluded. Use --no-default-excludes to disable default exclusions."
+        ),
+    )
+    parser.add_argument(
+        "--include-folder",
+        action="append",
+        dest="include_folders",
+        help=(
+            "Force include a folder that would otherwise be excluded (overrides both default and custom exclusions). "
+            "Example: --include-folder venv"
+        ),
+    )
+    parser.add_argument(
+        "--no-default-excludes",
+        action="store_true",
+        help="Do not exclude default folders (__pycache__, .git, venv, etc.). Only exclude folders with --exclude-folder.",
+    )
+    parser.add_argument(
+        "--list-default-excludes",
         action="store_true",
-        help="Enable verbose output"
+        help="List the default excluded folders and exit.",
+    )
+    parser.add_argument(
+        "--secrets", action="store_true", help="Scan for API keys. Off by default."
     )
     parser.add_argument(
-        "--interactive", "-i",
+        "--danger",
         action="store_true",
-        help="Interactively select items to remove (requires inquirer)"
+        help="Scan for security issues. Off by default.",
     )
     parser.add_argument(
-        "--dry-run",
+        "--quality",
         action="store_true",
-        help="Show what would be removed without actually modifying files"
+        help="Run code quality checks. Off by default.",
+    )
+
+    parser.add_argument(
+        "command", 
+        nargs="*",
+        help="Command to run if gate passes"
     )
 
     args = parser.parse_args()
+    project_root = pathlib.Path(args.path).resolve()
+    if project_root.is_file():
+        project_root = project_root.parent
+
     logger = setup_logger(args.output)
-    
+    console = logger.console
+
+    if args.list_default_excludes:
+        console.print("[brand]Default excluded folders:[/brand]")
+        for folder in sorted(DEFAULT_EXCLUDE_FOLDERS):
+            console.print(f" {folder}")
+        console.print(f"\n[muted]Total: {len(DEFAULT_EXCLUDE_FOLDERS)} folders[/muted]")
+        console.print("\nUse --no-default-excludes to disable these exclusions")
+        console.print("Use --include-folder <folder> to force include specific folders")
+        return
+
     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}")
+
+    use_defaults = not args.no_default_excludes
+    final_exclude_folders = parse_exclude_folders(
+        user_exclude_folders=args.exclude_folders,
+        use_defaults=use_defaults,
+        include_folders=args.include_folders,
+    )
+
+    if not args.json:
+        if final_exclude_folders:
+            console.print(
+                f"[warn] Excluding:[/warn] {', '.join(sorted(final_exclude_folders))}"
+            )
+        else:
+            console.print("[good] No folders excluded[/good]")
 
     try:
-        result_json = skylos.analyze(args.path)
+        with Progress(
+            SpinnerColumn(style="brand"),
+            TextColumn("[brand]Skylos[/brand] analyzing your code…"),
+            transient=True,
+            console=console,
+        ) as progress:
+            progress.add_task("analyze", total=None)
+            result_json = run_analyze(
+                args.path,
+                conf=args.confidence,
+                enable_secrets=bool(args.secrets),
+                enable_danger=bool(args.danger),
+                enable_quality=bool(args.quality),
+                exclude_folders=list(final_exclude_folders),
+            )
+
+        if args.json:
+            print(result_json)
+            return
+
         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)
-        return
+    if args.interactive:
+        unused_functions = result.get("unused_functions", [])
+        unused_imports = result.get("unused_imports", [])
 
-    unused_functions = result.get("unused_functions", [])
-    unused_imports = result.get("unused_imports", [])
-    
-    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}")
-    
-    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}")
+        if not (unused_functions or unused_imports):
+            console.print("[good]No unused functions/imports to process.[/good]")
+        else:
+            selected_functions, selected_imports = interactive_selection(
+                console, unused_functions, unused_imports, root_path=project_root
+            )
+
+            if selected_functions or selected_imports:
+                if not args.dry_run:
+                    if args.comment_out:
+                        action_func_fn = comment_out_unused_function
+                        action_func_imp = comment_out_unused_import
+                        action_past = "Commented out"
+                        action_verb = "comment out"
+                    else:
+                        action_func_fn = remove_unused_function
+                        action_func_imp = remove_unused_import
+                        action_past = "Removed"
+                        action_verb = "remove"
+
+                    if INTERACTIVE_AVAILABLE:
+                        confirm_q = [
+                            inquirer.Confirm(
+                                "confirm",
+                                message="Proceed with changes?",
+                                default=False,
+                            )
+                        ]
+                        answers = inquirer.prompt(confirm_q)
+                        proceed = answers and answers.get("confirm")
+                    else:
+                        proceed = True
+
+                    if proceed:
+                        console.print(f"[warn]Applying changes…[/warn]")
+                        for func in selected_functions:
+                            ok = action_func_fn(
+                                func["file"], func["name"], func["line"]
+                            )
+                            if ok:
+                                console.print(
+                                    f"[good] ✓ {action_past} function:[/good] {func['name']}"
+                                )
+                            else:
+                                console.print(
+                                    f"[bad] x Failed to {action_verb} function:[/bad] {func['name']}"
+                                )
+
+                        for imp in selected_imports:
+                            ok = action_func_imp(imp["file"], imp["name"], imp["line"])
+                            if ok:
+                                console.print(
+                                    f"[good] ✓ {action_past} import:[/good] {imp['name']}"
+                                )
+                            else:
+                                console.print(
+                                    f"[bad] x Failed to {action_verb} import:[/bad] {imp['name']}"
+                                )
+                        console.print(f"[good]Cleanup complete![/good]")
+                    else:
+                        console.print(f"[warn]Operation cancelled.[/warn]")
                 else:
-                    logger.info(f"\n{Colors.YELLOW}Operation cancelled.{Colors.RESET}")
+                    console.print(f"[warn]Dry run — no files modified.[/warn]")
             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}")
+                console.print("[muted]No items selected.[/muted]")
+
+    render_results(console, result, tree=args.tree, root_path=project_root)
+
+    unused_total = sum(
+        len(result.get(k, []))
+        for k in (
+            "unused_functions",
+            "unused_imports",
+            "unused_variables",
+            "unused_classes",
+            "unused_parameters",
+        )
+    )
+    danger_count = len(result.get("danger", []) or [])
+    quality_count = len(result.get("quality", []) or [])
+    print_badge(
+        unused_total,
+        logging.getLogger("skylos"),
+        danger_enabled=bool(danger_count),
+        danger_count=danger_count,
+        quality_enabled=bool(quality_count),
+        quality_count=quality_count,
+    )
+
+    if args.gate:
+        cfg = load_config(project_root)
         
-        dead_code_count = len(unused_functions) + len(unused_imports)
-        print_badge(dead_code_count, logger)
+        cmd = args.command
+        if cmd and cmd[0] == "--":
+            cmd = cmd[1:]
+ 
+        exit_code = run_gate_interaction(result, cfg, cmd)
+        sys.exit(exit_code)
 
-        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()
+    main()