diffimpactscout 0.1.0__py3-none-any.whl

diffimpactscout/checks/prettier.py

@@ -0,0 +1,103 @@
+"""Prettier incremental check: flags files the developer changed whose formatting differs from prettier.
+
+Example: a dev-changed .ts file that prettier would reformat produces an
+issue and a hint to run prettier on it.
+"""
+
+import os
+import subprocess
+
+from diffimpactscout.checks.base import (
+    Check,
+    CheckIssue,
+    CheckResult,
+    register,
+)
+
+_PRETTIER_EXTS = (".ts", ".js", ".html", ".css", ".scss", ".json")
+
+
+def _run_npx(argv, root):
+    proc = subprocess.Popen(
+        argv,
+        cwd=root,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    out, err = proc.communicate()
+    return proc, out, err
+
+
+def _load_baseline(root):
+    path = os.path.join(root, ".prettierignore_baseline")
+    try:
+        with open(path, "r") as fh:
+            content = fh.read()
+    except (OSError, ValueError):
+        return set()
+    entries = set()
+    for line in content.split("\n"):
+        line = line.strip()
+        if not line:
+            continue
+        if line.startswith("./"):
+            line = line[2:]
+        entries.add(line)
+    return entries
+
+
+def _dev_changed(context, path):
+    try:
+        return bool(
+            context.scope.contains(
+                context.anchor, path, context.from_ref, context.to_ref
+            )
+        )
+    except Exception:
+        return False
+
+
+@register
+class PrettierCheck(Check):
+    id = "prettier"
+    scoped = "files"
+
+    def run(self, context, files):
+        issues = []
+        warned = []
+        baseline = _load_baseline(context.root)
+        for path in files or []:
+            if not path.endswith(_PRETTIER_EXTS):
+                continue
+            parts = path.split("/")
+            if "src" not in parts and "app" not in parts:
+                continue
+            if path in baseline and not _dev_changed(context, path):
+                continue
+            try:
+                proc, _out, _err = _run_npx(
+                    ["npx", "prettier", "--check", path],
+                    context.root,
+                )
+            except OSError as exc:
+                warned.append("npx prettier unavailable: %s" % exc)
+                break
+            if proc.returncode == 0:
+                continue
+            if proc.returncode != 1:
+                warned.append(
+                    "npx prettier --check %s exited with code %s"
+                    % (path, proc.returncode)
+                )
+                continue
+            issues.append(
+                CheckIssue(
+                    path,
+                    0,
+                    0,
+                    self.id,
+                    "%s is not formatted. Fix with: npx prettier --write %s"
+                    % (path, path),
+                )
+            )
+        return CheckResult(issues=issues, warned=warned)

diffimpactscout/checks/repo_checks.py

@@ -0,0 +1,95 @@
+"""Repo-wide checks for oversized files and leaked private keys.
+
+Example: a 300 MB binary is flagged with a git-lfs hint, and any file
+containing a private key block always blocks the push.
+"""
+
+import os
+
+from diffimpactscout.checks.base import (
+    Check,
+    CheckIssue,
+    CheckResult,
+    register,
+)
+
+PRIVATE_KEY_MARKERS = (
+    b"-----BEGIN RSA PRIVATE KEY-----",
+    b"-----BEGIN PRIVATE KEY-----",
+    b"-----BEGIN EC PRIVATE KEY-----",
+    b"-----BEGIN OPENSSH PRIVATE KEY-----",
+    b"-----BEGIN DSA PRIVATE KEY-----",
+    b"-----BEGIN PGP PRIVATE KEY BLOCK-----",
+)
+
+
+@register
+class LargeFilesCheck(Check):
+    id = "repo/large-files"
+    scoped = "files"
+    max_kb = 250000
+
+    def extend_config(self, entry):
+        super(LargeFilesCheck, self).extend_config(entry)
+        max_kb = 250000
+        for arg in self.args:
+            if arg.startswith("--maxkb"):
+                if not arg.startswith("--maxkb="):
+                    raise ValueError("--maxkb must be --maxkb=<positive int>")
+                value = arg[len("--maxkb="):]
+                try:
+                    max_kb = int(value)
+                except ValueError:
+                    raise ValueError("invalid --maxkb value: %r" % value)
+                if max_kb <= 0:
+                    raise ValueError("--maxkb must be a positive integer")
+        self.max_kb = max_kb
+        return self
+
+    def run(self, context, files):
+        issues = []
+        for path in files or []:
+            fn = os.path.join(context.root, path)
+            try:
+                if not os.path.exists(fn):
+                    continue
+                size = os.path.getsize(fn)
+            except OSError:
+                continue
+            if size > self.max_kb * 1024:
+                size_kb = size // 1024
+                issues.append(
+                    CheckIssue(
+                        path,
+                        0,
+                        0,
+                        self.id,
+                        "file size %d kB exceeds limit of %d kB; consider git lfs"
+                        % (size_kb, self.max_kb),
+                    )
+                )
+        return CheckResult(issues=issues)
+
+
+@register
+class PrivateKeyCheck(Check):
+    id = "repo/private-key"
+    scoped = "files"
+    always_block = True
+
+    def run(self, context, files):
+        issues = []
+        for path in files or []:
+            fn = os.path.join(context.root, path)
+            try:
+                with open(fn, "rb") as fh:
+                    data = fh.read()
+            except OSError:
+                continue
+            for marker in PRIVATE_KEY_MARKERS:
+                if marker in data:
+                    issues.append(
+                        CheckIssue(path, 0, 0, self.id, "private key detected")
+                    )
+                    break
+        return CheckResult(issues=issues)

diffimpactscout/checks/ruff.py

@@ -0,0 +1,210 @@
+"""Ruff and ruff-format incremental checks scoped to the developer's changed lines.
+
+Example: an E501 on a line the developer added blocks the push, while an
+E501 on an untouched upstream line does not.
+"""
+
+import json
+import re
+import subprocess
+
+from diffimpactscout.checks.base import (
+    Check,
+    CheckIssue,
+    CheckResult,
+    register,
+)
+
+_HUNK_RE = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+
+
+def _truncate(text, limit=30):
+    lines = text.split("\n")
+    if len(lines) <= limit:
+        return text
+    return "\n".join(lines[:limit]) + "\n... (%d more lines)" % (
+        len(lines) - limit
+    )
+
+
+def _changed_lines(context, path):
+    try:
+        tracked = context.is_tracked(path)
+        changed = context.changed_lines(path)
+    except Exception:
+        return set()
+    if changed is not None:
+        return changed
+    if tracked:
+        return set()
+    return None
+
+
+def _filter_diff_by_lines(diff, changed):
+    if changed is None:
+        return diff
+    if not changed:
+        return ""
+    lines = diff.split("\n")
+    header = []
+    i = 0
+    while i < len(lines) and (
+        lines[i].startswith("--- ") or lines[i].startswith("+++ ")
+    ):
+        header.append(lines[i])
+        i += 1
+    out = list(header)
+    body = "\n".join(lines[i:])
+    for hunk in re.split(r"(?=^@@)", body, flags=re.MULTILINE):
+        if not hunk.startswith("@@"):
+            continue
+        m = _HUNK_RE.match(hunk)
+        if not m:
+            continue
+        old_ln = int(m.group(1))
+        block = []
+        block_old_lines = []
+        found = []
+        for ln in hunk.split("\n")[1:]:
+            if ln.startswith("-"):
+                block.append(ln)
+                block_old_lines.append(old_ln)
+                old_ln += 1
+            elif ln.startswith("+"):
+                block.append(ln)
+            else:
+                if block and any(o in changed for o in block_old_lines):
+                    found.extend(block)
+                block = []
+                block_old_lines = []
+                if ln.startswith(" "):
+                    old_ln += 1
+        if block and any(o in changed for o in block_old_lines):
+            found.extend(block)
+        if found:
+            out.append(hunk.split("\n")[0])
+            out.extend(found)
+    if len(out) > len(header):
+        return "\n".join(out)
+    return ""
+
+
+def _run_ruff(argv, root):
+    proc = subprocess.Popen(
+        argv,
+        cwd=root,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    out, err = proc.communicate()
+    return proc, out, err
+
+
+@register
+class RuffCheck(Check):
+    id = "ruff"
+    scoped = "lines"
+
+    def run(self, context, files):
+        issues = []
+        warned = []
+        for path in files or []:
+            if not path.endswith(".py"):
+                continue
+            changed = _changed_lines(context, path)
+            if changed is not None and not changed:
+                continue
+            try:
+                proc, out, err = _run_ruff(
+                    ["ruff", "check", path, "--output-format", "json"],
+                    context.root,
+                )
+            except OSError as exc:
+                warned.append("ruff unavailable: %s" % exc)
+                break
+            if proc.returncode not in (0, 1):
+                warned.append(
+                    "ruff check %s exited with code %s"
+                    % (path, proc.returncode)
+                )
+                continue
+            try:
+                data = json.loads(out.decode("utf-8", errors="replace"))
+            except ValueError:
+                continue
+            if not isinstance(data, list):
+                continue
+            for violation in data:
+                location = violation.get("location") or {}
+                row = location.get("row")
+                if changed is not None and row not in changed:
+                    continue
+                issues.append(
+                    CheckIssue(
+                        path,
+                        row or 0,
+                        location.get("column") or 0,
+                        violation.get("code") or self.id,
+                        violation.get("message") or "",
+                    )
+                )
+        return CheckResult(issues=issues, warned=warned)
+
+
+@register
+class RuffFormatCheck(Check):
+    id = "ruff-format"
+    scoped = "lines"
+
+    def run(self, context, files):
+        issues = []
+        warned = []
+        for path in files or []:
+            if not path.endswith(".py"):
+                continue
+            changed = _changed_lines(context, path)
+            if changed is not None and not changed:
+                continue
+            try:
+                proc, _out, _err = _run_ruff(
+                    ["ruff", "format", "--check", path], context.root
+                )
+            except OSError as exc:
+                warned.append("ruff unavailable: %s" % exc)
+                break
+            if proc.returncode == 0:
+                continue
+            if proc.returncode != 1:
+                warned.append(
+                    "ruff format --check %s exited with code %s"
+                    % (path, proc.returncode)
+                )
+                continue
+            try:
+                diff_proc, out, _err = _run_ruff(
+                    ["ruff", "format", "--diff", path], context.root
+                )
+            except OSError as exc:
+                warned.append("ruff unavailable: %s" % exc)
+                break
+            if diff_proc.returncode not in (0, 1):
+                warned.append(
+                    "ruff format --diff %s exited with code %s"
+                    % (path, diff_proc.returncode)
+                )
+                continue
+            diff = out.decode("utf-8", errors="replace")
+            kept = _filter_diff_by_lines(diff, changed)
+            if not kept:
+                continue
+            issues.append(
+                CheckIssue(
+                    path,
+                    0,
+                    0,
+                    self.id,
+                    "formatting issue in changed lines:\n%s\nFix with: ruff format %s"
+                    % (_truncate(kept), path),
+                )
+            )
+        return CheckResult(issues=issues, warned=warned)

diffimpactscout/checks/syntax.py

@@ -0,0 +1,133 @@
+"""Syntax checks for JSON, Python AST, and merge-conflict markers.
+
+Example: a "=======" marker in a dev-changed region is flagged as a leftover
+merge conflict, and a dev-added invalid JSON file is flagged.
+"""
+
+import ast
+import json
+import os
+
+from diffimpactscout.checks.base import (
+    Check,
+    CheckIssue,
+    CheckResult,
+    register,
+)
+
+
+@register
+class JsonSyntaxCheck(Check):
+    id = "syntax/json-syntax"
+    scoped = "files"
+
+    def run(self, context, files):
+        issues = []
+        for path in files or []:
+            if not path.endswith(".json"):
+                continue
+            fn = os.path.join(context.root, path)
+            try:
+                with open(fn, "rb") as fh:
+                    data = fh.read()
+            except OSError:
+                continue
+            try:
+                json.loads(data)
+            except ValueError as exc:
+                issues.append(
+                    CheckIssue(
+                        path,
+                        getattr(exc, "lineno", 0) or 0,
+                        getattr(exc, "colno", 0) or 0,
+                        self.id,
+                        "invalid JSON: %s" % exc,
+                    )
+                )
+        return CheckResult(issues=issues)
+
+
+@register
+class AstSyntaxCheck(Check):
+    id = "syntax/ast-syntax"
+    scoped = "files"
+
+    def run(self, context, files):
+        issues = []
+        for path in files or []:
+            if not path.endswith(".py"):
+                continue
+            fn = os.path.join(context.root, path)
+            try:
+                with open(fn, "rb") as fh:
+                    data = fh.read()
+            except OSError:
+                continue
+            try:
+                ast.parse(data.decode("utf-8-sig"), filename=path)
+            except SyntaxError as exc:
+                issues.append(
+                    CheckIssue(
+                        path,
+                        exc.lineno or 0,
+                        exc.offset or 0,
+                        self.id,
+                        "invalid python syntax: %s" % (exc.msg or "syntax error"),
+                    )
+                )
+            except ValueError as exc:
+                issues.append(
+                    CheckIssue(
+                        path, 0, 0, self.id, "invalid python source: %s" % exc
+                    )
+                )
+        return CheckResult(issues=issues)
+
+
+@register
+class MergeConflictCheck(Check):
+    id = "syntax/merge-conflict"
+    scoped = "lines"
+    markers = ("<<<<<<< ", "=======", ">>>>>>> ")
+
+    def run(self, context, files):
+        issues = []
+        for path in files or []:
+            fn = os.path.join(context.root, path)
+            try:
+                with open(fn, "rb") as fh:
+                    data = fh.read()
+            except OSError:
+                continue
+            lines = data.decode("utf-8", errors="replace").splitlines()
+            changed = self._changed_lines(context, path)
+            if changed is None:
+                changed = set(range(1, len(lines) + 1))
+            if not changed:
+                continue
+            for lineno in sorted(changed):
+                if lineno < 1 or lineno > len(lines):
+                    continue
+                line = lines[lineno - 1]
+                if self._is_marker(line):
+                    issues.append(
+                        CheckIssue(path, lineno, 0, self.id, "conflict marker found")
+                    )
+        return CheckResult(issues=issues)
+
+    def _is_marker(self, line):
+        if line == "=======":
+            return True
+        return line.startswith("<<<<<<< ") or line.startswith(">>>>>>> ")
+
+    def _changed_lines(self, context, path):
+        try:
+            tracked = context.is_tracked(path)
+            changed = context.changed_lines(path)
+        except Exception:
+            return set()
+        if changed is not None:
+            return changed
+        if tracked:
+            return set()
+        return None