diffimpactscout 0.1.0__py3-none-any.whl

diffimpactscout/__init__.py

@@ -0,0 +1,3 @@
+"""diffimpactscout: incremental pre-push guard and AST blast-radius impact analyzer."""
+
+__version__ = "0.1.0"

diffimpactscout/__main__.py

@@ -0,0 +1,8 @@
+"""Module entry point: ``python -m diffimpactscout`` runs the CLI."""
+
+import sys
+
+from diffimpactscout.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

diffimpactscout/base.py

@@ -0,0 +1,95 @@
+"""Resolve the change base the developer's diff is measured against (upstream master, upstream sprint, or the default origin branch).
+
+Example: when the repo has an upstream/sprint/12 ref, diffs are measured
+against it instead of origin/master.
+"""
+
+import diffimpactscout.gitrun as gitrun
+
+MASTER_REF = "refs/remotes/upstream/master"
+SPRINT_PREFIX = "sprint/"
+DEFAULT_MAX_SPRINT_CANDIDATES = 10
+REMOTE_FALLBACKS = ("main", "master", "develop")
+
+
+def resolve_change_base(root, limit=DEFAULT_MAX_SPRINT_CANDIDATES):
+    """Return the remote ref closest to HEAD, or None.
+
+    `limit` caps how many `sprint/*` refs are considered: only the
+    `limit` (default 10) most-recent ones by committer date, unlike the
+    bash original dev_base.sh which considered every sprint branch.
+    """
+    for remote in _remote_order(root):
+        ref = _resolve_remote(root, remote, limit)
+        if ref is not None:
+            return ref
+    return None
+
+
+def _remote_order(root):
+    names = set()
+    for name in gitrun.git_lines(["remote"], root):
+        if name:
+            names.add(name)
+    for ref in gitrun.git_lines(
+        ["for-each-ref", "--format=%(refname)", "refs/remotes/"], root
+    ):
+        parts = ref.split("/")
+        if len(parts) >= 3:
+            names.add(parts[2])
+    ordered = []
+    for name in ("upstream", "origin"):
+        if name in names:
+            ordered.append(name)
+    for name in sorted(names):
+        if name not in ordered:
+            ordered.append(name)
+    return ordered
+
+
+def _resolve_remote(root, remote, limit):
+    if remote == "upstream":
+        return _closest_tree(root, _upstream_candidates(root, limit))
+    short = gitrun.git_out(
+        ["symbolic-ref", "--short", "refs/remotes/%s/HEAD" % remote], root
+    )
+    if short.startswith(remote + "/"):
+        ref = "refs/remotes/" + short
+        if gitrun.git_ok(["rev-parse", "--verify", ref], root):
+            return ref
+    for branch in REMOTE_FALLBACKS:
+        ref = "refs/remotes/%s/%s" % (remote, branch)
+        if gitrun.git_ok(["rev-parse", "--verify", ref], root):
+            return ref
+    return None
+
+
+def _upstream_candidates(root, limit):
+    candidates = [MASTER_REF]
+    pattern = "refs/remotes/upstream/%s" % SPRINT_PREFIX
+    sprints = gitrun.git_lines(
+        ["for-each-ref", "--sort=-committerdate", "--format=%(refname)", pattern], root
+    )
+    candidates.extend(sprints[:limit])
+    return candidates
+
+
+def _closest_tree(root, candidates):
+    best = None
+    best_count = None
+    for ref in candidates:
+        if not ref:
+            continue
+        if not gitrun.git_ok(["rev-parse", "--verify", ref], root):
+            continue
+        count = len(
+            gitrun.git_nul(
+                ["diff", "--name-only", "-z", "--diff-filter=ACMRT", ref, "HEAD"], root
+            )
+        )
+        if best_count is None or count < best_count:
+            best = ref
+            best_count = count
+        if count == 0:
+            break
+    return best

diffimpactscout/checks/__init__.py

@@ -0,0 +1,20 @@
+"""Checks package: registry of all guard checks and the make_check factory."""
+
+from diffimpactscout.checks import base
+from diffimpactscout.checks.base import (
+    REGISTRY,
+    Check,
+    CheckContext,
+    CheckIssue,
+    CheckResult,
+    ExternalCheck,
+    make_check,
+    register,
+)
+
+import diffimpactscout.checks.hygiene
+import diffimpactscout.checks.syntax
+import diffimpactscout.checks.repo_checks
+import diffimpactscout.checks.ruff
+import diffimpactscout.checks.eslint
+import diffimpactscout.checks.prettier

diffimpactscout/checks/base.py

@@ -0,0 +1,206 @@
+"""Check framework: registers checks, defines the check context and results, and turns config entries into runnable checks.
+
+Example: a check entry with type external runs a given command per file and
+reports its output as issues.
+"""
+
+import subprocess
+
+import diffimpactscout.env as env
+
+REGISTRY = {}
+
+
+class Check(object):
+    id = None
+    scoped = "files"
+    blocking = True
+    always_block = False
+
+    def __init__(self, id=None, scoped=None, blocking=None, always_block=None):
+        if id is not None:
+            self.id = id
+        if scoped is not None:
+            self.scoped = scoped
+        if blocking is not None:
+            self.blocking = blocking
+        if always_block is not None:
+            self.always_block = always_block
+        if getattr(self, "id", None) is None:
+            raise ValueError("Check subclass must define an id")
+        self.args = []
+
+    def extend_config(self, entry):
+        if isinstance(entry, dict):
+            args = entry.get("args")
+            if args:
+                self.args = list(self.args) + list(args)
+            blocking = entry.get("blocking")
+            if blocking is not None:
+                self.blocking = env.is_true(blocking)
+            always_block = entry.get("always_block")
+            if always_block is not None:
+                self.always_block = env.is_true(always_block)
+        return self
+
+    def run(self, context, files):
+        raise NotImplementedError("Check subclasses must implement run()")
+
+
+class ExternalCheck(Check):
+    scoped = "files"
+
+    def __init__(self, entry):
+        if not isinstance(entry, dict):
+            entry = {}
+        command = list(entry.get("command") or [])
+        if not command:
+            raise ValueError("external check requires a command")
+        cid = entry.get("id")
+        if not cid:
+            cid = "external:" + command[0]
+        super(ExternalCheck, self).__init__(
+            id=cid,
+            scoped=entry.get("scoped") or "files",
+            blocking=entry.get("blocking"),
+        )
+        self.command = command
+        self.always_block = env.is_true(entry.get("always_block"))
+
+    def _argv_for(self, path):
+        has_placeholder = any("{file}" in token for token in self.command)
+        argv = [token.replace("{file}", path) for token in self.command]
+        if not has_placeholder:
+            argv.append(path)
+        return argv
+
+    def run(self, context, files):
+        issues = []
+        fixed = []
+        skipped = []
+        warned = []
+        if self.scoped == "repo":
+            try:
+                proc = subprocess.Popen(
+                    list(self.command),
+                    cwd=context.root,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+            except OSError as exc:
+                warned.append("command %r unavailable: %s" % (self.command[0], exc))
+                return CheckResult(
+                    issues=issues, fixed=fixed, skipped=skipped, warned=warned
+                )
+            out, err = proc.communicate()
+            if proc.returncode != 0:
+                output = (out or err).decode("utf-8", errors="replace").strip()
+                if not output:
+                    output = "exit code %s" % proc.returncode
+                issues.append(CheckIssue(".", 0, 0, self.id, output))
+            return CheckResult(issues=issues, fixed=fixed, skipped=skipped, warned=warned)
+        for path in files or []:
+            argv = self._argv_for(path)
+            try:
+                proc = subprocess.Popen(
+                    argv,
+                    cwd=context.root,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+            except OSError as exc:
+                warned.append("command %r unavailable: %s" % (self.command[0], exc))
+                break
+            out, err = proc.communicate()
+            if proc.returncode != 0:
+                output = (out or err).decode("utf-8", errors="replace").strip()
+                if not output:
+                    output = "exit code %s" % proc.returncode
+                issues.append(CheckIssue(path, 0, 0, self.id, output))
+        return CheckResult(issues=issues, fixed=fixed, skipped=skipped, warned=warned)
+
+
+class CheckContext(object):
+    def __init__(self, root, anchor, from_ref, to_ref, scope, config=None, echo=True):
+        self.root = root
+        self.anchor = anchor
+        self.from_ref = from_ref
+        self.to_ref = to_ref
+        self.scope = scope
+        self.config = config if config is not None else {}
+        self.echo = echo
+
+    def changed_lines(self, path):
+        """Changed line numbers for path, or None when the path is untracked (whole file) or scope lookup failed; pair with is_tracked()."""
+        try:
+            return self.scope.changed_lines(
+                self.anchor, path, self.from_ref, self.to_ref
+            )
+        except Exception:
+            return None
+
+    def is_tracked(self, path):
+        try:
+            return bool(self.scope.is_tracked(path))
+        except Exception:
+            return False
+
+    def note(self, text):
+        if self.echo:
+            print(text)
+
+
+class CheckIssue(object):
+    def __init__(self, path, line, column, code, message):
+        self.path = path
+        self.line = line
+        self.column = column
+        self.code = code
+        self.message = message
+
+    def format(self):
+        return "%s:%s:%s: %s %s" % (
+            self.path,
+            self.line,
+            self.column,
+            self.code,
+            self.message,
+        )
+
+
+class CheckResult(object):
+    def __init__(self, issues=None, fixed=None, skipped=None, warned=None):
+        self.issues = list(issues) if issues else []
+        self.fixed = list(fixed) if fixed else []
+        self.skipped = list(skipped) if skipped else []
+        self.warned = list(warned) if warned else []
+
+    def ok(self):
+        return not self.issues
+
+    def has_issues(self):
+        return bool(self.issues)
+
+
+def register(cls):
+    if not getattr(cls, "id", None):
+        raise ValueError("registered check class must define an id")
+    REGISTRY[cls.id] = cls
+    return cls
+
+
+def make_check(entry):
+    if not isinstance(entry, dict):
+        return None
+    if entry.get("type") == "external":
+        try:
+            return ExternalCheck(entry)
+        except ValueError:
+            return None
+    cls = REGISTRY.get(entry.get("id"))
+    if cls is None:
+        return None
+    try:
+        return cls().extend_config(entry)
+    except Exception:
+        return None

diffimpactscout/checks/eslint.py

@@ -0,0 +1,164 @@
+"""ESLint incremental check: reports only violations on lines the developer changed, and honors a saved baseline.
+
+Example: a no-unused-vars error on a line the developer added fails the
+guard, while the same error on an untouched upstream line is skipped.
+"""
+
+import json
+import os
+import subprocess
+
+from diffimpactscout.checks.base import (
+    Check,
+    CheckIssue,
+    CheckResult,
+    register,
+)
+
+
+def _normalize(path):
+    if path.startswith("./"):
+        return path[2:]
+    return path
+
+
+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 _load_baseline(root):
+    path = os.path.join(root, ".eslint_baseline.json")
+    try:
+        with open(path, "r") as fh:
+            data = json.load(fh)
+    except (OSError, ValueError):
+        return []
+    if isinstance(data, dict) and "results" in data:
+        data = data.get("results")
+    if isinstance(data, dict):
+        entries = []
+        for key, values in data.items():
+            if isinstance(values, list):
+                entries.append((_normalize(key), set(values)))
+        return entries
+    if not isinstance(data, list):
+        return []
+    entries = []
+    for item in data:
+        if not isinstance(item, dict):
+            continue
+        keys = set()
+        for message in item.get("messages") or []:
+            line = message.get("line")
+            column = message.get("column")
+            rule_id = message.get("ruleId")
+            if line and column and rule_id:
+                keys.add("%s:%s:%s" % (line, column, rule_id))
+        file_path = item.get("filePath")
+        if file_path:
+            entries.append((file_path, keys))
+    return entries
+
+
+def _path_matches(file_path, candidate):
+    if file_path == candidate:
+        return True
+    if file_path.endswith(os.sep + candidate):
+        return True
+    if file_path.endswith("/" + candidate):
+        return True
+    return False
+
+
+def _baseline_keys(baseline, root, path):
+    candidates = (path, _normalize(path), os.path.join(root, path))
+    for file_path, keys in baseline:
+        for candidate in candidates:
+            if _path_matches(file_path, candidate):
+                return keys
+    return set()
+
+
+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
+
+
+@register
+class EslintCheck(Check):
+    id = "eslint"
+    scoped = "lines"
+
+    def run(self, context, files):
+        issues = []
+        warned = []
+        baseline = _load_baseline(context.root)
+        for path in files or []:
+            changed = _changed_lines(context, path)
+            if changed is not None and not changed:
+                continue
+            try:
+                proc, out, _err = _run_npx(
+                    ["npx", "eslint", path, "--format", "json"],
+                    context.root,
+                )
+            except OSError as exc:
+                warned.append("npx eslint unavailable: %s" % exc)
+                break
+            if proc.returncode not in (0, 1):
+                warned.append(
+                    "npx eslint %s exited with code %s"
+                    % (path, proc.returncode)
+                )
+                continue
+            try:
+                data = json.loads(out.decode("utf-8", errors="replace"))
+            except ValueError:
+                continue
+            if isinstance(data, dict):
+                data = data.get("results")
+            if not isinstance(data, list):
+                continue
+            baseline_keys = _baseline_keys(baseline, context.root, path)
+            for file_result in data:
+                if not isinstance(file_result, dict):
+                    continue
+                for message in file_result.get("messages") or []:
+                    line = message.get("line")
+                    column = message.get("column")
+                    rule_id = message.get("ruleId")
+                    if changed is not None and line not in changed:
+                        continue
+                    if (
+                        line
+                        and column
+                        and rule_id
+                        and "%s:%s:%s" % (line, column, rule_id)
+                        in baseline_keys
+                    ):
+                        continue
+                    issues.append(
+                        CheckIssue(
+                            path,
+                            line or 0,
+                            column or 0,
+                            rule_id or self.id,
+                            message.get("message") or "",
+                        )
+                    )
+        return CheckResult(issues=issues, warned=warned)

diffimpactscout/checks/hygiene.py

@@ -0,0 +1,104 @@
+"""Auto-fixing checks for line endings, trailing whitespace, and a missing final newline.
+
+Example: a dev-changed file whose line ends with a trailing space is
+rewritten without it, while an upstream file with the same flaw is left
+alone.
+"""
+
+import os
+
+from diffimpactscout.checks.base import (
+    Check,
+    CheckResult,
+    register,
+)
+
+
+def fix_content(fixer, data):
+    if fixer == 'mixed-line-ending':
+        if b'\r' not in data:
+            return None
+        return data.replace(b'\r\n', b'\n').replace(b'\r', b'\n')
+    if fixer == 'end-of-file-fixer':
+        if not data:
+            return None
+        strip = data.rstrip(b'\n')
+        if data == strip:
+            return data + b'\n'
+        if len(data) - len(strip) > 1:
+            return strip + b'\n'
+        return None
+    if fixer == 'trailing-whitespace':
+        lines = data.split(b'\n')
+        new_lines = [line.rstrip(b' \t') for line in lines]
+        changed = new_lines != lines
+        while new_lines and not new_lines[-1]:
+            new_lines.pop()
+            changed = True
+        out = b'\n'.join(new_lines)
+        if out:
+            out += b'\n'
+        return out if out != data and changed else None
+    return None
+
+
+class _HygieneCheck(Check):
+    scoped = "files"
+    fixer = None
+
+    def run(self, context, files):
+        fixed = []
+        warned = []
+        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
+            new = fix_content(self.fixer, data)
+            if new is not None:
+                try:
+                    with open(fn, 'wb') as fh:
+                        written = fh.write(new)
+                except OSError as exc:
+                    warned.append("could not write %s: %s" % (path, exc))
+                    continue
+                if written != len(new):
+                    warned.append(
+                        "partial write to %s (%d of %d bytes)"
+                        % (path, written, len(new))
+                    )
+                    continue
+                fixed.append(path)
+        return CheckResult(fixed=fixed, warned=warned)
+
+
+@register
+class MixedLineEndingCheck(_HygieneCheck):
+    id = "hygiene/mixed-line-ending"
+    fixer = "mixed-line-ending"
+
+    def extend_config(self, entry):
+        super(MixedLineEndingCheck, self).extend_config(entry)
+        mode = "lf"
+        for arg in self.args:
+            if arg.startswith("--fix="):
+                mode = arg[len("--fix="):]
+        if mode != "lf":
+            raise ValueError(
+                "mixed-line-ending only supports --fix=lf (got --fix=%s)" % mode
+            )
+        return self
+
+
+@register
+class TrailingWhitespaceCheck(_HygieneCheck):
+    id = "hygiene/trailing-whitespace"
+    fixer = "trailing-whitespace"
+
+
+@register
+class EndOfFileFixerCheck(_HygieneCheck):
+    id = "hygiene/end-of-file-fixer"
+    fixer = "end-of-file-fixer"