sarj-python-lint 0.41.0__tar.gz → 0.43.0__tar.gz

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sarj-python-lint
-Version: 0.41.0
+Version: 0.43.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://github.com/sarj-ai/standards/tree/main/packages/python
 Project-URL: Repository, https://github.com/sarj-ai/standards
@@ -157,7 +157,7 @@ the shipped config the section goes and the summary stays.
 read against source gave **~2%** false positives, the whole of which was one
 family (`Returns: A new X` — whether the value is a copy is the one thing
 `-> Self` cannot say) now guarded. Three findings on this repo's own source, all
-true, all deleted. Measurements: [docs/rules/SARJ087.md](../../docs/rules/SARJ087.md).
+true, all deleted. The guarded copy-return case is covered by the paired rule tests.
 
 ### Test ceremony, and the census it was chosen from (0.38.0)
 
@@ -169,7 +169,7 @@ true, all deleted. Measurements: [docs/rules/SARJ087.md](../../docs/rules/SARJ08
 Every comment GROUP in 19 repositories / 45,900 Python files was collected with
 its adjacent code and classified: **451,482 groups, 1,293,022 lines**, of which
 the seven comment/docstring rules that predate this release reached **4.9%**.
-The full census table is in [docs/rules/SARJ088.md](../../docs/rules/SARJ088.md).
+The shipped predicate and its boundaries are recorded in the paired rule tests.
 
 The largest precisely-detectable class left in it is the **test docstring**:
 52,894 of them, 10.1% of every comment group, and SARJ050 reached 4.7%. It

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/README.md

@@ -139,7 +139,7 @@ the shipped config the section goes and the summary stays.
 read against source gave **~2%** false positives, the whole of which was one
 family (`Returns: A new X` — whether the value is a copy is the one thing
 `-> Self` cannot say) now guarded. Three findings on this repo's own source, all
-true, all deleted. Measurements: [docs/rules/SARJ087.md](../../docs/rules/SARJ087.md).
+true, all deleted. The guarded copy-return case is covered by the paired rule tests.
 
 ### Test ceremony, and the census it was chosen from (0.38.0)
 
@@ -151,7 +151,7 @@ true, all deleted. Measurements: [docs/rules/SARJ087.md](../../docs/rules/SARJ08
 Every comment GROUP in 19 repositories / 45,900 Python files was collected with
 its adjacent code and classified: **451,482 groups, 1,293,022 lines**, of which
 the seven comment/docstring rules that predate this release reached **4.9%**.
-The full census table is in [docs/rules/SARJ088.md](../../docs/rules/SARJ088.md).
+The shipped predicate and its boundaries are recorded in the paired rule tests.
 
 The largest precisely-detectable class left in it is the **test docstring**:
 52,894 of them, 10.1% of every comment group, and SARJ050 reached 4.7%. It

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.41.0"
+version = "0.43.0"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/src/sarj_python_lint/__main__.py

@@ -9,7 +9,7 @@ from pathlib import Path
 import sys
 
 from sarj_python_lint import __version__
-from sarj_python_lint.rule_base import Diagnostic, is_suppressed
+from sarj_python_lint.rule_base import Diagnostic, Severity, is_suppressed
 from sarj_python_lint.rules import REGISTRY
 
 
@@ -117,14 +117,14 @@ def _explain(wanted: str) -> int:
     sys.stdout.write(
         f"{cls.code}  {cls.id}\n{summary[0] if summary else cls.description}\nexamples: {cls.examples_url()}\n"
     )
-    if cls.has_evidence:
-        sys.stdout.write(f"evidence: {cls.evidence_url()}\n")
     return 0
 
 
 def _baseline_counts(diags: list[Diagnostic]) -> dict[str, dict[str, int]]:
     counts: dict[str, dict[str, int]] = {}
     for d in diags:
+        if d.severity is Severity.WARNING:
+            continue
         counts.setdefault(str(d.path), {})
         counts[str(d.path)][d.code] = counts[str(d.path)].get(d.code, 0) + 1
     return counts
@@ -160,6 +160,9 @@ def _apply_baseline(diags: list[Diagnostic], baseline: dict[str, dict[str, int]]
     seen: Counter[tuple[str, str]] = Counter()
     out: list[Diagnostic] = []
     for d in diags:
+        if d.severity is Severity.WARNING:
+            out.append(d)
+            continue
         key = (str(d.path), d.code)
         seen[key] += 1
         if seen[key] > baseline.get(key[0], {}).get(key[1], 0):
@@ -221,7 +224,7 @@ def main(argv: list[str] | None = None) -> int:
         diags = _apply_baseline(diags, _read_baseline(args.baseline))
     for d in diags:
         sys.stdout.write(d.format() + "\n")
-    return 1 if diags else 0
+    return 1 if any(d.severity is Severity.ERROR for d in diags) else 0
 
 
 if __name__ == "__main__":

sarj_python_lint-0.43.0/src/sarj_python_lint/_secret_names.py

@@ -0,0 +1,109 @@
+"""Recognize secret-bearing identifiers for SARJ011 and SARJ012.
+
+Matching uses whole words and excludes metadata and boolean-state names.
+"""
+
+from __future__ import annotations
+
+from itertools import pairwise
+import re
+
+
+SECRET_WORDS = frozenset(
+    {
+        "token",
+        "secret",
+        "password",
+        "passwd",
+        "jwt",
+        "secrets",
+        "passwords",
+        "credential",
+        "credentials",
+        "authorization",
+        "signature",
+        "hmac",
+        "digest",
+        "hash",
+        "apikey",
+        # Keep this vocabulary aligned with the TypeScript helper.
+        "bearer",
+    }
+)
+
+_SECRET_WORDS = SECRET_WORDS
+
+# A trailing word in this set makes the identifier metadata, not a credential.
+_INNOCUOUS_WORDS = frozenset(
+    {
+        "count",
+        "counts",
+        "budget",
+        "limit",
+        "limits",
+        "id",
+        "ids",
+        "enabled",
+        "disabled",
+        "flag",
+        "flags",
+        "present",
+        "set",
+        "unset",
+        "configured",
+        "missing",
+        "required",
+        "valid",
+        "invalid",
+        "exists",
+        "type",
+        "types",
+    }
+)
+
+# A leading predicate makes the identifier a boolean flag, not a credential.
+_FLAG_PREFIXES = frozenset({"is", "has", "was", "are", "can", "should"})
+
+# camelCase / PascalCase / ALLCAPS / digit run splitter, applied to each
+# snake/kebab segment. `APIKey` -> ["API", "Key"], `authToken` -> ["auth", "Token"].
+_CAMEL_RE = re.compile(r"[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|\d+")
+_SEGMENT_RE = re.compile(r"[^A-Za-z0-9]+")
+
+
+def identifier_tokens(identifier: str) -> list[str]:
+    """Return lowercase whole segments and their camel-case words."""
+    tokens: list[str] = []
+    for segment in _SEGMENT_RE.split(identifier):
+        if not segment:
+            continue
+        tokens.append(segment.lower())
+        camel_parts: list[str] = _CAMEL_RE.findall(segment)
+        tokens.extend(part.lower() for part in camel_parts)
+    return tokens
+
+
+def leading_word(identifier: str) -> str | None:
+    """Return the first camel- or delimiter-separated word, lowercased."""
+    for segment in _SEGMENT_RE.split(identifier):
+        if not segment:
+            continue
+        parts: list[str] = _CAMEL_RE.findall(segment)
+        return parts[0].lower() if parts else segment.lower()
+    return None
+
+
+def is_secret_name(identifier: str) -> bool:
+    """Report whether `identifier` names raw secret material (a credential, not metadata)."""
+    tokens = identifier_tokens(identifier)
+    if tokens and tokens[-1] in _INNOCUOUS_WORDS:
+        return False
+    if leading_word(identifier) in _FLAG_PREFIXES:
+        return False
+    if any(tok in SECRET_WORDS for tok in tokens):
+        return True
+    return _has_api_key(tokens)
+
+
+def _has_api_key(tokens: list[str]) -> bool:
+    """Report whether `api` is immediately followed by `key` (the split form of `api_key`)."""
+    return any(a == "api" and b == "key" for a, b in pairwise(tokens))

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/src/sarj_python_lint/rule_base.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import ast
 from dataclasses import dataclass
+from enum import StrEnum
 from pathlib import Path
 import re
 from typing import TYPE_CHECKING, Final
@@ -14,15 +15,9 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
 
 
-# The two locations a rule's documentation lives in, and the base of the links
-# that point at them. Named once here because `Rule.examples_path` /
-# `Rule.evidence_path` DERIVE every rule's links from these plus the rule's own
-# module name and code — no rule module writes a URL by hand, so a rename cannot
-# leave a dead link behind. `test_rule_meta.py` asserts every derived path
-# resolves on disk.
+# Each rule points directly to its executable examples.
 REPO_BLOB: Final = "https://github.com/sarj-ai/standards/blob/main"
 TESTS_DIR: Final = "packages/python/tests/rules"
-EVIDENCE_DIR: Final = "docs/rules"
 
 
 # Suppression syntax. Two forms supported:
@@ -58,6 +53,13 @@ def is_suppressed(source_lines: Sequence[str], line: int, code: str) -> bool:
     return code.upper() in codes
 
 
+class Severity(StrEnum):
+    """Whether a diagnostic blocks the lint command."""
+
+    WARNING = "warning"
+    ERROR = "error"
+
+
 @dataclass(frozen=True, slots=True)
 class Diagnostic:
     """A single lint finding."""
@@ -67,10 +69,12 @@ class Diagnostic:
     col: int
     code: str
     message: str
+    severity: Severity = Severity.ERROR
 
     def format(self) -> str:
         """Render the finding ruff-compatibly as `path:line:col: CODE message`."""
-        return f"{self.path}:{self.line}:{self.col}: {self.code} {self.message}"
+        label = "warning: " if self.severity is Severity.WARNING else ""
+        return f"{self.path}:{self.line}:{self.col}: {self.code} {label}{self.message}"
 
 
 class Rule(ABC):
@@ -79,24 +83,14 @@ class Rule(ABC):
     Subclasses set `id` (kebab-case) and `code` (e.g. SARJ001) as class
     attributes and implement `check(path, source) -> list[Diagnostic]`.
 
-    A rule documents itself with a one-line summary plus two DERIVED links —
-    `examples_url()` (the examples) and `evidence_url()` (the measurements). Both
-    are computed from `__module__` and `code`, never written by hand, and
-    `test_rule_meta.py` asserts each resolves to a file that exists. A rename
-    therefore fails the suite instead of leaving a dead link in a docstring.
+    A rule documents itself with a concise summary and a derived link to its
+    executable examples. The metadata tests require that paired test module.
     """
 
     id: str
     code: str
     description: str
 
-    # True when `docs/rules/<code>.md` holds this rule's measured evidence — the
-    # corpus census, the threshold sweeps and the false-positive families each
-    # guard was built to stop. Declared rather than probed so the link still
-    # prints from an installed wheel, where `docs/` is not shipped;
-    # `test_evidence_flag_matches_the_filesystem` keeps the two honest.
-    has_evidence: bool = False
-
     @abstractmethod
     def check(self, path: Path, source: str) -> list[Diagnostic]:
         """Inspect the given source. Return zero or more diagnostics."""
@@ -106,18 +100,10 @@ class Rule(ABC):
     def examples_path(cls) -> str:
         return f"{TESTS_DIR}/test_{cls.__module__.rpartition('.')[2]}.py"
 
-    @classmethod
-    def evidence_path(cls) -> str:
-        return f"{EVIDENCE_DIR}/{cls.code}.md"
-
     @classmethod
     def examples_url(cls) -> str:
         return f"{REPO_BLOB}/{cls.examples_path()}"
 
-    @classmethod
-    def evidence_url(cls) -> str:
-        return f"{REPO_BLOB}/{cls.evidence_path()}"
-
 
 _last_parse: tuple[str, str, ast.Module | None] | None = None
 

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/src/sarj_python_lint/rules/_docstrings.py

@@ -111,7 +111,7 @@ _BASE_STOPWORDS = frozenset(
 # config", "the entire widget" — strip the adjective and the sentence means
 # exactly what it meant. Kept as its own name because a single one of these
 # was the commonest reason a pure restatement survived the whole family; see
-# docs/rules/SARJ088.md for the measurement. `main`, `new`, `same` and `copy`
+# The paired SARJ088 tests cover this vocabulary. `main`, `new`, `same` and `copy`
 # are NOT here: they name the thing or its identity, which is content.
 FILLER_QUALIFIERS = frozenset(
     {

sarj_python_lint-0.43.0/src/sarj_python_lint/rules/_prose_budget.py

@@ -0,0 +1,151 @@
+"""Shared extraction and sentence counting for SARJ090-092."""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+import io
+import re
+import tokenize
+from typing import TYPE_CHECKING, Final
+
+from sarj_python_lint.rule_base import parse_or_none
+from sarj_python_lint.rules._docstrings import PROMPT_DECORATOR_MARKERS, decorator_markers, sections
+from sarj_python_lint.rules._paths import is_generated
+
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+_DIRECTIVE_RE: Final = re.compile(
+    r"^(?:!|noqa|sarj-noqa|type:|pragma|pyright|mypy|fmt:|isort|ruff|pylint|flake8|"
+    r"nosec|nosemgrep|todo|fixme|hack\b|xxx|coding[:=])",
+    re.IGNORECASE,
+)
+_LICENSE_RE: Final = re.compile(r"\b(?:copyright|spdx-license-identifier|licensed under)\b", re.IGNORECASE)
+_BOUNDARY_RE: Final = re.compile(r"(?<=[.!?])[\"'`)\]]*\s+(?=[A-Z0-9`])")
+_BULLET_RE: Final = re.compile(r"^\s*(?:[-*+] |\d+[.)] )")
+_TYPED_SECTIONS: Final = frozenset(
+    {"Args", "Arguments", "Parameters", "Params", "Keyword Args", "Keyword Arguments", "Returns", "Return", "Yields", "Yield"}
+)
+_SCHEMA_BASES: Final = frozenset(
+    {"BaseModel", "BaseSettings", "RootModel", "TypedDict", "Enum", "IntEnum", "StrEnum"}
+)
+_SCHEMA_DECORATORS: Final = frozenset({"pydantic", "strawberry", "graphene", "msgspec"})
+
+
+@dataclass(frozen=True, slots=True)
+class ProseGroup:
+    line: int
+    col: int
+    text: str
+    kind: str
+    typed_sections: frozenset[str] = frozenset()
+
+
+def sentence_units(text: str) -> int:
+    """Count prose sentences and unpunctuated list items deterministically."""
+    cleaned = re.sub(r"https?://\S+", "URL", text)
+    cleaned = re.sub(r"`[^`\n]+`", "CODE", cleaned)
+    cleaned = re.sub(r"\b\d+\.\d+\b", "NUMBER", cleaned)
+    cleaned = re.sub(r"\b(?:e\.g\.|i\.e\.|vs\.|etc\.)", "ABBREVIATION", cleaned, flags=re.IGNORECASE)
+    units = 0
+    prose: list[str] = []
+    for raw in cleaned.splitlines():
+        line = raw.strip().lstrip("*").strip()
+        if not line or re.fullmatch(r"[A-Za-z][A-Za-z ]+:", line):
+            continue
+        if _BULLET_RE.match(line):
+            units += 1
+        else:
+            prose.append(line)
+    paragraph = " ".join(prose).strip()
+    if paragraph:
+        units += len(_BOUNDARY_RE.split(paragraph))
+    return units
+
+
+def groups(path: Path, source: str) -> list[ProseGroup]:
+    """Extract docstrings and contiguous own-line comment runs from one file."""
+    if is_generated(path, source):
+        return []
+    tree = parse_or_none(path, source)
+    if tree is None:
+        return []
+    out = _docstring_groups(tree)
+    lines = source.splitlines()
+    try:
+        comments = [token for token in tokenize.generate_tokens(io.StringIO(source).readline) if token.type == tokenize.COMMENT]
+    except tokenize.TokenError, IndentationError, SyntaxError:
+        return out
+    run: list[tokenize.TokenInfo] = []
+    for comment in comments:
+        body = comment.string.removeprefix("#").strip()
+        own_line = not lines[comment.start[0] - 1][: comment.start[1]].strip()
+        if not own_line or _DIRECTIVE_RE.match(body) or _LICENSE_RE.search(body):
+            if run:
+                out.append(_comment_run(run))
+                run = []
+            continue
+        if run and (comment.start[0] != run[-1].end[0] + 1 or comment.start[1] != run[-1].start[1]):
+            out.append(_comment_run(run))
+            run = []
+        run.append(comment)
+    if run:
+        out.append(_comment_run(run))
+    return out
+
+
+def _comment_run(run: list[tokenize.TokenInfo]) -> ProseGroup:
+    return ProseGroup(
+        line=run[0].start[0],
+        col=run[0].start[1] + 1,
+        text="\n".join(token.string.removeprefix("#").strip() for token in run),
+        kind="comment",
+    )
+
+
+def _docstring_groups(tree: ast.Module) -> list[ProseGroup]:
+    out: list[ProseGroup] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.Module, ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)) or not node.body:
+            continue
+        first = node.body[0]
+        if not (
+            isinstance(first, ast.Expr)
+            and isinstance(first.value, ast.Constant)
+            and isinstance(first.value.value, str)
+        ):
+            continue
+        if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)) and (
+            decorator_markers(node) & PROMPT_DECORATOR_MARKERS
+        ):
+            continue
+        if isinstance(node, ast.ClassDef) and _is_schema_class(node):
+            continue
+        doc = first.value.value
+        found = frozenset(
+            name
+            for name in sections(doc)
+            if name in _TYPED_SECTIONS and isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and _fully_typed(node)
+        )
+        out.append(ProseGroup(first.lineno, first.col_offset + 1, doc, "docstring", found))
+    return out
+
+
+def _is_schema_class(node: ast.ClassDef) -> bool:
+    bases = {
+        target.attr if isinstance(target, ast.Attribute) else target.id
+        for base in node.bases
+        if isinstance((target := base.value if isinstance(base, ast.Subscript) else base), (ast.Attribute, ast.Name))
+    }
+    return bool(bases & _SCHEMA_BASES or decorator_markers(node) & _SCHEMA_DECORATORS)
+
+
+def _fully_typed(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    args = node.args
+    parameters = (*args.posonlyargs, *args.args, *args.kwonlyargs)
+    return node.returns is not None and all(arg.arg in {"self", "cls"} or arg.annotation is not None for arg in parameters) and (
+        args.vararg is None or args.vararg.annotation is not None
+    ) and (args.kwarg is None or args.kwarg.annotation is not None)

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/src/sarj_python_lint/rules/_registry.py

@@ -37,6 +37,7 @@ from sarj_python_lint.rules.no_first_party_private_import import (
 from sarj_python_lint.rules.no_fstring_in_log import NoFstringInLog
 from sarj_python_lint.rules.no_gen_random_uuid_in_sql import NoGenRandomUuidInSql
 from sarj_python_lint.rules.no_isinstance_union_chain import NoIsinstanceUnionChain
+from sarj_python_lint.rules.no_long_comment import NoLongComment
 from sarj_python_lint.rules.no_offset_pagination import NoOffsetPagination
 from sarj_python_lint.rules.no_optional_tenant_predicate import (
     NoOptionalTenantPredicate,
@@ -52,6 +53,7 @@ from sarj_python_lint.rules.no_sequential_await import NoSequentialAwait
 from sarj_python_lint.rules.no_sleep_in_test_body import NoSleepInTestBody
 from sarj_python_lint.rules.no_stdlib_logging import NoStdlibLogging
 from sarj_python_lint.rules.no_tautological_expect import NoTautologicalExpect
+from sarj_python_lint.rules.no_typed_doc_sections import NoTypedDocSections
 from sarj_python_lint.rules.no_unreachable_after_terminal import (
     NoUnreachableAfterTerminal,
 )
@@ -73,12 +75,14 @@ from sarj_python_lint.rules.prefer_module_level_constant import (
 from sarj_python_lint.rules.prefer_namedtuple_over_tuple_return import (
     PreferNamedtupleOverTupleReturn,
 )
+from sarj_python_lint.rules.prefer_nominal_id_types import PreferNominalIdTypes
 from sarj_python_lint.rules.prefer_non_nullable_collection import (
     PreferNonNullableCollection,
 )
 from sarj_python_lint.rules.prefer_or_pattern import PreferOrPattern
 from sarj_python_lint.rules.prefer_real_store_in_tests import PreferRealStoreInTests
 from sarj_python_lint.rules.prefer_self_type_annotation import PreferSelfTypeAnnotation
+from sarj_python_lint.rules.prefer_single_sentence_comment import PreferSingleSentenceComment
 from sarj_python_lint.rules.prefer_str_enum import PreferStrEnum
 from sarj_python_lint.rules.prefer_struct_over_namedtuple import (
     PreferStructOverNamedtuple,
@@ -190,6 +194,10 @@ REGISTRY: dict[str, type[Rule]] = {
     DocstringReturnsRestateSignature.id: DocstringReturnsRestateSignature,
     RestatedTestDocstring.id: RestatedTestDocstring,
     TestPhaseLabelComment.id: TestPhaseLabelComment,
+    PreferSingleSentenceComment.id: PreferSingleSentenceComment,
+    NoLongComment.id: NoLongComment,
+    NoTypedDocSections.id: NoTypedDocSections,
+    PreferNominalIdTypes.id: PreferNominalIdTypes,
 }
 
 __all__ = ["REGISTRY"]

sarj_python_lint-0.43.0/src/sarj_python_lint/rules/_sql.py

@@ -0,0 +1,78 @@
+"""Extract executable SQL while masking quoted values and comments."""
+
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+from sarj_python_lint.rules._paths import is_test_path
+
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def is_store_module(path: Path) -> bool:
+    """Return whether a non-test path belongs to the store layer."""
+    if is_test_path(path):
+        return False
+    return path.name.endswith("_store.py") or "stores" in path.parts
+
+
+def sql_string_value(node: ast.expr) -> str | None:
+    """Reconstruct a (possibly `+`-concatenated) string literal, else None."""
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        return node.value
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+        left = sql_string_value(node.left)
+        right = sql_string_value(node.right)
+        if left is not None and right is not None:
+            return left + right
+    return None
+
+
+def strip_sql_noise(text: str) -> str:
+    """Mask SQL values and comments without changing text or line lengths."""
+    out = list(text)
+    n = len(text)
+    i = 0
+    while i < n:
+        ch = text[i]
+        if ch in {"'", '"'}:
+            out[i] = " "
+            i += 1
+            while i < n:
+                c = text[i]
+                if c == ch:
+                    if i + 1 < n and text[i + 1] == ch:
+                        out[i] = out[i + 1] = " "
+                        i += 2
+                        continue
+                    out[i] = " "
+                    i += 1
+                    break
+                if c != "\n":
+                    out[i] = " "
+                i += 1
+            continue
+        if ch == "-" and i + 1 < n and text[i + 1] == "-":
+            while i < n and text[i] != "\n":
+                out[i] = " "
+                i += 1
+            continue
+        if ch == "/" and i + 1 < n and text[i + 1] == "*":
+            out[i] = out[i + 1] = " "
+            i += 2
+            while i < n and not (text[i] == "*" and i + 1 < n and text[i + 1] == "/"):
+                if text[i] != "\n":
+                    out[i] = " "
+                i += 1
+            if i < n:
+                out[i] = " "
+                i += 1
+                if i < n:
+                    out[i] = " "
+                    i += 1
+            continue
+        i += 1
+    return "".join(out)

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/src/sarj_python_lint/rules/conditional_assertion_in_test.py

@@ -1,7 +1,6 @@
 """SARJ065 — A test whose every assertion sits behind a branch or loop can pass asserting nothing.
 
 Examples: https://github.com/sarj-ai/standards/blob/main/packages/python/tests/rules/test_conditional_assertion_in_test.py
-Evidence: https://github.com/sarj-ai/standards/blob/main/docs/rules/SARJ065.md
 """
 
 from __future__ import annotations
@@ -137,7 +136,6 @@ class _Facts:
 class ConditionalAssertionInTest(Rule):
     id: str = "conditional-assertion-in-test"
     code: str = "SARJ065"
-    has_evidence: bool = True
     description: str = "Every assertion in the test is inside a conditional or loop — it can pass asserting nothing."
 
     @override

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/src/sarj_python_lint/rules/docstring_args_restate_signature.py

@@ -1,7 +1,6 @@
 """SARJ086 — An `Args:` block that only re-spells the parameter list.
 
 Examples: https://github.com/sarj-ai/standards/blob/main/packages/python/tests/rules/test_docstring_args_restate_signature.py
-Evidence: https://github.com/sarj-ai/standards/blob/main/docs/rules/SARJ086.md
 """
 
 from __future__ import annotations
@@ -32,7 +31,6 @@ if TYPE_CHECKING:
 class DocstringArgsRestateSignature(Rule):
     id: str = "docstring-args-restate-signature"
     code: str = "SARJ086"
-    has_evidence: bool = True
     description: str = (
         "`Args:` block adds nothing the signature does not already say — delete the section and keep the summary."
     )

{sarj_python_lint-0.41.0 → sarj_python_lint-0.43.0}/src/sarj_python_lint/rules/docstring_returns_restate_signature.py

@@ -1,7 +1,6 @@
 """SARJ087 — A `Returns:` block that only re-spells the name and the return annotation.
 
 Examples: https://github.com/sarj-ai/standards/blob/main/packages/python/tests/rules/test_docstring_returns_restate_signature.py
-Evidence: https://github.com/sarj-ai/standards/blob/main/docs/rules/SARJ087.md
 """
 
 from __future__ import annotations
@@ -52,7 +51,6 @@ def _return_block(docstring: str) -> str | None:
 class DocstringReturnsRestateSignature(Rule):
     id: str = "docstring-returns-restate-signature"
     code: str = "SARJ087"
-    has_evidence: bool = True
     description: str = (
         "`Returns:` block adds nothing the name and the return annotation do not "
         "already say — delete the section and keep the summary."