slopmop 2.3.0__tar.gz → 2.3.2__tar.gz

{slopmop-2.3.0/slopmop.egg-info → slopmop-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slopmop
-Version: 2.3.0
+Version: 2.3.2
 Summary: Quality gates for AI-assisted codebases — catch the slop LLMs leave behind.
 Author: ScienceIsNeato
 License: Apache-2.0
@@ -102,7 +102,7 @@ It is purposefully opinionated, as structure begets adherence to best practices.
 
 ## Project Status
 
-slop-mop is at version 2.3.0. The current public policy surface for release and
+slop-mop is at version 2.3.2. The current public policy surface for release and
 stability expectations lives here:
 
 - [DOCS/COMPATIBILITY.md](https://github.com/ScienceIsNeato/slop-mop/blob/main/DOCS/COMPATIBILITY.md)

{slopmop-2.3.0 → slopmop-2.3.2}/README.md

@@ -27,7 +27,7 @@ It is purposefully opinionated, as structure begets adherence to best practices.
 
 ## Project Status
 
-slop-mop is at version 2.3.0. The current public policy surface for release and
+slop-mop is at version 2.3.2. The current public policy surface for release and
 stability expectations lives here:
 
 - [DOCS/COMPATIBILITY.md](https://github.com/ScienceIsNeato/slop-mop/blob/main/DOCS/COMPATIBILITY.md)

{slopmop-2.3.0 → slopmop-2.3.2}/pyproject.toml

@@ -134,6 +134,8 @@ exclude = ["tests*"]
     "templates/copilot/.copilot/skills/slopmop/*",
     "templates/copilot/.github/*",
     "templates/cursor/.cursor/rules/*",
+    "templates/gemini/.gemini/skills/slopmop/*",
+    "templates/gemini/GEMINI.md",
     "templates/roo/.roo/rules/*",
     "templates/windsurf/.windsurf/rules/*",
 ]

{slopmop-2.3.0 → slopmop-2.3.2}/slopmop/_version.py

@@ -11,4 +11,4 @@ automatically. Everything else derives from it:
   from this value, so a mismatch can never be merged.
 """
 
-__version__ = "2.3.0"
+__version__ = "2.3.2"

{slopmop-2.3.0 → slopmop-2.3.2}/slopmop/agent_install/registry.py

@@ -57,6 +57,11 @@ TARGETS: Dict[str, InstallTarget] = {
         display_name="Google Antigravity workspace rules",
         template_dir="antigravity",
     ),
+    "gemini": InstallTarget(
+        key="gemini",
+        display_name="Gemini CLI instructions + skills",
+        template_dir="gemini",
+    ),
 }
 
 ALL_KEYS: Tuple[str, ...] = tuple(TARGETS.keys())

slopmop-2.3.2/slopmop/agent_install/templates/gemini/.gemini/skills/slopmop/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: slopmop
+description: >-
+  Substitutes pytest, gh, mypy, black, and every other tool in this
+  repo with a single `sm` CLI.  Never run the underlying tools
+  directly — `sm swab` for fast iteration, `sm scour` before a PR,
+  `sm buff` after CI or review feedback, `sm doctor` when the
+  environment looks broken, `sm refit` for onboarding existing repos,
+  `sm sail` when unsure what to do next.
+  Use `sm barnacle file` (never `gh issue create`) when slop-mop
+  itself causes tool friction — the barnacle CLI auto-applies labels
+  and targets the right repo.
+---
+
+{{CORE}}

slopmop-2.3.2/slopmop/agent_install/templates/roo/.roo/rules/01-slopmop.md

@@ -0,0 +1 @@
+{{CORE}}

slopmop-2.3.2/slopmop/checks/python/_host_formatter.py

@@ -0,0 +1,74 @@
+"""Detect the Python formatter already configured by the host project.
+
+Used by sloppy-formatting.py to defer to the project's own formatter
+instead of imposing slop-mop's defaults (autoflake + black + isort).
+
+When a project already pins ruff (or black), slop-mop running a different
+formatter produces churn: the gate-fix commit ends up in a style that the
+host's CI then immediately undoes. Detecting the host formatter and using
+it keeps the output in sync with what CI expects.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+
+def detect_host_python_formatter(project_root: str) -> Optional[str]:
+    """Return the formatter the project has configured, or None.
+
+    Return values:
+      'ruff'  — project configured ruff; use ``ruff format`` + ``ruff check``
+      'black' — project configured black explicitly (no ruff)
+      None    — no host formatter detected; caller should use defaults
+
+    Detection priority:
+      1. pyproject.toml [tool.ruff.*] → 'ruff'
+      2. .ruff.toml or ruff.toml presence → 'ruff'
+      3. .pre-commit-config.yaml containing a ruff hook → 'ruff'
+      4. pyproject.toml [tool.black] (no ruff) → 'black'
+      5. Nothing found → None
+    """
+    root = Path(project_root)
+    pyproject_has_black = False
+
+    # 1. pyproject.toml
+    pyproject = root / "pyproject.toml"
+    if pyproject.exists():
+        try:
+            content = pyproject.read_text(encoding="utf-8")
+            # Matches [tool.ruff], [tool.ruff.format], [tool.ruff.lint], etc.
+            if re.search(r"^\s*\[tool\.ruff[.\]]", content, re.MULTILINE):
+                return "ruff"
+            # Matches [tool.black] or [tool.black.*] — defer the return so that
+            # a standalone ruff config or pre-commit ruff hook can still win
+            # (e.g. a project that migrated from black to ruff but kept the
+            # legacy [tool.black] section for history).
+            if re.search(r"^\s*\[tool\.black[.\]]", content, re.MULTILINE):
+                pyproject_has_black = True
+        except OSError:
+            pass  # Unreadable pyproject — fall through
+
+    # 2. Standalone ruff config files (checked before honouring pyproject black)
+    if (root / ".ruff.toml").exists() or (root / "ruff.toml").exists():
+        return "ruff"
+
+    # 3. .pre-commit-config.yaml with a ruff hook
+    precommit = root / ".pre-commit-config.yaml"
+    if precommit.exists():
+        try:
+            content = precommit.read_text(encoding="utf-8")
+            # Match `- id: ruff` or `- id: ruff-format` (actual hook IDs),
+            # not URLs or comments that merely mention "ruff".
+            if re.search(r"^\s*-\s+id:\s+ruff", content, re.MULTILINE):
+                return "ruff"
+        except OSError:
+            pass
+
+    # 4. Fall back to black if we saw it in pyproject but no ruff signal won
+    if pyproject_has_black:
+        return "black"
+
+    return None

{slopmop-2.3.0 → slopmop-2.3.2}/slopmop/checks/python/lint_format.py

@@ -1,10 +1,15 @@
 """Python lint and format check using black, isort, autoflake, and flake8.
 
 This check:
-1. Auto-removes unused imports with autoflake
-2. Auto-fixes formatting with black
-3. Auto-fixes import order with isort
+1. Auto-removes unused imports with autoflake (or ruff when configured)
+2. Auto-fixes formatting with black (or ruff when configured)
+3. Auto-fixes import order with isort (or ruff when configured)
 4. Checks for critical lint errors with flake8
+
+When the project already pins ruff (detected via pyproject.toml, ruff.toml,
+or .pre-commit-config.yaml), the gate defers to ruff format + ruff check
+instead of running black/isort/autoflake.  This prevents formatting churn
+when the host's CI would immediately reformat slop-mop's output.
 """
 
 import os
@@ -21,7 +26,9 @@ from slopmop.checks.base import (
     RemediationChurn,
     ToolContext,
 )
+from slopmop.checks.constants import COMMAND_NOT_FOUND
 from slopmop.checks.mixins import PythonCheckMixin
+from slopmop.checks.python._host_formatter import detect_host_python_formatter
 from slopmop.constants import ISSUES_FOUND_TEMPLATE
 from slopmop.core.result import CheckResult, CheckStatus, Finding, FindingLevel
 
@@ -33,6 +40,7 @@ _FLAKE8_RE = re.compile(r"^(.+?):(\d+):(\d+): (\w+) (.+)$")
 # a string (real formatting failure) so that run() can report the
 # skip without treating it as a pass.
 _BLACK_SKIPPED = "__BLACK_SKIPPED_BROKEN_INSTALL__"
+_RUFF_SKIPPED = "__RUFF_SKIPPED_NOT_INSTALLED__"
 
 _DEFAULT_EXCLUDE_DIRS = [
     "venv",
@@ -51,6 +59,13 @@ _DEFAULT_EXCLUDE_DIRS = [
     "ephemeral",
 ]
 
+# Black --extend-exclude regex built from _DEFAULT_EXCLUDE_DIRS so that
+# recursive runs on a top-level package (e.g. "enterprise") don't descend
+# into nested migration dirs like enterprise/migrations/versions/. (#263)
+_BLACK_EXTEND_EXCLUDE = (
+    r"/(" + "|".join(re.escape(d) for d in _DEFAULT_EXCLUDE_DIRS) + r")/"
+)
+
 
 def _is_import_error(output: str) -> bool:
     """True when output looks like a Python import/module-not-found error.
@@ -93,7 +108,7 @@ class PythonLintFormatCheck(BaseCheck, PythonCheckMixin):
     """
 
     tool_context = ToolContext.SM_TOOL
-    required_tools = ["black", "isort", "autoflake", "flake8"]
+    required_tools = ["black", "isort", "autoflake", "flake8", "ruff"]
     role = CheckRole.FOUNDATION
     remediation_churn = RemediationChurn.DOWNSTREAM_CHANGES_VERY_UNLIKELY
     is_formatting_gate = True
@@ -128,8 +143,36 @@ class PythonLintFormatCheck(BaseCheck, PythonCheckMixin):
                 description="Maximum line length for black",
                 permissiveness="lower_is_stricter",
             ),
+            ConfigField(
+                name="formatter",
+                field_type="string",
+                default="auto",
+                choices=["auto", "ruff", "black", "none"],
+                description=(
+                    "Python formatter to use. Options: 'auto' (detect from project "
+                    "config — default), 'ruff' (always use ruff format + ruff check), "
+                    "'black' (always use autoflake + black + isort), 'none' (skip "
+                    "formatting entirely — flake8 syntax checks still run). "
+                    "Auto-detection checks pyproject.toml, .ruff.toml, and "
+                    ".pre-commit-config.yaml."
+                ),
+            ),
         ]
 
+    def _effective_formatter(self, project_root: str) -> Optional[str]:
+        """Return 'ruff', 'black', or None (use black defaults).
+
+        Respects an explicit 'formatter' config override; falls back to
+        auto-detection via the project's own config files.
+        """
+        override = self.config.get("formatter")
+        if override == "none":
+            return "none"
+        if override in ("ruff", "black"):
+            return override
+        # 'auto' or unset: detect from project
+        return detect_host_python_formatter(project_root)
+
     def is_applicable(self, project_root: str) -> bool:
         return self.is_python_project(project_root)
 
@@ -137,7 +180,46 @@ class PythonLintFormatCheck(BaseCheck, PythonCheckMixin):
         return True
 
     def auto_fix(self, project_root: str) -> bool:
-        """Auto-fix formatting issues with autoflake, black, and isort."""
+        """Auto-fix formatting issues.
+
+        Defers to the project's own formatter when one is configured
+        (ruff), falling back to autoflake + black + isort otherwise.
+        """
+        formatter = self._effective_formatter(project_root)
+        if formatter == "none":
+            return False
+        if formatter == "ruff":
+            return self._auto_fix_ruff(project_root)
+        return self._auto_fix_black(project_root)
+
+    def _auto_fix_ruff(self, project_root: str) -> bool:
+        """Format with ruff — defers to the project's own ruff config."""
+        fixed = False
+
+        # ruff format replaces black
+        result = self._run_command(
+            ["ruff", "format", "."],
+            cwd=project_root,
+            timeout=60,
+        )
+        if result.success:
+            fixed = True
+
+        # ruff check --fix --select I replaces isort; F401 replaces autoflake.
+        # --select overrides pyproject config for this invocation so we touch
+        # only style (not logic-altering rules).
+        result = self._run_command(
+            ["ruff", "check", "--fix", "--select", "I,F401", "."],
+            cwd=project_root,
+            timeout=60,
+        )
+        if result.success:
+            fixed = True
+
+        return fixed
+
+    def _auto_fix_black(self, project_root: str) -> bool:
+        """Format with autoflake + black + isort (slop-mop defaults)."""
         fixed = False
 
         # Find Python source directories to format
@@ -161,13 +243,16 @@ class PythonLintFormatCheck(BaseCheck, PythonCheckMixin):
         if result.success:
             fixed = True
 
-        # Run black on each target
+        # Run black on each target.  --extend-exclude prevents recursive
+        # descent into nested migration/alembic dirs (#263).
         for target in targets:
             result = self._run_command(
                 [
                     "black",
                     "--line-length",
                     "88",
+                    "--extend-exclude",
+                    _BLACK_EXTEND_EXCLUDE,
                     target,
                 ],
                 cwd=project_root,
@@ -207,30 +292,63 @@ class PythonLintFormatCheck(BaseCheck, PythonCheckMixin):
         return targets
 
     def run(self, project_root: str) -> CheckResult:
-        """Run lint and format checks."""
+        """Run lint and format checks.
+
+        Uses ruff when the project has it configured; black/isort otherwise.
+        Flake8 runs in both cases for critical syntax/undefined-name errors.
+        """
         start_time = time.time()
+        formatter = self._effective_formatter(project_root)
         issues: List[str] = []
         output_parts: List[str] = []
 
-        # Check 1: Black formatting
-        black_result = self._check_black(project_root)
-        if black_result == _BLACK_SKIPPED:
-            output_parts.append("Black: ⚠️ Skipped (broken installation)")
-        elif black_result:
-            issues.append(black_result)
-            output_parts.append(f"Black: {black_result}")
+        if formatter == "none":
+            output_parts.append("Formatting skipped (formatter: none)")
+            fix_hint = "Run: flake8 --select=E9,F63,F7,F82,F401 . to check syntax"
+        elif formatter == "ruff":
+            # Check 1: ruff format
+            fmt_result = self._check_ruff_format(project_root)
+            if fmt_result == _RUFF_SKIPPED:
+                output_parts.append("Ruff format: ⚠️ Skipped (ruff not installed)")
+            elif fmt_result:
+                issues.append(fmt_result)
+                output_parts.append(f"Ruff format: {fmt_result}")
+            else:
+                output_parts.append("Ruff format: ✅ Formatting OK")
+
+            # Check 2: ruff import order
+            import_result = self._check_ruff_imports(project_root)
+            if import_result == _RUFF_SKIPPED:
+                output_parts.append("Ruff imports: ⚠️ Skipped (ruff not installed)")
+            elif import_result:
+                issues.append(import_result)
+                output_parts.append(f"Ruff imports: {import_result}")
+            else:
+                output_parts.append("Ruff imports: ✅ Import order OK")
+
+            fix_hint = "Run: ruff format . && ruff check --fix --select I,F401 ."
         else:
-            output_parts.append("Black: ✅ Formatting OK")
-
-        # Check 2: Isort imports
-        isort_result = self._check_isort(project_root)
-        if isort_result:
-            issues.append(isort_result)
-            output_parts.append(f"Isort: {isort_result}")
-        else:
-            output_parts.append("Isort: ✅ Import order OK")
-
-        # Check 3: Flake8 critical errors
+            # Check 1: Black formatting
+            black_result = self._check_black(project_root)
+            if black_result == _BLACK_SKIPPED:
+                output_parts.append("Black: ⚠️ Skipped (broken installation)")
+            elif black_result:
+                issues.append(black_result)
+                output_parts.append(f"Black: {black_result}")
+            else:
+                output_parts.append("Black: ✅ Formatting OK")
+
+            # Check 2: Isort imports
+            isort_result = self._check_isort(project_root)
+            if isort_result:
+                issues.append(isort_result)
+                output_parts.append(f"Isort: {isort_result}")
+            else:
+                output_parts.append("Isort: ✅ Import order OK")
+
+            fix_hint = "Run: black . && isort . to auto-fix formatting"
+
+        # Check 3: Flake8 critical errors (always)
         flake8_result, flake8_findings = self._check_flake8(project_root)
         if flake8_result:
             issues.append(flake8_result)
@@ -242,7 +360,6 @@ class PythonLintFormatCheck(BaseCheck, PythonCheckMixin):
 
         if issues:
             msg = ISSUES_FOUND_TEMPLATE.format(count=len(issues))
-            # Prefer flake8_findings if available; if none, use generic message
             final_findings = (
                 flake8_findings
                 if flake8_findings
@@ -253,7 +370,7 @@ class PythonLintFormatCheck(BaseCheck, PythonCheckMixin):
                 duration=duration,
                 output="\n".join(output_parts),
                 error=msg,
-                fix_suggestion="Run: black . && isort . to auto-fix formatting",
+                fix_suggestion=fix_hint,
                 findings=final_findings,
             )
 
@@ -263,6 +380,40 @@ class PythonLintFormatCheck(BaseCheck, PythonCheckMixin):
             output="\n".join(output_parts),
         )
 
+    def _check_ruff_format(self, project_root: str) -> Optional[str]:
+        """Check ruff formatting (equivalent of black --check)."""
+        result = self._run_command(
+            ["ruff", "format", "--check", "."],
+            cwd=project_root,
+            timeout=60,
+        )
+        if not result.success:
+            output = (result.output or "").strip()
+            if COMMAND_NOT_FOUND in output:
+                return _RUFF_SKIPPED
+            return output or "Ruff format check failed"
+        return None
+
+    def _check_ruff_imports(self, project_root: str) -> Optional[str]:
+        """Check import order with ruff (equivalent of isort --check-only)."""
+        result = self._run_command(
+            ["ruff", "check", "--select", "I", "."],
+            cwd=project_root,
+            timeout=60,
+        )
+        if not result.success:
+            output = (result.output or "").strip()
+            if COMMAND_NOT_FOUND in output:
+                return _RUFF_SKIPPED
+            if output:
+                lines = [line for line in output.splitlines() if line.strip()]
+                if len(lines) <= 5:
+                    return "Import order issues:\n  " + "\n  ".join(lines)
+                shown = "\n  ".join(lines[:5])
+                return f"Import order issues:\n  {shown}\n  ... and {len(lines)-5} more"
+            return "Import order issues found"
+        return None
+
     def _check_black(self, project_root: str) -> Optional[str]:
         """Check black formatting.
 
@@ -286,6 +437,8 @@ class PythonLintFormatCheck(BaseCheck, PythonCheckMixin):
                     "--check",
                     "--line-length",
                     "88",
+                    "--extend-exclude",
+                    _BLACK_EXTEND_EXCLUDE,
                     target,
                 ],
                 cwd=project_root,

{slopmop-2.3.0 → slopmop-2.3.2}/slopmop/checks/python/type_checking.py

@@ -55,6 +55,41 @@ TYPE_COMPLETENESS_RULES: Dict[str, str] = {
 MAX_ERRORS_TO_SHOW = 5
 MAX_FILES_TO_SHOW = 10
 
+# Excludes injected when include falls back to ["."] (the whole-tree scan).
+# All patterns use "**/" so nested subproject directories are excluded too —
+# a bare "venv" only excludes the root-level dir in pyright. (#262)
+# "env" and ".env" are intentionally omitted: "env" is a legitimate Python
+# package name, and ".env" is nearly always a file rather than a directory.
+_BROAD_SCAN_EXCLUDES: List[str] = [
+    "**/__pycache__",
+    "**/node_modules",
+    "**/venv",
+    "**/.venv",
+    "**/build",
+    "**/dist",
+    "**/*.egg-info",
+    "**/.eggs",
+    "**/.tox",
+    "**/.nox",
+]
+
+# Safe minimal excludes applied for every scoped include (won't shadow real packages).
+_MINIMAL_EXCLUDES: List[str] = ["**/__pycache__", "**/node_modules"]
+
+
+def _fallback_excludes(venv_name: Optional[str]) -> List[str]:
+    """Build the exclude list for the whole-tree include:['.'] fallback.
+
+    Appends the detected venv name (with **/ prefix) when it isn't already
+    covered by _BROAD_SCAN_EXCLUDES, e.g. a non-standard name like 'myenv'.
+    """
+    excludes = list(_BROAD_SCAN_EXCLUDES)
+    if venv_name:
+        prefixed = f"**/{venv_name}"
+        if prefixed not in excludes:
+            excludes.append(prefixed)
+    return excludes
+
 
 def _fix_strategy_for_pyright(rule: str, message: str) -> Optional[str]:
     """Return a prescriptive remediation for common pyright rules."""
@@ -347,14 +382,29 @@ class PythonTypeCheckingCheck(BaseCheck, PythonCheckMixin):
             config["extends"] = base_config_file
             if isinstance(explicit_include_dirs, list) and explicit_include_dirs:
                 config["include"] = include_dirs
+                # Explicit include:["."] still needs broad excludes — same guard
+                # as the auto-detect fallback below. (#262)
+                if include_dirs == ["."]:
+                    config["exclude"] = _fallback_excludes(venv_name)
             elif not explicitly_configured and "include" not in base_cfg:
                 # Auto-detected pyrightconfig.json that doesn't scope includes:
                 # keep source-dir scoping so the gate doesn't balloon to the
                 # whole tree. (An explicitly configured base is trusted as-is.)
                 config["include"] = include_dirs
+                # Only inject broad excludes for the whole-tree fallback; a
+                # scoped include already limits the scan and broad excludes
+                # could silently shadow a real package with the same name. (#262)
+                if include_dirs == ["."]:
+                    config["exclude"] = _fallback_excludes(venv_name)
         else:
             config["include"] = include_dirs
-            config["exclude"] = ["**/__pycache__", "**/node_modules"]
+            if include_dirs == ["."]:
+                # Whole-tree fallback: guard venv/build/generated dirs. (#262)
+                config["exclude"] = _fallback_excludes(venv_name)
+            else:
+                # Scoped include: minimal excludes only — broad patterns could
+                # shadow a real package whose name happens to match (e.g. "env").
+                config["exclude"] = list(_MINIMAL_EXCLUDES)
             config["pythonVersion"] = python_version
 
         if venv_path and venv_name:
@@ -371,6 +421,12 @@ class PythonTypeCheckingCheck(BaseCheck, PythonCheckMixin):
                 if rule not in owned_rules:
                     config[rule] = level
 
+        # Copy any report* rules from base config to the generated config to prevent
+        # them from being overridden/reset by typeCheckingMode: standard.
+        for rule, level in base_cfg.items():
+            if rule.startswith("report") and rule not in config:
+                config[rule] = level
+
         return config
 
     def run(self, project_root: str) -> CheckResult:

{slopmop-2.3.0 → slopmop-2.3.2}/slopmop/cli/audit.py

@@ -569,7 +569,12 @@ def cmd_audit(args: argparse.Namespace) -> int:
     include_gates = not getattr(args, "no_gates", False)
     output_path_str: Optional[str] = getattr(args, "output", None)
     json_flag = getattr(args, "json_output", None)
-    json_mode = json_flag is True or (json_flag is None and not sys.stdout.isatty())
+    if json_flag is None:
+        from slopmop.utils.environment import is_agent_environment
+
+        json_mode = not sys.stdout.isatty() or is_agent_environment()
+    else:
+        json_mode = json_flag
     quiet = getattr(args, "quiet", False)
 
     timestamp = datetime.now(tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")