slopgate-cli 0.1.0__py3-none-any.whl

slopgate/diff_parser.py

@@ -0,0 +1,186 @@
+"""
+Git Unified Diff Parser.
+Extracts modified files, hunks, line mappings, and added/removed fragments.
+"""
+
+import ast
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+
+@dataclass
+class Hunk:
+    added: List[Tuple[int, str]] = field(default_factory=list)
+    removed: List[Tuple[int, str]] = field(default_factory=list)
+
+
+@dataclass
+class FileDiff:
+    old_path: Optional[str]
+    new_path: Optional[str]
+    is_deleted: bool = False
+    is_new: bool = False
+    added_lines: List[Tuple[int, str]] = field(default_factory=list)
+    removed_lines: List[Tuple[int, str]] = field(default_factory=list)
+    hunks: List[Hunk] = field(default_factory=list)
+    raw_diff: str = ""
+
+    @property
+    def target_path(self) -> str:
+        return self.new_path or self.old_path or "unknown"
+
+    @property
+    def is_python(self) -> bool:
+        return self.target_path.endswith(".py")
+
+    @property
+    def is_test_file(self) -> bool:
+        path = self.target_path.lower()
+        parts = Path(path).parts
+        return (
+            any(p in ("tests", "test", "__tests__") for p in parts)
+            or Path(path).name.startswith("test_")
+            or Path(path).name.endswith("_test.py")
+        )
+
+    @property
+    def is_doc_file(self) -> bool:
+        path = self.target_path.lower()
+        return path.endswith((".md", ".rst", ".txt", ".adoc", ".markdown"))
+
+
+def _unquote(path: str) -> str:
+    """Git wraps paths with spaces or special characters in double quotes."""
+    quoted = len(path) >= 2 and path[0] == '"' and path[-1] == '"'
+    if not quoted:
+        return path
+    inner = path[1:-1]
+    try:
+        # Git uses C-style escapes; octal sequences are UTF-8 bytes.
+        decoded = ast.literal_eval('"' + inner + '"')
+        return decoded.encode("latin-1", "replace").decode("utf-8", "replace")
+    except (ValueError, SyntaxError, UnicodeEncodeError):
+        return inner
+
+
+def _clean_path(path: str) -> Optional[str]:
+    path = _unquote(path.strip())
+    if path == "/dev/null":
+        return None
+    if path.startswith("a/") or path.startswith("b/"):
+        return path[2:]
+    return path
+
+
+class DiffParser:
+    """Parses standard unified git diffs into structured FileDiff objects."""
+
+    HUNK_RE = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+
+    @classmethod
+    def _header_paths(cls, line: str) -> Tuple[Optional[str], Optional[str]]:
+        rest = line[len("diff --git ") :]
+        # Quoted tokens (spaces/C-escapes) stay intact so _unquote can decode them
+        parts = re.findall(r'"(?:[^"\\]|\\.)*"|\S+', rest)
+        if len(parts) < 2:
+            return None, None
+        return _clean_path(parts[0]), _clean_path(parts[1])
+
+    @classmethod
+    def parse(cls, diff_text: str) -> List[FileDiff]:
+        files: List[FileDiff] = []
+        current_file: Optional[FileDiff] = None
+        current_hunk: Optional[Hunk] = None
+        old_line = 0
+        new_line = 0
+
+        lines = diff_text.splitlines()
+        skip_combined = False
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+
+            if line.startswith("diff --git "):
+                if current_file:
+                    files.append(current_file)
+                old_p, new_p = cls._header_paths(line)
+                current_file = FileDiff(
+                    old_path=old_p, new_path=new_p, raw_diff=line + "\n"
+                )
+                current_hunk = None
+                skip_combined = False
+                i += 1
+                continue
+
+            if current_file is None:
+                # Diff text without 'diff --git' header, try parsing '---' and '+++'
+                if line.startswith("--- "):
+                    old_p = _clean_path(line[4:])
+                    i += 1
+                    new_p = None
+                    if i < len(lines) and lines[i].startswith("+++ "):
+                        new_p = _clean_path(lines[i][4:])
+                        i += 1
+                    current_file = FileDiff(old_path=old_p, new_path=new_p)
+                    continue
+                i += 1
+                continue
+
+            current_file.raw_diff += line + "\n"
+
+            if line.startswith("@@@"):
+                # Combined (merge) diffs use two-column prefixes; parsing them as
+                # regular hunks would report garbage line numbers.
+                skip_combined = True
+                i += 1
+                continue
+            if skip_combined:
+                i += 1
+                continue
+
+            if line.startswith("new file mode"):
+                current_file.is_new = True
+            elif line.startswith("deleted file mode"):
+                current_file.is_deleted = True
+            elif line.startswith("--- "):
+                path = _clean_path(line[4:])
+                if path:
+                    current_file.old_path = path
+            elif line.startswith("+++ "):
+                path = _clean_path(line[4:])
+                if path:
+                    current_file.new_path = path
+            elif line.startswith("@@"):
+                m = cls.HUNK_RE.match(line)
+                if m:
+                    old_line = int(m.group(1))
+                    new_line = int(m.group(3))
+                current_hunk = Hunk()
+                current_file.hunks.append(current_hunk)
+            elif line.startswith("+") and not line.startswith("+++"):
+                if current_hunk is None:
+                    # Fragments without hunk headers still need a bucket
+                    current_hunk = Hunk()
+                    current_file.hunks.append(current_hunk)
+                current_file.added_lines.append((new_line, line[1:]))
+                current_hunk.added.append((new_line, line[1:]))
+                new_line += 1
+            elif line.startswith("-") and not line.startswith("---"):
+                if current_hunk is None:
+                    current_hunk = Hunk()
+                    current_file.hunks.append(current_hunk)
+                current_file.removed_lines.append((old_line, line[1:]))
+                current_hunk.removed.append((old_line, line[1:]))
+                old_line += 1
+            elif line.startswith(" "):
+                old_line += 1
+                new_line += 1
+
+            i += 1
+
+        if current_file:
+            files.append(current_file)
+
+        return files

slopgate/engine.py

@@ -0,0 +1,266 @@
+"""
+Core SlopGate Audit Engine.
+Orchestrates AST tamper checks, phantom symbol detection, diff metrics,
+and maintainer verdict generation.
+"""
+
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple
+
+from slopgate.ast_tamper import AstTamperAnalyzer, TamperKind
+from slopgate.diff_parser import DiffParser, FileDiff
+from slopgate.phantom import PhantomDetector
+
+
+class Severity(str, Enum):
+    INFO = "INFO"
+    WARNING = "WARNING"
+    BLOCKED = "BLOCKED"
+
+
+@dataclass
+class Violation:
+    rule_id: str
+    severity: Severity
+    file_path: str
+    line_number: int
+    title: str
+    message: str
+    snippet: Optional[str] = None
+
+
+@dataclass
+class DiffMetrics:
+    total_added: int = 0
+    total_removed: int = 0
+    code_added: int = 0
+    test_added: int = 0
+    doc_added: int = 0
+    files_changed: int = 0
+    slop_ratio: float = 0.0  # ratio of doc/comment lines to real logic lines
+    doc_heaviest_path: str = ""
+
+
+@dataclass
+class AuditReport:
+    status: Severity
+    violations: List[Violation] = field(default_factory=list)
+    metrics: DiffMetrics = field(default_factory=DiffMetrics)
+    repro_verified: bool = False
+    summary: str = ""
+
+    @property
+    def is_clean(self) -> bool:
+        return self.status == Severity.INFO
+
+    @property
+    def not_blocked(self) -> bool:
+        return self.status != Severity.BLOCKED
+
+
+QUOTE_DELIMS = ('"""', "'''")
+
+
+def classify_added_python_lines(lines: List[Tuple[int, str]]) -> Tuple[int, int]:
+    """Splits added Python lines into (doc/comment, executable) counts.
+
+    Tracks multi-line block strings so docstring bodies count as docs, not code.
+    """
+    doc = 0
+    code = 0
+    block: Optional[str] = None
+    for _, line in lines:
+        stripped = line.strip()
+        if block:
+            doc += 1
+            if block in stripped:
+                block = None
+            continue
+        if not stripped:
+            continue
+        if stripped.startswith("#"):
+            doc += 1
+            continue
+        # Drop a string prefix (r""" / f""" / rb""") before delimiter detection
+        literal = re.sub(r"^[rRbBuUfF]{0,2}(?=['\"])", "", stripped)
+        for delim in QUOTE_DELIMS:
+            if literal.startswith(delim):
+                doc += 1
+                if literal.count(delim) == 1:
+                    block = delim
+                break
+        else:
+            code += 1
+    return doc, code
+
+
+class AuditEngine:
+    """Orchestrates all SlopGate security and code integrity checks."""
+
+    def __init__(self, repo_root: Optional[Path] = None):
+        self.repo_root = repo_root or Path.cwd()
+        self.declared_deps: Set[str] = PhantomDetector.get_declared_dependencies(
+            self.repo_root
+        )
+
+    def audit_diff(self, diff_text: str) -> AuditReport:
+        files = DiffParser.parse(diff_text)
+        violations: List[Violation] = []
+        metrics = self._compute_metrics(files)
+
+        has_code_change = False
+        has_test_change = False
+        tampered_test = False
+
+        for f in files:
+            # A deleted test file is not a reproduction test
+            if f.is_test_file and not f.is_deleted:
+                has_test_change = True
+                # Run Test Tampering Inspection
+                incidents = AstTamperAnalyzer.analyze_file(f)
+                for inc in incidents:
+                    tampered_test = True
+                    sev = (
+                        Severity.BLOCKED
+                        if inc.kind
+                        in (
+                            TamperKind.ASSERT_DELETED,
+                            TamperKind.TRY_EXCEPT_BYPASS,
+                            TamperKind.TEST_SKIPPED,
+                        )
+                        else Severity.WARNING
+                    )
+
+                    violations.append(
+                        Violation(
+                            rule_id=f"SG-{inc.kind.value}",
+                            severity=sev,
+                            file_path=inc.file_path,
+                            line_number=inc.line_number,
+                            title=inc.kind.value.replace("_", " ").title(),
+                            message=inc.message,
+                            snippet=inc.snippet,
+                        )
+                    )
+            elif f.is_python and f.added_lines:
+                has_code_change = True
+
+            # Run Phantom Symbol Inspection on all Python files
+            if f.is_python:
+                phantoms = PhantomDetector.analyze_file(f, self.declared_deps)
+                for ph in phantoms:
+                    violations.append(
+                        Violation(
+                            rule_id=f"SG-{ph.kind.value}",
+                            severity=Severity.BLOCKED,
+                            file_path=ph.file_path,
+                            line_number=ph.line_number,
+                            title=ph.kind.value.replace("_", " ").title(),
+                            message=ph.message,
+                            snippet=f"symbol: {ph.symbol}",
+                        )
+                    )
+
+        # Repro Test Check: a test file must have been touched and not tampered with
+        repro_verified = has_code_change and has_test_change and not tampered_test
+        if has_code_change and not repro_verified:
+            changed_prod = next(
+                (
+                    f
+                    for f in files
+                    if f.is_python
+                    and not f.is_test_file
+                    and not f.is_deleted
+                    and f.added_lines
+                ),
+                None,
+            )
+            violations.append(
+                Violation(
+                    rule_id="SG-MISSING_TEST_REPRO",
+                    severity=Severity.WARNING,
+                    file_path=changed_prod.target_path if changed_prod else "diff",
+                    line_number=1,
+                    title="Missing Reproduction Test",
+                    message="PR modifies production logic without adding a trustworthy test case.",
+                    snippet=None,
+                )
+            )
+
+        # Slop Ratio Check (e.g. 50 lines of explanatory comments with 1 line of logic)
+        if (
+            metrics.slop_ratio > 4.0
+            and metrics.doc_added >= 30
+            and 0 < metrics.code_added < 5
+        ):
+            violations.append(
+                Violation(
+                    rule_id="SG-SLOP_BLOAT",
+                    severity=Severity.WARNING,
+                    file_path=metrics.doc_heaviest_path or "diff",
+                    line_number=1,
+                    title="Disproportionate Comment/Doc Bloat",
+                    message=f"PR contains high slop-to-logic ratio ({metrics.slop_ratio:.1f}x doc additions vs executable code).",
+                    snippet=f"+{metrics.doc_added} doc lines vs +{metrics.code_added} code lines",
+                )
+            )
+
+        # Determine overall status
+        status = Severity.INFO
+        if any(v.severity == Severity.BLOCKED for v in violations):
+            status = Severity.BLOCKED
+        elif any(v.severity == Severity.WARNING for v in violations):
+            status = Severity.WARNING
+
+        summary = self._generate_summary(status, violations)
+        return AuditReport(
+            status=status,
+            violations=violations,
+            metrics=metrics,
+            repro_verified=repro_verified,
+            summary=summary,
+        )
+
+    def _compute_metrics(self, files: List[FileDiff]) -> DiffMetrics:
+        metrics = DiffMetrics(files_changed=len(files))
+        doc_by_file: Dict[str, int] = {}
+        for f in files:
+            added = len(f.added_lines)
+            removed = len(f.removed_lines)
+            metrics.total_added += added
+            metrics.total_removed += removed
+
+            if f.is_test_file:
+                metrics.test_added += added
+            elif f.is_doc_file:
+                metrics.doc_added += added
+                doc_by_file[f.target_path] = added
+            elif f.is_python:
+                doc, code = classify_added_python_lines(f.added_lines)
+                metrics.doc_added += doc
+                metrics.code_added += code
+                doc_by_file[f.target_path] = doc
+
+        if doc_by_file:
+            metrics.doc_heaviest_path = max(doc_by_file, key=lambda p: doc_by_file[p])
+
+        if metrics.code_added > 0:
+            metrics.slop_ratio = metrics.doc_added / metrics.code_added
+        else:
+            metrics.slop_ratio = float(metrics.doc_added)
+
+        return metrics
+
+    def _generate_summary(self, status: Severity, violations: List[Violation]) -> str:
+        if status == Severity.INFO and not violations:
+            return "✅ SlopGate Passed: All test assertions intact, no hallucinated symbols detected."
+
+        blocked_count = sum(1 for v in violations if v.severity == Severity.BLOCKED)
+        warning_count = sum(1 for v in violations if v.severity == Severity.WARNING)
+
+        if status == Severity.BLOCKED:
+            return f"⛔ SlopGate Blocked: Found {blocked_count} critical integrity violation(s) (test tampering / phantom symbols)."
+        return f"⚠️ SlopGate Warning: Found {warning_count} non-blocking notice(s)."

slopgate/fragment.py

@@ -0,0 +1,102 @@
+"""
+Partial AST for the added lines of a diff.
+
+Diff fragments are rarely valid modules (a hunk can start mid-function), so the
+parser retries the fragment wrapped in a stub function and reports the line
+offset so callers can map AST line numbers back to real file lines.
+"""
+
+import ast
+import textwrap
+from typing import List, Optional, Set, Tuple
+
+from slopgate.diff_parser import FileDiff
+
+QUOTE_DELIMS = ('"""', "'''")
+
+
+def _lexical_string_lines(text: str) -> Set[int]:
+    """Line ranges of complete triple-quoted strings in unparseable text.
+
+    Only spans with a matching close count, so a hunk starting on a docstring
+    *closing* line cannot swallow the rest of the hunk.
+    """
+    covered: Set[int] = set()
+    opened: Optional[str] = None
+    opened_at = 0
+    for lineno, line in enumerate(text.splitlines(), start=1):
+        for delim in QUOTE_DELIMS:
+            start = 0
+            while True:
+                pos = line.find(delim, start)
+                if pos < 0:
+                    break
+                start = pos + 3
+                if pos > 0 and line[pos - 1] == "\\":
+                    continue
+                if opened is None:
+                    opened, opened_at = delim, lineno
+                elif opened == delim:
+                    covered.update(range(opened_at, lineno + 1))
+                    opened = None
+    return covered
+
+
+class Fragment:
+    def __init__(self, file_diff: FileDiff):
+        self.text = "\n".join(line for _, line in file_diff.added_lines)
+        self.line_map: List[int] = [ln for ln, _ in file_diff.added_lines]
+
+    @classmethod
+    def from_lines(cls, lines: List[Tuple[int, str]]) -> "Fragment":
+        fragment = cls.__new__(cls)
+        fragment.text = "\n".join(line for _, line in lines)
+        fragment.line_map = [ln for ln, _ in lines]
+        return fragment
+
+    def real_line(self, lineno: int, offset: int = 0) -> int:
+        """Maps an AST line number inside the fragment to the real file line."""
+        idx = lineno - 1 - offset
+        if 0 <= idx < len(self.line_map):
+            return self.line_map[idx]
+        return self.line_map[0] if self.line_map else 1
+
+    def parse(self) -> Tuple[Optional[ast.Module], int]:
+        """Returns (tree, offset). offset is 1 when the stub wrapper was added."""
+        dedented = textwrap.dedent(self.text)
+        try:
+            return ast.parse(dedented), 0
+        except SyntaxError:
+            pass
+        try:
+            return ast.parse(
+                "def _fragment():\n" + textwrap.indent(dedented, "    ")
+            ), 1
+        except SyntaxError:
+            return None, 0
+
+    def string_lines(
+        self, tree: Optional[ast.Module] = None, offset: Optional[int] = None
+    ) -> Set[int]:
+        """Fragment line numbers (1-based) sitting inside a multi-line string.
+
+        Raw-line fallbacks use this so docstrings and fixtures are not scanned
+        for API calls or assertions. Empty when the fragment does not parse.
+        """
+        if tree is None:
+            tree, parsed_offset = self.parse()
+            offset = parsed_offset
+        offset = offset or 0
+        if tree is None:
+            return _lexical_string_lines(self.text)
+
+        covered: Set[int] = set()
+        for node in ast.walk(tree):
+            is_str = (
+                isinstance(node, ast.Constant) and isinstance(node.value, str)
+            ) or isinstance(node, ast.JoinedStr)
+            begin = getattr(node, "lineno", 0) - offset
+            end = getattr(node, "end_lineno", begin) - offset
+            if is_str and end > begin:
+                covered.update(range(begin, end + 1))
+        return covered