@event4u/agent-config 6.1.0 → 7.0.0

package/src/scripts/lint_load_context.py

@@ -1,196 +0,0 @@
-#!/usr/bin/env python3
-"""Lint the `load_context:` / `load_context_eager:` frontmatter schema.
-
-Validates per docs/contracts/load-context-schema.md:
-  - Paths exist and are .md
-  - Allowed roots only (dist/agent-src*/contexts/, agents/settings/contexts/)
-  - No public→project-local leak (warn)
-  - No circular refs across lazy + eager edges
-  - Combined char-budget for eager edges (rule + eager targets ≤ cap)
-
-Exits non-zero on error; warnings are reported but do not fail.
-Used in CI via `task lint-load-context`.
-"""
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-from typing import Iterable
-
-import yaml
-
-QUIET = "--quiet" in sys.argv
-
-ROOT = Path(__file__).resolve().parent.parent.parent
-
-SCAN_DIRS = [
-    ROOT / ".agent-src.uncondensed" / "rules",
-    ROOT / ".agent-src.uncondensed" / "contexts",
-    ROOT / "agents" / "contexts",
-]
-
-ALLOWED_PREFIXES = (
-    "contexts/",                               # logical name (canonical — P1.1 / P5.3)
-    "dist/agent-src/contexts/",                    # projected (defensive — only seen in condensed inputs)
-    "agents/settings/contexts/",                        # project-local
-)
-
-# `.agent-src.uncondensed/contexts/` was the legacy fully-qualified form
-# (pre road-to-path-fixes.md P5.3). It is now a hard error: P2.1 migrated
-# all in-tree rules to logical names, the rewriter resolves them at
-# condense time, and the schema regex in `scripts/schemas/rule.schema.json`
-# rejects the prefix at validate-schema time. Keeping a separate runtime
-# diagnostic so the failure points authors at the canonical
-# `contexts/<area>/<file>.md` form rather than a generic schema mismatch.
-LEGACY_PREFIX = ".agent-src.uncondensed/contexts/"
-
-# Logical names resolve against the source root.
-SOURCE_ROOT = ROOT / ".agent-src.uncondensed"
-
-PUBLIC_RULE_PREFIX = ".agent-src.uncondensed/rules/"
-PROJECT_LOCAL_PREFIX = "agents/settings/contexts/"
-
-
-def resolve_entry(entry: str) -> Path:
-    """Resolve a `load_context:` entry to an absolute path on disk.
-
-    Logical names (`contexts/...`) live under `.agent-src.uncondensed/`;
-    fully-qualified entries are repo-root-relative.
-    """
-    if entry.startswith("contexts/"):
-        return SOURCE_ROOT / entry
-    return ROOT / entry
-
-HARD_FLOOR_RULES = {"non-destructive-by-default", "security-sensitive-stop"}
-
-CAP_ALWAYS = 2_500
-CAP_AUTO = 4_000
-CAP_SAFETY = 5_000
-
-
-def parse_frontmatter(path: Path) -> dict:
-    text = path.read_text(encoding="utf-8")
-    if not text.startswith("---\n"):
-        return {}
-    end = text.find("\n---\n", 4)
-    if end == -1:
-        return {}
-    try:
-        data = yaml.safe_load(text[4:end])
-    except yaml.YAMLError:
-        return {}
-    return data if isinstance(data, dict) else {}
-
-
-def collect_files() -> Iterable[Path]:
-    for d in SCAN_DIRS:
-        if d.exists():
-            yield from d.rglob("*.md")
-
-
-def rel(p: Path) -> str:
-    return p.relative_to(ROOT).as_posix()
-
-
-def cap_for(rule_path: Path, fm: dict) -> int:
-    if rule_path.stem in HARD_FLOOR_RULES:
-        return CAP_SAFETY
-    rtype = (fm.get("type") or "").strip('"').strip("'")
-    if rtype == "always":
-        return CAP_ALWAYS
-    if rtype == "auto":
-        return CAP_AUTO
-    return CAP_AUTO  # default for non-rule contexts cited in eager (won't trigger)
-
-
-def find_cycles(graph: dict[str, list[str]]) -> list[list[str]]:
-    cycles: list[list[str]] = []
-    visiting: set[str] = set()
-    visited: set[str] = set()
-    stack: list[str] = []
-
-    def dfs(node: str) -> None:
-        if node in visiting:
-            i = stack.index(node)
-            cycles.append(stack[i:] + [node])
-            return
-        if node in visited:
-            return
-        visiting.add(node)
-        stack.append(node)
-        for nxt in graph.get(node, []):
-            dfs(nxt)
-        stack.pop()
-        visiting.discard(node)
-        visited.add(node)
-
-    for n in graph:
-        dfs(n)
-    return cycles
-
-
-def main() -> int:
-    errors: list[str] = []
-    warnings: list[str] = []
-    graph: dict[str, list[str]] = {}
-
-    for f in collect_files():
-        fm = parse_frontmatter(f)
-        lazy = fm.get("load_context") or []
-        eager = fm.get("load_context_eager") or []
-        if not (lazy or eager):
-            continue
-        if not isinstance(lazy, list) or not isinstance(eager, list):
-            errors.append(f"{rel(f)}: load_context* must be a list")
-            continue
-
-        edges = list(lazy) + list(eager)
-        graph[rel(f)] = edges
-
-        for entry in edges:
-            if not isinstance(entry, str) or not entry.endswith(".md"):
-                errors.append(f"{rel(f)}: entry not str ending in .md → {entry!r}")
-                continue
-            if entry.startswith(LEGACY_PREFIX):
-                logical = entry[len(".agent-src.uncondensed/"):]
-                errors.append(
-                    f"{rel(f)}: legacy `.agent-src.uncondensed/` prefix in load_context → {entry} "
-                    f"— use logical name `{logical}` instead (road-to-path-fixes.md P5.3)"
-                )
-                continue
-            if not entry.startswith(ALLOWED_PREFIXES):
-                errors.append(f"{rel(f)}: disallowed root → {entry}")
-                continue
-            target = resolve_entry(entry)
-            if not target.exists():
-                errors.append(f"{rel(f)}: target missing → {entry}")
-                continue
-            if rel(f).startswith(PUBLIC_RULE_PREFIX) and entry.startswith(PROJECT_LOCAL_PREFIX):
-                warnings.append(f"{rel(f)}: public rule references project-local context → {entry}")
-
-        if eager:
-            cap = cap_for(f, fm)
-            total = len(f.read_text(encoding="utf-8"))
-            for entry in eager:
-                tgt = resolve_entry(entry)
-                if tgt.exists():
-                    total += len(tgt.read_text(encoding="utf-8"))
-            if total > cap:
-                errors.append(f"{rel(f)}: eager-load combined chars {total} > cap {cap}")
-
-    for cycle in find_cycles(graph):
-        errors.append("circular load_context: " + " → ".join(cycle))
-
-    for w in warnings:
-        print(f"⚠️  {w}")
-    for e in errors:
-        print(f"❌  {e}")
-    if errors:
-        return 1
-    if not QUIET:
-        print(f"✅  load_context schema clean ({len(graph)} declarer(s))")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/lint_marketplace.py

@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-"""
-Lint .claude-plugin/marketplace.json for the event4u/agent-config package.
-
-Validates the Claude Code Plugin Marketplace manifest against the canonical
-manifest shape:
-
-  - Required top-level fields: name, owner, metadata, plugins
-  - owner must have name + email
-  - metadata must have description + version
-  - metadata.version must match package.json (single source of truth)
-  - every plugins[].skills[] entry must exist on disk and carry a SKILL.md
-  - every SKILL.md on disk under .claude/skills/ must be listed in some
-    plugin's skills[] (drift detection)
-
-Exit codes: 0 = clean, 1 = problems found, 3 = internal error.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-from pathlib import Path
-
-ROOT = Path(".")
-MARKETPLACE = ROOT / ".claude-plugin" / "marketplace.json"
-PACKAGE_JSON = ROOT / "package.json"
-# Committed marketplace skill sources (git-consumed): real skills resolve to
-# dist/agent-src/skills/<name>; command-as-skill entries to the committed
-# .claude-plugin/skills/<slug> projection. .claude/skills/ is a gitignored
-# local channel and is intentionally NOT a marketplace source.
-SKILL_SOURCE_DIRS = (
-    ROOT / "dist/agent-src" / "skills",
-    ROOT / ".claude-plugin" / "skills",
-)
-
-
-def fail(errors: list[str]) -> int:
-    print("❌  marketplace.json has problems:")
-    for e in errors:
-        print(f"  - {e}")
-    return 1
-
-
-def require_key(obj: dict, key: str, where: str, errors: list[str]) -> bool:
-    if key not in obj:
-        errors.append(f"missing key `{key}` in {where}")
-        return False
-    return True
-
-
-def main() -> int:
-    if not MARKETPLACE.exists():
-        print(f"❌  {MARKETPLACE} not found")
-        return 1
-
-    try:
-        data = json.loads(MARKETPLACE.read_text())
-    except json.JSONDecodeError as e:
-        print(f"❌  {MARKETPLACE} is not valid JSON: {e}")
-        return 1
-
-    errors: list[str] = []
-
-    # Top-level required fields
-    for k in ("name", "owner", "metadata", "plugins"):
-        require_key(data, k, "marketplace root", errors)
-
-    # Owner
-    owner = data.get("owner", {})
-    if isinstance(owner, dict):
-        for k in ("name", "email"):
-            require_key(owner, k, "owner", errors)
-    else:
-        errors.append("`owner` must be an object")
-
-    # Metadata + version sync
-    metadata = data.get("metadata", {})
-    if isinstance(metadata, dict):
-        for k in ("description", "version"):
-            require_key(metadata, k, "metadata", errors)
-        mp_version = metadata.get("version")
-        if mp_version and PACKAGE_JSON.exists():
-            pkg = json.loads(PACKAGE_JSON.read_text())
-            pkg_version = pkg.get("version")
-            if pkg_version and mp_version != pkg_version:
-                errors.append(
-                    f"metadata.version `{mp_version}` does not match "
-                    f"package.json version `{pkg_version}`"
-                )
-    else:
-        errors.append("`metadata` must be an object")
-
-    # Plugins
-    plugins = data.get("plugins", [])
-    if not isinstance(plugins, list) or not plugins:
-        errors.append("`plugins` must be a non-empty array")
-        plugins = []
-
-    for idx, plugin in enumerate(plugins):
-        where = f"plugins[{idx}]"
-        if not isinstance(plugin, dict):
-            errors.append(f"{where} must be an object")
-            continue
-        for k in ("name", "description", "source", "skills"):
-            require_key(plugin, k, where, errors)
-
-        skills = plugin.get("skills", [])
-        if not isinstance(skills, list):
-            errors.append(f"{where}.skills must be an array")
-            continue
-
-        seen: set[str] = set()
-        for s_idx, path in enumerate(skills):
-            entry = f"{where}.skills[{s_idx}]"
-            if not isinstance(path, str):
-                errors.append(f"{entry} must be a string")
-                continue
-            if path in seen:
-                errors.append(f"{entry} is a duplicate: `{path}`")
-            seen.add(path)
-
-            # Resolve path relative to repo root (strip leading "./" only,
-            # NOT every "." and "/" character)
-            rel = path.removeprefix("./")
-            skill_dir = ROOT / rel
-            if not skill_dir.exists():
-                errors.append(f"{entry} path does not exist: `{path}`")
-                continue
-            skill_md = skill_dir / "SKILL.md"
-            if not skill_md.exists():
-                errors.append(f"{entry} has no SKILL.md: `{path}`")
-
-    # Reverse-completeness: every SKILL.md on disk under the committed skill
-    # sources (dist/agent-src/skills/ + .claude-plugin/skills/) must appear in some
-    # plugin's skills[]. Catches the drift where new skills/commands are
-    # generated but never added to the marketplace manifest.
-    listed: set[str] = set()
-    for plugin in plugins:
-        if not isinstance(plugin, dict):
-            continue
-        for path in plugin.get("skills", []):
-            if isinstance(path, str):
-                listed.add(path.removeprefix("./"))
-
-    for source_dir in SKILL_SOURCE_DIRS:
-        if not source_dir.exists():
-            continue
-        prefix = source_dir.relative_to(ROOT).as_posix()
-        for skill_dir in sorted(source_dir.iterdir()):
-            if not skill_dir.is_dir():
-                continue
-            if not (skill_dir / "SKILL.md").exists():
-                continue
-            rel = f"{prefix}/{skill_dir.name}"
-            if rel not in listed:
-                errors.append(
-                    f"skill exists on disk but is not listed in marketplace.json: "
-                    f"`./{rel}`"
-                )
-
-    if errors:
-        return fail(errors)
-
-    plugin_count = len(plugins)
-    skill_count = sum(len(p.get("skills", [])) for p in plugins if isinstance(p, dict))
-    print(
-        f"✅  marketplace.json ({plugin_count} plugin"
-        f"{'s' if plugin_count != 1 else ''}, {skill_count} skills total)"
-    )
-    print("  No issues found.")
-    return 0
-
-
-if __name__ == "__main__":
-    try:
-        sys.exit(main())
-    except Exception as exc:  # pragma: no cover
-        print(f"❌  internal error: {exc}", file=sys.stderr)
-        sys.exit(3)

package/src/scripts/lint_marketplace_install_completeness.py

@@ -1,198 +0,0 @@
-#!/usr/bin/env python3
-"""Lint that every command in `hooks/hooks.json` resolves to a real
-dispatcher subcommand in `scripts/_dispatch.bash`.
-
-Phase 6 of `road-to-hooks-actually-fire-in-consumers`.
-
-The linter checks **plugin-side completeness** — the package ships a
-valid `hooks.json` whose every command line points at a subcommand
-the dispatcher knows about. It does NOT check consumer-side
-scaffolding (that's the runtime `dispatch-issues.jsonl` log's job
-from Phase 1).
-
-This distinction is load-bearing — see Council R3 finding #1:
-"A valid plugin against an unscaffolded consumer is a PASS;
-the linter must not produce a false-positive on that state."
-
-Exit codes:
-  0 — every command resolves; clean.
-  1 — at least one command references an unknown subcommand.
-  2 — schema / file error.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-HOOKS_JSON = REPO_ROOT / "hooks" / "hooks.json"
-DISPATCH_BASH = REPO_ROOT / "src" / "scripts" / "_dispatch.bash"
-
-
-# Map agent-config-cli subcommand → dispatcher function name. The
-# subcommand is what appears after `./agent-config <subcommand>` in
-# the hooks.json command line; the function is what's defined in
-# _dispatch.bash. The user-facing subcommand uses colons; the
-# function uses underscores (e.g. `dispatch:hook` → `cmd_dispatch_hook`).
-def subcommand_to_function(subcommand: str) -> str:
-    # Normalise: replace `:` and `-` with `_`.
-    sanitised = subcommand.replace(":", "_").replace("-", "_")
-    return f"cmd_{sanitised}"
-
-
-def load_hook_commands(hooks_path: Path) -> list[tuple[str, str]]:
-    """Return [(event_name, command_line)] for every hook entry."""
-    try:
-        data = json.loads(hooks_path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError) as exc:
-        raise SystemExit(f"lint-marketplace-install: cannot read {hooks_path}: {exc}")
-
-    hooks = data.get("hooks") or {}
-    if not isinstance(hooks, dict):
-        raise SystemExit(f"lint-marketplace-install: {hooks_path} `hooks` is not an object")
-
-    out: list[tuple[str, str]] = []
-    for event, groups in hooks.items():
-        if not isinstance(groups, list):
-            continue
-        for group in groups:
-            if not isinstance(group, dict):
-                continue
-            for entry in group.get("hooks", []) or []:
-                if not isinstance(entry, dict):
-                    continue
-                cmd = entry.get("command")
-                if isinstance(cmd, str) and cmd.strip():
-                    out.append((str(event), cmd))
-    return out
-
-
-# Pattern A: `"$CLAUDE_PROJECT_DIR"/agent-config <subcommand> [args...]`.
-# Accepts both quoted and bare CLAUDE_PROJECT_DIR.
-_CMD_RE = re.compile(
-    r'(?:"?\$\{?CLAUDE_PROJECT_DIR\}?"?/)?agent-config\s+([a-zA-Z0-9:_-]+)'
-)
-# Pattern B (ADR-020 global-binary fallback wrapper):
-#   BIN="$CLAUDE_PROJECT_DIR/agent-config"; [ -x "$BIN" ] || BIN=agent-config;
-#   "$BIN" <subcommand> [args...]
-# The subcommand follows the `"$BIN"` invocation; the wrapper must still
-# resolve an agent-config binary for the line to qualify.
-_BIN_CMD_RE = re.compile(r'"\$\{?BIN\}?"\s+([a-zA-Z0-9:_-]+)')
-
-
-def extract_subcommand(command_line: str) -> str | None:
-    """Pull the agent-config subcommand out of a hooks.json command line."""
-    m = _CMD_RE.search(command_line)
-    if m:
-        return m.group(1)
-    if "agent-config" in command_line:
-        m = _BIN_CMD_RE.search(command_line)
-        if m:
-            return m.group(1)
-    return None
-
-
-def load_dispatcher_subcommands(dispatch_path: Path) -> set[str]:
-    """Return the set of subcommand identifiers the dispatcher knows.
-
-    Reads `cmd_<name>` function definitions from _dispatch.bash and
-    converts back to subcommand form (underscores → colons / hyphens
-    is ambiguous, so we keep BOTH forms in the set — `dispatch_hook`
-    AND `dispatch:hook` — so the linter accepts either).
-    """
-    try:
-        text = dispatch_path.read_text(encoding="utf-8")
-    except OSError as exc:
-        raise SystemExit(f"lint-marketplace-install: cannot read {dispatch_path}: {exc}")
-
-    out: set[str] = set()
-    for match in re.finditer(r"^cmd_([a-zA-Z0-9_]+)\(\)", text, flags=re.MULTILINE):
-        ident = match.group(1)
-        # Add the underscore form.
-        out.add(ident)
-        # Also add a colon-substituted variant — agent-config supports
-        # `:` in user-facing subcommand names; the function strips them
-        # to underscores. We accept either spelling on the hook side.
-        # First _ → `:`, the rest stay (heuristic; covers `dispatch:hook`,
-        # `mcp:render`, `hooks:install` etc.).
-        if "_" in ident:
-            head, _, tail = ident.partition("_")
-            out.add(f"{head}:{tail}")
-    return out
-
-
-def lint(hooks_path: Path = HOOKS_JSON, dispatch_path: Path = DISPATCH_BASH) -> int:
-    if not hooks_path.is_file():
-        sys.stderr.write(f"lint-marketplace-install: {hooks_path} not found\n")
-        return 2
-    if not dispatch_path.is_file():
-        sys.stderr.write(f"lint-marketplace-install: {dispatch_path} not found\n")
-        return 2
-
-    commands = load_hook_commands(hooks_path)
-    known = load_dispatcher_subcommands(dispatch_path)
-
-    issues: list[str] = []
-    checked = 0
-    for event, cmd in commands:
-        sub = extract_subcommand(cmd)
-        if sub is None:
-            issues.append(
-                f"  {event}: command does not reference `agent-config <subcommand>`: "
-                f"{cmd!r}"
-            )
-            continue
-        checked += 1
-        if sub not in known:
-            issues.append(
-                f"  {event}: unknown_dispatcher_subcommand: {sub!r} "
-                f"(not in scripts/_dispatch.bash)"
-            )
-
-    if issues:
-        try:
-            relative = hooks_path.resolve().relative_to(REPO_ROOT)
-        except ValueError:
-            relative = hooks_path
-        sys.stderr.write(
-            f"lint-marketplace-install: {len(issues)} issue(s) in {relative}:\n"
-        )
-        for line in issues:
-            sys.stderr.write(line + "\n")
-        return 1
-
-    print(
-        f"✅  lint-marketplace-install: {checked} hook command(s) checked, "
-        f"all resolve to known dispatcher subcommands."
-    )
-    return 0
-
-
-def parse_args(argv: list[str]) -> argparse.Namespace:
-    p = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    p.add_argument(
-        "--hooks-json",
-        type=Path,
-        default=HOOKS_JSON,
-        help="Path to hooks/hooks.json (default: %(default)s)",
-    )
-    p.add_argument(
-        "--dispatch-bash",
-        type=Path,
-        default=DISPATCH_BASH,
-        help="Path to scripts/_dispatch.bash (default: %(default)s)",
-    )
-    return p.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = parse_args(argv if argv is not None else sys.argv[1:])
-    return lint(args.hooks_json, args.dispatch_bash)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/lint_mcp_config_security.py

@@ -1,124 +0,0 @@
-#!/usr/bin/env python3
-"""P1.3 — MCP-config security linter (road-to-security-pillar.md). OWASP ASI04.
-
-Scans shipped MCP configuration — named config files (``*.mcp.json``,
-``mcp.json``, ``claude_desktop_config.json*``) and fenced ```json blocks that
-declare ``mcpServers`` — for the supply-chain smells behind MCP tool-poisoning
-and rug-pull attacks.
-
-- HIGH (fail): a **real inline secret value** in a shipped config (an actual
-  key, not the bare prefix used as documentation). Secrets belong in
-  ``${env:VAR}``.
-- MED (warn): ``npx -y`` auto-install, unpinned server version, ``autoApprove``
-  / ``enableAllProjectMcpServers``, ``0.0.0.0`` binding, shell metacharacters in
-  args, omnibus scopes (``*`` / ``all`` / ``full-access``), ``*_BASE_URL`` in a
-  project-scoped env. These are smells, not leaks — templates legitimately show
-  them, so they warn (and weight 0.25x in example/template files per P1.5).
-
-Usage: python3 src/scripts/lint_mcp_config_security.py [--json]
-"""
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from _lib import security_lint as sl  # noqa: E402
-
-CHECK = "mcp-config-security"
-
-_NAME_HINTS = re.compile(r"(^|/)(\.mcp\.json|mcp\.json|claude_desktop_config\.json)")
-
-# Real secret VALUES (prefix + enough key chars to be a live credential).
-_SECRET = re.compile(
-    r"sk-ant-[A-Za-z0-9_\-]{20,}"
-    r"|sk-proj-[A-Za-z0-9_\-]{20,}"
-    r"|AKIA[0-9A-Z]{16}"
-    r"|AIza[0-9A-Za-z_\-]{35}"
-    r"|ghp_[0-9A-Za-z]{36}"
-    r"|eyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}"
-)
-
-# Line-level smells (match on a single line).
-_MED = [
-    (re.compile(r"\bautoApprove\b|\benableAllProjectMcpServers\b", re.IGNORECASE), "auto-approve / auto-enable bypasses consent"),
-    (re.compile(r"0\.0\.0\.0"), "0.0.0.0 bind (exposed beyond localhost)"),
-    (re.compile(r'"[^"]*_BASE_URL"\s*:'), "*_BASE_URL in config (request-redirect / token-exfil vector)"),
-    (re.compile(r'"(scopes?|permissions?)"\s*:\s*(\[[^\]]*"(\*|all|full-access)"|"(\*|all|full-access)")', re.IGNORECASE), "omnibus scope (* / all / full-access)"),
-    (re.compile(r'"args"\s*:\s*\[[^\]]*(&&|\|\||;|`)'), "shell metacharacters in args"),
-]
-# Chunk-level smells (span multiple lines in pretty-printed JSON).
-_NPX = re.compile(r'"command"\s*:\s*"(npx|uvx)"', re.IGNORECASE)
-_NPX_YES = re.compile(r'"\s*(-y|--yes)\s*"')
-
-
-def _candidate_chunks(sf: sl.ScannedFile):
-    """Yield (start_lineno, [lines]) for MCP-config regions in this file."""
-    if _NAME_HINTS.search(sf.rel):
-        yield 1, list(enumerate(sf.lines, start=1))
-        return
-    if sf.path.suffix != ".md":
-        return
-    # fenced ```json / ```jsonc blocks that mention mcpServers / command
-    in_block, start, buf = False, 0, []
-    for i, text in enumerate(sf.lines, start=1):
-        st = text.strip()
-        if not in_block and re.match(r"`{3,}(json[c5]?|jsonc)\b", st):
-            in_block, start, buf = True, i, []
-            continue
-        if in_block and re.match(r"`{3,}\s*$", st):
-            joined = "\n".join(t for _, t in buf)
-            if "mcpServers" in joined or '"command"' in joined:
-                yield start, buf
-            in_block, buf = False, []
-            continue
-        if in_block:
-            buf.append((i, text))
-
-
-def _scan(sf: sl.ScannedFile):
-    if sf.pragma_allows(CHECK):
-        return []
-    out = []
-    for start, numbered in _candidate_chunks(sf):
-        for lineno, text in numbered:
-            if _SECRET.search(text):
-                out.append(sl.Finding(sf.rel, lineno, CHECK, "HIGH",
-                                      "inline secret value in MCP config — use ${env:VAR}",
-                                      sf.weight))
-            for rx, label in _MED:
-                if rx.search(text):
-                    out.append(sl.Finding(sf.rel, lineno, CHECK, "MED", label, sf.weight))
-        # chunk-level: npx/uvx auto-install spans command + args lines
-        npx_line = next((ln for ln, t in numbered if _NPX.search(t)), start)
-        chunk = "\n".join(t for _, t in numbered)
-        if _NPX.search(chunk) and _NPX_YES.search(chunk):
-            out.append(sl.Finding(sf.rel, npx_line, CHECK, "MED",
-                                  "npx/uvx -y auto-install (supply-chain risk; pin + pre-install)",
-                                  sf.weight))
-    return out
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__, epilog=sl.GUIDELINE_EPILOG)
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-
-    findings = []
-    # scan .md (fenced examples) under the default roots PLUS named MCP configs
-    # under src/templates (where the shipped claude_desktop_config template lives).
-    roots = (*sl.DEFAULT_SCAN_ROOTS, "src/templates")
-    for sf in sl.iter_corpus(roots=roots, exts=(".md", ".json", ".template")):
-        findings.extend(_scan(sf))
-
-    if args.json:
-        import json
-        print(json.dumps([f.__dict__ for f in findings], indent=2))
-        return 1 if any(f.is_fail for f in findings) else 0
-    return sl.report(findings, check_label="mcp-config-security")
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())