intendant 4.0.0__py3-none-any.whl

intendant/__init__.py

@@ -0,0 +1,3 @@
+"""Intendant — multi-stack project governance framework."""
+
+__version__ = "4.0.0"

intendant/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m intendant`` invocation."""
+
+from intendant.cli import main
+
+if __name__ == "__main__":
+    main()

intendant/adapters/claude_skill/__init__.py

@@ -0,0 +1,26 @@
+"""Skill adapter — Claude Skill repository rules."""
+
+from __future__ import annotations
+
+from intendant.adapters.claude_skill.ci import CLAUDE_SKILL_CI001MinimumSteps
+from intendant.adapters.claude_skill.sk import (
+    SK001SkillMdExists,
+    SK002FrontmatterValid,
+    SK003DescriptionQuality,
+    SK004NameMatchesDir,
+    SK005EvalsNonEmpty,
+    SK006ReferencedDirsExist,
+    SK007ReadmeInstallPath,
+)
+from intendant.core.rule import Rule
+
+RULES: list[Rule] = [
+    SK001SkillMdExists(),
+    SK002FrontmatterValid(),
+    SK003DescriptionQuality(),
+    SK004NameMatchesDir(),
+    SK005EvalsNonEmpty(),
+    SK006ReferencedDirsExist(),
+    SK007ReadmeInstallPath(),
+    CLAUDE_SKILL_CI001MinimumSteps(),
+]

intendant/adapters/claude_skill/ci.py

@@ -0,0 +1,34 @@
+"""Claude Skill adapter CI rules."""
+
+from __future__ import annotations
+
+from intendant.core.repo import Repo
+from intendant.core.rule import CheckResult, Rule
+
+
+class CLAUDE_SKILL_CI001MinimumSteps(Rule):  # noqa: N801
+    id = "CLAUDE_SKILL_CI001"
+    title = "CI workflow runs intendant audit"
+    severity = "required"
+    stacks = ("claude-skill",)
+    handbook_ref = "docs/handbook/03-ci.md#claude_skill_ci001"
+
+    def check(self, repo: Repo) -> CheckResult:
+        wf_dir = repo.path / ".github" / "workflows"
+        if not wf_dir.is_dir():
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="no .github/workflows/ directory (covered by CI001)",
+            )
+        contents = "\n".join(p.read_text(errors="replace") for p in wf_dir.glob("*.yml"))
+        contents += "\n".join(p.read_text(errors="replace") for p in wf_dir.glob("*.yaml"))
+        if "intendant audit" not in contents:
+            return CheckResult(
+                passing=False,
+                evidence="no `intendant audit` step found in CI workflows",
+            )
+        return CheckResult(
+            passing=True,
+            evidence="`intendant audit` step found in CI",
+        )

intendant/adapters/claude_skill/inspectors.py

@@ -0,0 +1,62 @@
+"""Helpers shared by skill rule check/fix methods."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import yaml
+
+_EXCLUDED_PARTS = frozenset(
+    {
+        ".git",
+        "node_modules",
+        "__pycache__",
+        ".venv",
+        ".tox",
+        "dist",
+        "build",
+    }
+)
+
+_FRONTMATTER_RE = re.compile(r"^---\n(.*?\n)---\n", re.DOTALL)
+_BOM = ""
+
+
+def find_skill_md(repo_path: Path) -> Path | None:
+    """Locate a single SKILL.md at depth 1 or 2 below ``repo_path``.
+
+    Returns the alphabetically-first match for determinism. Depth-1
+    matches take precedence over depth-2 matches. Excludes paths that
+    pass through any directory in ``_EXCLUDED_PARTS``. Returns ``None``
+    if no SKILL.md is found.
+    """
+    for depth in (1, 2):
+        pattern = "*/" * (depth - 1) + "SKILL.md"
+        candidates = sorted(
+            p
+            for p in repo_path.glob(pattern)
+            if not (set(p.relative_to(repo_path).parts) & _EXCLUDED_PARTS)
+        )
+        if candidates:
+            return candidates[0]
+    return None
+
+
+def parse_frontmatter(skill_md_path: Path) -> dict | None:
+    """Extract and parse YAML frontmatter from a SKILL.md file.
+
+    Returns the parsed dict, or ``None`` if frontmatter is absent or malformed.
+    Treats UTF-8 BOM at file start as if it were not there.
+    """
+    text = skill_md_path.read_text(encoding="utf-8", errors="replace")
+    if text.startswith(_BOM):
+        text = text[len(_BOM) :]
+    match = _FRONTMATTER_RE.match(text)
+    if not match:
+        return None
+    try:
+        data = yaml.safe_load(match.group(1))
+    except yaml.YAMLError:
+        return None
+    return data if isinstance(data, dict) else None

intendant/adapters/claude_skill/sk.py

@@ -0,0 +1,287 @@
+"""Skill adapter SK rules (SK001-SK007)."""
+
+from __future__ import annotations
+
+import re
+
+import yaml
+
+from intendant.adapters.claude_skill.inspectors import find_skill_md, parse_frontmatter
+from intendant.core.patch import Patch
+from intendant.core.repo import Repo
+from intendant.core.rule import CheckResult, Rule
+
+# Used by SK002 (raw-text frontmatter detection) and SK006 (strip frontmatter from body).
+_FRONTMATTER_BLOCK_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
+
+
+class SK001SkillMdExists(Rule):
+    id = "CLAUDE_SKILL_SK001"
+    title = "SKILL.md exists at depth <= 2"
+    severity = "required"
+    stacks = ("claude-skill",)
+    handbook_ref = "docs/handbook/09-claude-skill.md#claude_skill_sk001"
+
+    def check(self, repo: Repo) -> CheckResult:
+        skill_md = find_skill_md(repo.path)
+        if skill_md is None:
+            return CheckResult(
+                passing=False,
+                evidence=(
+                    "no SKILL.md found at depth <= 2 (excluding .git, node_modules, "
+                    "__pycache__, .venv, .tox, dist, build)"
+                ),
+            )
+        rel = skill_md.relative_to(repo.path)
+        return CheckResult(passing=True, evidence=f"skill detected at {rel}")
+
+
+class SK002FrontmatterValid(Rule):
+    id = "CLAUDE_SKILL_SK002"
+    title = "SKILL.md frontmatter valid (name + description present and non-empty)"
+    severity = "required"
+    stacks = ("claude-skill",)
+    handbook_ref = "docs/handbook/09-claude-skill.md#claude_skill_sk002"
+
+    def check(self, repo: Repo) -> CheckResult:
+        skill_md = find_skill_md(repo.path)
+        if skill_md is None:
+            return CheckResult(passing=False, evidence="no SKILL.md found")
+        text = skill_md.read_text(encoding="utf-8", errors="replace")
+        if text.startswith(""):
+            text = text[1:]
+        match = _FRONTMATTER_BLOCK_RE.match(text)
+        if not match:
+            return CheckResult(passing=False, evidence="no frontmatter block found")
+        try:
+            data = yaml.safe_load(match.group(1))
+        except yaml.YAMLError as exc:
+            return CheckResult(passing=False, evidence=f"YAML parse error: {exc}")
+        if not isinstance(data, dict):
+            return CheckResult(
+                passing=False,
+                evidence="frontmatter root is not a YAML mapping",
+            )
+        for field in ("name", "description"):
+            if field not in data:
+                return CheckResult(
+                    passing=False,
+                    evidence=f"missing required field: {field}",
+                )
+            value = data[field]
+            if value is None or (isinstance(value, str) and value.strip() == ""):
+                return CheckResult(
+                    passing=False,
+                    evidence=f"field {field!r} is empty",
+                )
+        name = data["name"]
+        desc = data["description"]
+        return CheckResult(
+            passing=True,
+            evidence=f"frontmatter valid: name={name!r}, description='{len(str(desc))} chars'",
+        )
+
+
+class SK003DescriptionQuality(Rule):
+    id = "CLAUDE_SKILL_SK003"
+    title = "SKILL.md description length within 10-1024 chars"
+    severity = "recommended"
+    stacks = ("claude-skill",)
+    handbook_ref = "docs/handbook/09-claude-skill.md#claude_skill_sk003"
+
+    def check(self, repo: Repo) -> CheckResult:
+        skill_md = find_skill_md(repo.path)
+        if skill_md is None:
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="no SKILL.md found (covered by SK001)",
+            )
+        data = parse_frontmatter(skill_md)
+        if data is None or "description" not in data:
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="frontmatter or description absent (covered by SK002)",
+            )
+        desc = str(data["description"]).strip()
+        n = len(desc)
+        if n < 10:
+            return CheckResult(
+                passing=False,
+                evidence=f"description too short: {n} chars (min 10)",
+            )
+        if n > 1024:
+            return CheckResult(
+                passing=False,
+                evidence=f"description too long: {n} chars (max 1024)",
+            )
+        return CheckResult(passing=True, evidence=f"description length: {n} chars")
+
+
+class SK004NameMatchesDir(Rule):
+    id = "CLAUDE_SKILL_SK004"
+    title = "frontmatter name matches parent directory name"
+    severity = "recommended"
+    stacks = ("claude-skill",)
+    handbook_ref = "docs/handbook/09-claude-skill.md#claude_skill_sk004"
+
+    def check(self, repo: Repo) -> CheckResult:
+        skill_md = find_skill_md(repo.path)
+        if skill_md is None:
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="no SKILL.md found (covered by SK001)",
+            )
+        data = parse_frontmatter(skill_md)
+        if data is None or "name" not in data:
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="frontmatter or name absent (covered by SK002)",
+            )
+        frontmatter_name = str(data["name"])
+        dir_name = skill_md.parent.name
+        if frontmatter_name == dir_name:
+            return CheckResult(passing=True, evidence=f"name matches directory: {dir_name!r}")
+        return CheckResult(
+            passing=False,
+            evidence=f"name {frontmatter_name!r} does not match directory {dir_name!r}",
+        )
+
+
+_EVAL_EXTENSIONS = frozenset({".md", ".json", ".yaml", ".yml", ".txt"})
+
+
+class SK005EvalsNonEmpty(Rule):
+    id = "CLAUDE_SKILL_SK005"
+    title = "evals/ directory present and non-empty"
+    severity = "recommended"
+    stacks = ("claude-skill",)
+    handbook_ref = "docs/handbook/09-claude-skill.md#claude_skill_sk005"
+
+    def check(self, repo: Repo) -> CheckResult:
+        skill_md = find_skill_md(repo.path)
+        if skill_md is None:
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="no SKILL.md found (covered by SK001)",
+            )
+        evals_dir = skill_md.parent / "evals"
+        if not evals_dir.is_dir():
+            return CheckResult(passing=False, evidence="evals/ directory missing")
+        files = [p for p in evals_dir.iterdir() if p.is_file() and p.suffix in _EVAL_EXTENSIONS]
+        if not files:
+            return CheckResult(
+                passing=False,
+                evidence="evals/ directory exists but empty (no .md/.json/.yaml/.txt files)",
+            )
+        return CheckResult(passing=True, evidence=f"evals/ present with {len(files)} file(s)")
+
+
+_DIR_REF_RE = re.compile(r"(?<!\S)(references|scripts)/[\w/.-]+")
+_FENCED_BLOCK_RE = re.compile(r"```.*?```", re.DOTALL)
+
+
+def _strip_frontmatter_and_codeblocks(text: str) -> str:
+    """Return the SKILL.md body with frontmatter and fenced code blocks removed."""
+    body = _FRONTMATTER_BLOCK_RE.sub("", text, count=1)
+    body = _FENCED_BLOCK_RE.sub("", body)
+    return body
+
+
+class SK006ReferencedDirsExist(Rule):
+    id = "CLAUDE_SKILL_SK006"
+    title = "referenced top-level dirs (references/, scripts/) exist when mentioned"
+    severity = "recommended"
+    stacks = ("claude-skill",)
+    handbook_ref = "docs/handbook/09-claude-skill.md#claude_skill_sk006"
+
+    def check(self, repo: Repo) -> CheckResult:
+        skill_md = find_skill_md(repo.path)
+        if skill_md is None:
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="no SKILL.md found (covered by SK001)",
+            )
+        text = skill_md.read_text(encoding="utf-8", errors="replace")
+        if text.startswith(""):
+            text = text[1:]
+        body = _strip_frontmatter_and_codeblocks(text)
+        mentioned_top_levels = {m.group(1) for m in _DIR_REF_RE.finditer(body)}
+        if not mentioned_top_levels:
+            return CheckResult(
+                passing=True,
+                evidence="no references/ or scripts/ mentioned",
+            )
+        skill_dir = skill_md.parent
+        missing = sorted(d for d in mentioned_top_levels if not (skill_dir / d).is_dir())
+        if missing:
+            return CheckResult(
+                passing=False,
+                evidence=f"SKILL.md references missing dirs: {missing}",
+            )
+        return CheckResult(passing=True, evidence="all referenced dirs present")
+
+
+_INSTALL_BLOCK_TEMPLATE = """
+
+## Installation
+
+Clone into your local Claude skills directory:
+
+```bash
+git clone <repo-url> ~/.claude/skills/{skill_name}
+```
+"""
+
+
+class SK007ReadmeInstallPath(Rule):
+    id = "CLAUDE_SKILL_SK007"
+    title = "README mentions skill install path (~/.claude/skills/ or claude/plugins/)"
+    severity = "recommended"
+    stacks = ("claude-skill",)
+    handbook_ref = "docs/handbook/09-claude-skill.md#claude_skill_sk007"
+
+    def check(self, repo: Repo) -> CheckResult:
+        readme = repo.path / "README.md"
+        if not readme.is_file():
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="README.md not found at repo root (covered by DG003)",
+            )
+        text = readme.read_text(encoding="utf-8", errors="replace")
+        if "~/.claude/skills/" in text or "claude/plugins/" in text:
+            return CheckResult(passing=True, evidence="install path documented in README.md")
+        return CheckResult(
+            passing=False,
+            evidence="README.md does not mention skill install path "
+            "(~/.claude/skills/ or claude/plugins/)",
+        )
+
+    def fix(self, repo: Repo, result: CheckResult) -> Patch | None:
+        # Re-check before patching: never patch when skipped (no README) or already passing.
+        if result.skipped or result.passing:
+            return None
+        readme = repo.path / "README.md"
+        if not readme.is_file():
+            return None
+        text = readme.read_text(encoding="utf-8", errors="replace")
+        # Idempotency: if path is now present (race or stale result), no-op.
+        if "~/.claude/skills/" in text or "claude/plugins/" in text:
+            return None
+        skill_md = find_skill_md(repo.path)
+        skill_name = skill_md.parent.name if skill_md else "skill-name"
+        addition = _INSTALL_BLOCK_TEMPLATE.format(skill_name=skill_name)
+        new_content = text.rstrip() + addition
+        return Patch(
+            target_path=readme,
+            kind="overwrite",
+            content=new_content,
+            diff=(f"--- a/README.md\n+++ b/README.md\n@@ +N @@\n{addition}"),
+            safe=True,
+        )

intendant/adapters/go/__init__.py

@@ -0,0 +1,18 @@
+"""Go adapter — language-specific rules."""
+
+from intendant.adapters.go.ci import GO_CI001MinimumSteps
+from intendant.adapters.go.pk import GoMod, GoSum, GoVersion
+from intendant.adapters.go.qu import GoLinter
+from intendant.adapters.go.sa import GO_SA001GitignoreBaseline
+from intendant.adapters.go.ts import GoTestFiles
+from intendant.core.rule import Rule
+
+RULES: list[Rule] = [
+    GoMod(),
+    GoSum(),
+    GoVersion(),
+    GoLinter(),
+    GoTestFiles(),
+    GO_CI001MinimumSteps(),
+    GO_SA001GitignoreBaseline(),
+]

intendant/adapters/go/ci.py

@@ -0,0 +1,43 @@
+"""Go adapter GO_CI rules."""
+
+from __future__ import annotations
+
+from intendant.core.repo import Repo
+from intendant.core.rule import CheckResult, Rule
+
+
+class GO_CI001MinimumSteps(Rule):  # noqa: N801
+    id = "GO_CI001"
+    title = "CI workflow runs go vet/build, go test, and a linter"
+    severity = "required"
+    stacks = ("go",)
+    handbook_ref = "docs/handbook/03-ci.md#go_ci001"
+
+    def check(self, repo: Repo) -> CheckResult:
+        wf_dir = repo.path / ".github" / "workflows"
+        if not wf_dir.is_dir():
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="no .github/workflows/ directory (covered by CI001)",
+            )
+        contents = "\n".join(p.read_text(errors="replace") for p in wf_dir.glob("*.yml"))
+        contents += "\n".join(p.read_text(errors="replace") for p in wf_dir.glob("*.yaml"))
+        missing: list[str] = []
+        build_markers = ("go vet", "go build")
+        if not any(m in contents for m in build_markers):
+            missing.append("build (go vet / go build)")
+        if "go test" not in contents:
+            missing.append("test (go test)")
+        lint_markers = ("golangci-lint", "gofmt", "staticcheck", "revive")
+        if not any(m in contents for m in lint_markers):
+            missing.append("lint (golangci-lint / gofmt / staticcheck / revive)")
+        if missing:
+            return CheckResult(
+                passing=False,
+                evidence=f"CI workflow(s) missing Go steps: {missing}",
+            )
+        return CheckResult(
+            passing=True,
+            evidence="CI workflow(s) include Go build+test+lint",
+        )

intendant/adapters/go/inspectors.py

@@ -0,0 +1,58 @@
+"""Helpers shared by Go rule check methods."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+_MODULE_RE = re.compile(r"^module\s+(\S+)\s*$", re.MULTILINE)
+_GO_DIRECTIVE_RE = re.compile(r"^go\s+(\d+\.\d+(?:\.\d+)?)\s*$", re.MULTILINE)
+_TEST_FUNC_RE = re.compile(r"^func\s+Test[A-Z_]\w*\s*\(", re.MULTILINE)
+
+
+@dataclass(frozen=True)
+class GoMod:
+    module: str | None
+    go_version: str | None
+
+
+def has_go_mod(repo_path: Path) -> bool:
+    return (repo_path / "go.mod").is_file()
+
+
+def load_go_mod(repo_path: Path) -> GoMod | None:
+    """Parse go.mod for the `module` and `go` directives. None if missing/unreadable."""
+    path = repo_path / "go.mod"
+    if not path.is_file():
+        return None
+    try:
+        text = path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        return None
+    module_match = _MODULE_RE.search(text)
+    go_match = _GO_DIRECTIVE_RE.search(text)
+    return GoMod(
+        module=module_match.group(1) if module_match else None,
+        go_version=go_match.group(1) if go_match else None,
+    )
+
+
+def find_test_files(repo_path: Path) -> list[Path]:
+    """Return *_test.go files containing a `func Test*(` declaration.
+
+    Walks the repo, skipping `vendor/`, `node_modules/`, `.git/`, and any
+    hidden directories at the top level.
+    """
+    hits: list[Path] = []
+    skip_dirs = {"vendor", "node_modules", ".git", "target", "dist"}
+    for test_file in repo_path.rglob("*_test.go"):
+        rel_parts = test_file.relative_to(repo_path).parts[:-1]
+        if any(p in skip_dirs or p.startswith(".") for p in rel_parts):
+            continue
+        try:
+            if _TEST_FUNC_RE.search(test_file.read_text(errors="replace")):
+                hits.append(test_file)
+        except OSError:
+            continue
+    return hits

intendant/adapters/go/pk.py

@@ -0,0 +1,65 @@
+"""Go adapter GO_PK (packaging) rules."""
+
+from __future__ import annotations
+
+from intendant.adapters.go.inspectors import has_go_mod, load_go_mod
+from intendant.core.repo import Repo
+from intendant.core.rule import CheckResult, Rule
+
+
+class GoMod(Rule):
+    id = "GO_PK001"
+    title = "go.mod present at repo root with module declaration"
+    severity = "required"
+    stacks = ("go",)
+    handbook_ref = "docs/handbook/12-go.md#go_pk001"
+
+    def check(self, repo: Repo) -> CheckResult:
+        if not has_go_mod(repo.path):
+            return CheckResult(passing=False, evidence="go.mod not found at repo root")
+        mod = load_go_mod(repo.path)
+        if mod is None or mod.module is None:
+            return CheckResult(
+                passing=False,
+                evidence="go.mod missing `module <path>` directive",
+            )
+        return CheckResult(passing=True, evidence=f"module declared: {mod.module}")
+
+
+class GoSum(Rule):
+    id = "GO_PK002"
+    title = "go.sum present at repo root"
+    severity = "required"
+    stacks = ("go",)
+    handbook_ref = "docs/handbook/12-go.md#go_pk002"
+
+    def check(self, repo: Repo) -> CheckResult:
+        if (repo.path / "go.sum").is_file():
+            return CheckResult(passing=True, evidence="go.sum present")
+        return CheckResult(
+            passing=False,
+            evidence="go.sum not found (run `go mod tidy` then commit it)",
+        )
+
+
+class GoVersion(Rule):
+    id = "GO_PK003"
+    title = "go directive pinned in go.mod"
+    severity = "recommended"
+    stacks = ("go",)
+    handbook_ref = "docs/handbook/12-go.md#go_pk003"
+
+    def check(self, repo: Repo) -> CheckResult:
+        mod = load_go_mod(repo.path)
+        if mod is None:
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence="go.mod missing or unreadable (covered by GO_PK001)",
+            )
+        if mod.go_version:
+            return CheckResult(passing=True, evidence=f"go version pinned: {mod.go_version}")
+        return CheckResult(
+            passing=False,
+            evidence="no `go <version>` directive in go.mod",
+        )

intendant/adapters/go/qu.py

@@ -0,0 +1,30 @@
+"""Go adapter GO_QU (quality) rules."""
+
+from __future__ import annotations
+
+from intendant.core.repo import Repo
+from intendant.core.rule import CheckResult, Rule
+
+_GOLANGCI_CONFIGS = (
+    ".golangci.yml",
+    ".golangci.yaml",
+    ".golangci.toml",
+    ".golangci.json",
+)
+
+
+class GoLinter(Rule):
+    id = "GO_QU001"
+    title = "golangci-lint config present"
+    severity = "recommended"
+    stacks = ("go",)
+    handbook_ref = "docs/handbook/12-go.md#go_qu001"
+
+    def check(self, repo: Repo) -> CheckResult:
+        present = [name for name in _GOLANGCI_CONFIGS if (repo.path / name).is_file()]
+        if present:
+            return CheckResult(passing=True, evidence=f"linter config present: {present}")
+        return CheckResult(
+            passing=False,
+            evidence=f"no golangci-lint config (looked for {list(_GOLANGCI_CONFIGS)})",
+        )

intendant/adapters/go/sa.py

@@ -0,0 +1,33 @@
+"""Go adapter GO_SA rules."""
+
+from __future__ import annotations
+
+from intendant.core.repo import Repo
+from intendant.core.rule import CheckResult, Rule
+
+_GO_GITIGNORE_BASELINE = ("*.test",)
+
+
+class GO_SA001GitignoreBaseline(Rule):  # noqa: N801
+    id = "GO_SA001"
+    title = "Go .gitignore baseline (*.test)"
+    severity = "required"
+    stacks = ("go",)
+    handbook_ref = "docs/handbook/06-sanitizing.md#go_sa001"
+
+    def check(self, repo: Repo) -> CheckResult:
+        path = repo.path / ".gitignore"
+        if not path.is_file():
+            return CheckResult(
+                passing=True,
+                skipped=True,
+                evidence=".gitignore not found (covered by SA004)",
+            )
+        text = path.read_text()
+        missing = [p for p in _GO_GITIGNORE_BASELINE if p not in text]
+        if missing:
+            return CheckResult(
+                passing=False,
+                evidence=f"missing Go baseline patterns in .gitignore: {missing}",
+            )
+        return CheckResult(passing=True, evidence="Go baseline patterns present")