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

skylos/codemods.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+import libcst as cst
+from libcst.metadata import PositionProvider
+from libcst.helpers import get_full_name_for_node
+
+
+class _CommentOutBlock(cst.CSTTransformer):
+    METADATA_DEPENDENCIES = (PositionProvider,)
+
+    def __init__(self, module_code, marker="SKYLOS DEADCODE"):
+        self.module_code = module_code.splitlines(True)
+        self.marker = marker
+
+    def _comment_block(self, start_line, end_line):
+        lines = self.module_code[start_line - 1 : end_line]
+        out = []
+        out.append(
+            cst.EmptyLine(
+                comment=cst.Comment(
+                    f"# {self.marker} START (lines {start_line}-{end_line})"
+                )
+            )
+        )
+        for raw in lines:
+            out.append(cst.EmptyLine(comment=cst.Comment("# " + raw.rstrip("\n"))))
+        out.append(cst.EmptyLine(comment=cst.Comment(f"# {self.marker} END")))
+        return out
+
+
+class _CommentOutFunctionAtLine(_CommentOutBlock):
+    def __init__(self, func_name, target_line, module_code, marker):
+        super().__init__(module_code, marker)
+        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 pos and pos.start.line == self.target_line
+
+    def leave_FunctionDef(self, orig: cst.FunctionDef, updated: cst.FunctionDef):
+        target = self.func_name.split(".")[-1]
+        if self._is_target(orig) and (orig.name.value == target):
+            self.changed = True
+            pos = self.get_metadata(PositionProvider, orig)
+            return cst.FlattenSentinel(
+                self._comment_block(pos.start.line, pos.end.line)
+            )
+        return updated
+
+    def leave_AsyncFunctionDef(
+        self, orig: cst.AsyncFunctionDef, updated: cst.AsyncFunctionDef
+    ):
+        target = self.func_name.split(".")[-1]
+        if self._is_target(orig) and (orig.name.value == target):
+            self.changed = True
+            pos = self.get_metadata(PositionProvider, orig)
+            return cst.FlattenSentinel(
+                self._comment_block(pos.start.line, pos.end.line)
+            )
+        return updated
+
+
+class _CommentOutImportAtLine(_CommentOutBlock):
+    def __init__(self, target_name, target_line, module_code, marker):
+        super().__init__(module_code, marker)
+        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 <= pos.end.line))
+
+    def _render_single_alias_text(self, head, alias: cst.ImportAlias, is_from):
+        if is_from:
+            alias_txt = alias.name.code
+            if alias.asname:
+                alias_txt += f" as {alias.asname.name.value}"
+            return f"from {head} import {alias_txt}"
+        else:
+            alias_txt = alias.name.code
+            if alias.asname:
+                alias_txt += f" as {alias.asname.name.value}"
+            return f"import {alias_txt}"
+
+    def _split_aliases(self, aliases, head, is_from):
+        kept = []
+        removed_for_comment = []
+        for alias in list(aliases):
+            bound = _bound_name_for_import_alias(alias)
+            name_code = get_full_name_for_node(alias.name)
+            tail = name_code.split(".")[-1]
+            if self.target_name in (bound, tail):
+                self.changed = True
+                removed_for_comment.append(
+                    self._render_single_alias_text(head, alias, is_from)
+                )
+            else:
+                kept.append(alias)
+        return kept, removed_for_comment
+
+    def leave_Import(self, orig: cst.Import, updated: cst.Import):
+        if not self._is_target_line(orig):
+            return updated
+
+        head = ""
+        kept, removed = self._split_aliases(updated.names, head, is_from=False)
+
+        if not removed:
+            return updated
+
+        pos = self.get_metadata(PositionProvider, orig)
+        if not kept:
+            return cst.FlattenSentinel(
+                self._comment_block(pos.start.line, pos.end.line)
+            )
+
+        commented = []
+        for txt in removed:
+            comment = cst.Comment(f"# {self.marker}: {txt}")
+            commented.append(cst.EmptyLine(comment=comment))
+
+        kept_import = updated.with_changes(names=tuple(kept))
+        all_nodes = [kept_import] + commented
+        return cst.FlattenSentinel(all_nodes)
+
+    def leave_ImportFrom(self, orig: cst.ImportFrom, updated: cst.ImportFrom):
+        if not self._is_target_line(orig) or isinstance(updated.names, cst.ImportStar):
+            return updated
+
+        if updated.relative:
+            dots = "." * len(updated.relative)
+        else:
+            dots = ""
+
+        if updated.module is not None:
+            modname = updated.module.code
+        else:
+            modname = ""
+
+        mod = f"{dots}{modname}"
+
+        kept, removed = self._split_aliases(list(updated.names), mod, is_from=True)
+
+        if not removed:
+            return updated
+        pos = self.get_metadata(PositionProvider, orig)
+
+        if not kept:
+            comment_block = self._comment_block(pos.start.line, pos.end.line)
+            return cst.FlattenSentinel(comment_block)
+
+        commented = []
+        for txt in removed:
+            comment = cst.Comment(f"# {self.marker}: {txt}")
+            commented.append(cst.EmptyLine(comment=comment))
+
+        updated_import = updated.with_changes(names=tuple(kept))
+        all_nodes = [updated_import] + commented
+
+        return cst.FlattenSentinel(all_nodes)
+
+
+def comment_out_unused_function_cst(
+    code, func_name, line_number, marker="SKYLOS DEADCODE"
+):
+    wrapper = cst.MetadataWrapper(cst.parse_module(code))
+    tx = _CommentOutFunctionAtLine(func_name, line_number, code, marker)
+    new_mod = wrapper.visit(tx)
+    return new_mod.code, tx.changed
+
+
+def comment_out_unused_import_cst(
+    code, import_name, line_number, marker="SKYLOS DEADCODE"
+):
+    wrapper = cst.MetadataWrapper(cst.parse_module(code))
+    tx = _CommentOutImportAtLine(import_name, line_number, code, marker)
+    new_mod = wrapper.visit(tx)
+    return new_mod.code, tx.changed
+
+
+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 <= pos.end.line))
+
+    def _filter_aliases(self, aliases):
+        kept = []
+        for alias in aliases:
+            bound = _bound_name_for_import_alias(alias)
+            name_code = get_full_name_for_node(alias.name) or ""
+            tail = name_code.split(".")[-1]
+            if self.target_name in (bound, tail):
+                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 pos and pos.start.line == self.target_line
+
+    def leave_FunctionDef(self, orig: cst.FunctionDef, updated: cst.FunctionDef):
+        target = self.func_name.split(".")[-1]
+        if self._is_target(orig) and (orig.name.value == target):
+            self.changed = True
+            return cst.RemoveFromParent()
+        return updated
+
+    def leave_AsyncFunctionDef(
+        self, orig: cst.AsyncFunctionDef, updated: cst.AsyncFunctionDef
+    ):
+        target = self.func_name.split(".")[-1]
+        if self._is_target(orig) and (orig.name.value == target):
+            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/config.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+
+DEFAULTS = {
+    "complexity": 10,
+    "nesting": 3,
+    "max_args": 5,
+    "max_lines": 50,
+    "ignore": [],
+}
+
+
+def load_config(start_path):
+    current = Path(start_path).resolve()
+    if current.is_file():
+        current = current.parent
+
+    root_config = None
+
+    while True:
+        toml_path = current / "pyproject.toml"
+        if toml_path.exists():
+            root_config = toml_path
+            break
+        if current.parent == current:
+            break
+        current = current.parent
+
+    if not root_config:
+        return DEFAULTS.copy()
+
+    try:
+        import tomllib
+    except ImportError:
+        try:
+            import tomli as tomllib
+        except ImportError:
+            return DEFAULTS.copy()
+
+    try:
+        with open(root_config, "rb") as f:
+            data = tomllib.load(f)
+
+        user_cfg = data.get("tool", {}).get("skylos", {})
+
+        final_cfg = DEFAULTS.copy()
+        final_cfg.update(user_cfg)
+        return final_cfg
+
+    except Exception:
+        return DEFAULTS.copy()

skylos/constants.py

@@ -0,0 +1,78 @@
+import re
+
+PENALTIES = {
+    "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_IMPORT_RE = re.compile(r"^(pytest|unittest|nose|mock|responses)(\.|$)")
+TEST_DECOR_RE = re.compile(
+    r"""^(
+    pytest\.(fixture|mark) |
+    patch(\.|$) |
+    responses\.activate |
+    freeze_time
+)$""",
+    re.X,
+)
+
+AUTO_CALLED = {"__init__", "__enter__", "__exit__"}
+TEST_METHOD_PATTERN = re.compile(r"^test_\w+$")
+
+UNITTEST_LIFECYCLE_METHODS = {
+    "setUp",
+    "tearDown",
+    "setUpClass",
+    "tearDownClass",
+    "setUpModule",
+    "tearDownModule",
+}
+
+FRAMEWORK_FILE_RE = re.compile(r"(?:views|handlers|endpoints|routes|api)\.py$", re.I)
+
+DEFAULT_EXCLUDE_FOLDERS = {
+    "__pycache__",
+    ".git",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".tox",
+    "htmlcov",
+    ".coverage",
+    "build",
+    "dist",
+    "*.egg-info",
+    "venv",
+    ".venv",
+}
+
+
+def is_test_path(p):
+    return bool(TEST_FILE_RE.search(str(p)))
+
+
+def is_framework_path(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

skylos/gatekeeper.py

@@ -0,0 +1,147 @@
+import sys
+import subprocess
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+
+try:
+    import inquirer
+    INTERACTIVE = True
+except ImportError:
+    INTERACTIVE = False
+
+console = Console()
+
+def run_cmd(cmd_list, error_msg="Git command failed"):
+    try:
+        result = subprocess.run(cmd_list, check=True, capture_output=True, text=True)
+        return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        console.print(f"[bold red]Error:[/bold red] {error_msg}\n[dim]{e.stderr}[/dim]")
+        return None
+
+def get_git_status():
+    out = run_cmd(["git", "status", "--porcelain"], "Could not get git status. Is this a repo?")
+    if not out: 
+        return []
+    
+    files = []
+    for line in out.splitlines():
+        if len(line) > 3: files.append(line[3:])
+    return files
+
+def run_push():
+    console.print("[dim]Pushing to remote...[/dim]")
+    try:
+        subprocess.run(["git", "push"], check=True)
+        console.print("[bold green] Deployment Complete. Code is live.[/bold green]")
+    except subprocess.CalledProcessError:
+        console.print("[bold red] Push failed. Check your git remote settings.[/bold red]")
+
+def start_deployment_wizard():
+    if not INTERACTIVE:
+        console.print("[yellow]Install 'inquirer' (pip install inquirer) to use interactive deployment.[/yellow]")
+        return
+
+    console.print("\n[bold cyan] Skylos Deployment Wizard[/bold cyan]")
+    
+    files = get_git_status()
+    if not files:
+        console.print("[green]Working tree is clean.[/green]")
+        if Confirm.ask("Push existing commits?"):
+            run_push()
+        return
+
+    q_scope = [
+        inquirer.List('scope',
+            message="What do you want to stage?",
+            choices=['All changed files', 'Select files manually', 'Skip commit (Push only)']
+        ),
+    ]
+    ans_scope = inquirer.prompt(q_scope)
+    if not ans_scope: 
+        return
+
+    if ans_scope['scope'] == 'Select files manually':
+        q_files = [inquirer.Checkbox('files', message="Select files", choices=files)]
+        ans_files = inquirer.prompt(q_files)
+        if not ans_files or not ans_files['files']:
+            console.print("[red]No files selected.[/red]")
+            return
+        run_cmd(["git", "add"] + ans_files['files'])
+        console.print(f"[green]Staged {len(ans_files['files'])} files.[/green]")
+
+    elif ans_scope['scope'] == 'All changed files':
+        run_cmd(["git", "add", "."])
+        console.print("[green]Staged all files.[/green]")
+    
+    if ans_scope['scope'] != 'Skip commit (Push only)':
+        msg = Prompt.ask("[bold green]Enter commit message[/bold green]")
+        if not msg:
+            console.print("[red]Commit message required.[/red]")
+            return
+        if run_cmd(["git", "commit", "-m", msg]):
+            console.print("[green]✓ Committed.[/green]")
+
+    if Confirm.ask("Ready to git push?"):
+        run_push()
+
+def check_gate(results, config):
+    gate_cfg = config.get("gate", {})
+    
+    danger = results.get("danger", [])
+    secrets = results.get("secrets", [])
+    quality = results.get("quality", [])
+    
+    reasons = []
+
+    criticals = []
+    for f in danger:
+        if f.get("severity") == "CRITICAL":
+            criticals.append(f)
+
+    if gate_cfg.get("fail_on_critical") and (criticals or secrets):
+        if criticals: reasons.append(f"Found {len(criticals)} CRITICAL security issues")
+        if secrets: reasons.append(f"Found {len(secrets)} Secrets")
+
+    total_sec = len(danger)
+    limit_sec = gate_cfg.get("max_security", 0)
+    if total_sec > limit_sec:
+        reasons.append(f"Security issues ({total_sec}) exceed limit ({limit_sec})")
+
+    total_qual = len(quality)
+    limit_qual = gate_cfg.get("max_quality", 10)
+    if total_qual > limit_qual:
+        reasons.append(f"Quality issues ({total_qual}) exceed limit ({limit_qual})")
+
+    return (len(reasons) == 0), reasons
+
+def run_gate_interaction(results, config, command_to_run):
+    passed, reasons = check_gate(results, config)
+    
+    if passed:
+        console.print("\n[bold green] Skylos Gate Passed.[/bold green]")
+        if command_to_run:
+            console.print(f"[dim]Running: {' '.join(command_to_run)}[/dim]")
+            subprocess.run(command_to_run)
+        else:
+            start_deployment_wizard()
+        return 0
+
+    console.print("\n[bold red] Skylos Gate Failed![/bold red]")
+    for reason in reasons:
+        console.print(f" - {reason}")
+    
+    if config.get("gate", {}).get("strict"):
+        console.print("[bold red]Strict mode enabled. Cannot bypass.[/bold red]")
+        return 1
+
+    if sys.stdout.isatty():
+        if Confirm.ask("\n[bold yellow]Do you want to bypass checks and proceed anyway?[/bold yellow]"):
+            console.print("[yellow]⚠ Bypassing Gate...[/yellow]")
+            if command_to_run:
+                subprocess.run(command_to_run)
+            else:
+                start_deployment_wizard()
+            return 0
+    
+    return 1

skylos/linter.py

@@ -0,0 +1,18 @@
+import ast
+
+
+class LinterVisitor(ast.NodeVisitor):
+    def __init__(self, rules, filename):
+        self.rules = rules
+        self.filename = filename
+        self.findings = []
+        self.context = {"filename": filename}
+
+    def visit(self, node):
+        for rule in self.rules:
+            results = rule.visit_node(node, self.context)
+            if results:
+                self.findings.extend(results)
+
+        for child in ast.iter_child_nodes(node):
+            self.visit(child)

skylos/rules/base.py

@@ -0,0 +1,20 @@
+import ast
+from abc import ABC, abstractmethod
+
+
+class SkylosRule(ABC):
+    """Base class for all Skylos rules"""
+
+    @property
+    @abstractmethod
+    def rule_id(self):
+        pass
+
+    @property
+    @abstractmethod
+    def name(self):
+        pass
+
+    @abstractmethod
+    def visit_node(self, node, context):
+        pass