superpowers-manager 0.1.6 → 0.3.0

package/scripts/adapters/codex/lib.sh

@@ -1,391 +0,0 @@
-#!/bin/sh
-# Sourced module; callers own set -eu.
-
-SPW_PLUGIN_ID="superpowers@superpowers-manager"
-SPW_MARKETPLACE_NAME="superpowers-manager"
-SPW_LEGACY_PLUGIN_ID="superpowers@superpowers-wrapper"
-SPW_LEGACY_MARKETPLACE_NAME="superpowers-wrapper"
-
-# Given a JSON document as the FIRST ARGUMENT (a string), print "present" if any
-# element of the top-level array <array_key> is an object whose <field> equals
-# <value>, else print "absent" (exit 0). On unparseable JSON or invalid schema,
-# print nothing and exit 2 so callers can fail closed rather than treat an
-# unreadable listing as "absent". Every item in the inspected array must be an
-# object with a non-empty string <field>; otherwise ownership is unprovable and
-# the helper exits 2 instead of treating the malformed entry as unrelated.
-# The JSON is passed as an argument (exactly as spw_json_get takes a file path),
-# NOT on stdin: the here-doc below is Python's stdin (its program source), so a
-# json.load(sys.stdin) here would read the program, not the caller's JSON.
-spw_json_array_has() {
-  json="$1"
-  array_key="$2"
-  field="$3"
-  value="$4"
-  python3 - "$json" "$array_key" "$field" "$value" <<'PY'
-import json, sys
-raw, array_key, field, value = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
-try:
-    data = json.loads(raw)
-except (json.JSONDecodeError, RecursionError):
-    sys.exit(2)
-if not isinstance(data, dict):
-    sys.exit(2)
-items = data.get(array_key)
-if not isinstance(items, list):
-    sys.exit(2)
-for item in items:
-    if not isinstance(item, dict):
-        sys.exit(2)
-    field_value = item.get(field)
-    if not isinstance(field_value, str) or not field_value:
-        sys.exit(2)
-found = any(item[field] == value for item in items)
-print("present" if found else "absent")
-PY
-}
-
-# Print the registered root of <marketplace_name> from a marketplace-list JSON
-# document (as a string argument, like spw_json_array_has), or nothing if the
-# marketplace is absent. Exit 2 on unparseable JSON, a non-object item, or an
-# item without a non-empty string name: such an item cannot be proven unrelated
-# and must not be mistaken for an absent manager marketplace. Validate root only
-# on the matching item; unrelated marketplace roots are never read. A matching
-# item without a non-empty string root also exits 2. Empty output is unambiguous:
-# a valid registered root is always a non-empty path.
-spw_marketplace_root_from_json() {
-  json="$1"
-  marketplace_name="$2"
-  python3 - "$json" "$marketplace_name" <<'PY'
-import json, sys
-raw, name = sys.argv[1], sys.argv[2]
-try:
-    data = json.loads(raw)
-except (json.JSONDecodeError, RecursionError):
-    sys.exit(2)
-if not isinstance(data, dict):
-    sys.exit(2)
-items = data.get("marketplaces")
-if not isinstance(items, list):
-    sys.exit(2)
-for item in items:
-    if not isinstance(item, dict):
-        sys.exit(2)
-    item_name = item.get("name")
-    if not isinstance(item_name, str) or not item_name:
-        sys.exit(2)
-for item in items:
-    if item["name"] == name:
-        item_root = item.get("root")
-        if not isinstance(item_root, str) or not item_root:
-            sys.exit(2)
-        print(item_root)
-        sys.exit(0)
-PY
-}
-
-# Print "same" if the two paths refer to the same physical location, else
-# "different". Physical-path normalization via os.path.realpath on both
-# sides (handles /var vs /private/var and other symlinked roots); if
-# realpath fails, fall back to comparing the original strings.
-spw_paths_equal() {
-  python3 - "$1" "$2" <<'PY'
-import os, sys
-a, b = sys.argv[1], sys.argv[2]
-try:
-    na, nb = os.path.realpath(a), os.path.realpath(b)
-except OSError:
-    na, nb = a, b
-print("same" if na == nb else "different")
-PY
-}
-
-spw_find_installed_metadata() {
-  search_root="${SUPERPOWERS_INSTALLED_SEARCH_ROOT:-$HOME/.codex}"
-  find "$search_root" \
-    \( -path "*/$SPW_MARKETPLACE_NAME/superpowers/.superpowers-upstream.json" \
-       -o -path "*/$SPW_MARKETPLACE_NAME/superpowers/*/.superpowers-upstream.json" \) \
-    -type f 2>/dev/null | head -n 1
-}
-
-spw_find_installed_manifest() {
-  search_root="${SUPERPOWERS_INSTALLED_SEARCH_ROOT:-$HOME/.codex}"
-  find "$search_root" \
-    \( -path "*/$SPW_MARKETPLACE_NAME/superpowers/.codex-plugin/plugin.json" \
-       -o -path "*/$SPW_MARKETPLACE_NAME/superpowers/*/.codex-plugin/plugin.json" \) \
-    -type f 2>/dev/null | head -n 1
-}
-
-spw_codex_json_get_or_empty() {
-  file="$1"
-  key="$2"
-  [ -f "$file" ] || return 1
-  python3 - "$file" "$key" <<'PY'
-import json
-import sys
-
-path, dotted_key = sys.argv[1:]
-MAX_JSON_NESTING = 256
-
-def reject_constant(constant):
-    raise ValueError(f"non-standard numeric constant: {constant}")
-
-def nesting_exceeds_limit(value):
-    stack = [(value, 0)]
-    while stack:
-        current, depth = stack.pop()
-        if isinstance(current, dict):
-            next_depth = depth + 1
-            if next_depth > MAX_JSON_NESTING:
-                return True
-            stack.extend((child, next_depth) for child in current.values())
-        elif isinstance(current, list):
-            next_depth = depth + 1
-            if next_depth > MAX_JSON_NESTING:
-                return True
-            stack.extend((child, next_depth) for child in current)
-    return False
-
-try:
-    with open(path, "r", encoding="utf-8") as handle:
-        data = json.load(handle, parse_constant=reject_constant)
-except (OSError, UnicodeError, json.JSONDecodeError, RecursionError, ValueError):
-    sys.exit(1)
-
-if nesting_exceeds_limit(data) or not isinstance(data, dict):
-    sys.exit(1)
-
-value = data
-for part in dotted_key.split("."):
-    if not isinstance(value, dict):
-        value = ""
-        break
-    value = value.get(part, "")
-
-if value is None:
-    value = ""
-if not isinstance(value, str):
-    sys.exit(1)
-print(value)
-PY
-}
-
-spw_codex_metadata_commit_or_empty() {
-  file="$1"
-  if ! commit=$(spw_codex_json_get_or_empty "$file" "commit"); then
-    return 1
-  fi
-  case "$commit" in
-    ""|*[!0-9a-fA-F]*) return 1 ;;
-  esac
-  case "${#commit}" in
-    7|40) printf '%s\n' "$commit" ;;
-    *) return 1 ;;
-  esac
-}
-
-spw_apply_manifest_overlay() {
-  manifest="$1"
-  version="$2"
-  python3 - "$manifest" "$version" <<'PY'
-import json
-import sys
-
-path, version = sys.argv[1:]
-MAX_JSON_NESTING = 256
-
-def reject_constant(constant):
-    raise ValueError(f"non-standard numeric constant: {constant}")
-
-def nesting_exceeds_limit(value):
-    stack = [(value, 0)]
-    while stack:
-        current, depth = stack.pop()
-        if isinstance(current, dict):
-            next_depth = depth + 1
-            if next_depth > MAX_JSON_NESTING:
-                return True
-            stack.extend((child, next_depth) for child in current.values())
-        elif isinstance(current, list):
-            next_depth = depth + 1
-            if next_depth > MAX_JSON_NESTING:
-                return True
-            stack.extend((child, next_depth) for child in current)
-    return False
-
-try:
-    with open(path, "r", encoding="utf-8") as f:
-        data = json.load(f, parse_constant=reject_constant)
-except RecursionError:
-    sys.exit(f"JSON nesting exceeds limit in {path}")
-except json.JSONDecodeError as exc:
-    sys.exit(
-        f"invalid manifest JSON in {path}: "
-        f"line {exc.lineno} column {exc.colno}: {exc.msg}"
-    )
-except (OSError, UnicodeError) as exc:
-    sys.exit(f"cannot read manifest JSON in {path}: {exc}")
-except ValueError as exc:
-    sys.exit(f"invalid manifest JSON in {path}: {exc}")
-
-if nesting_exceeds_limit(data):
-    sys.exit(f"JSON nesting exceeds limit in {path}")
-
-if not isinstance(data, dict):
-    sys.exit(f"manifest must be a JSON object: {path}")
-
-data["version"] = version
-data["skills"] = "./skills/"
-data.pop("hooks", None)
-
-try:
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2, allow_nan=False)
-        f.write("\n")
-except RecursionError as exc:
-    sys.exit(f"manifest JSON nesting exceeds limit while writing {path}: {exc}")
-except (OSError, UnicodeError, ValueError) as exc:
-    sys.exit(f"cannot write manifest JSON in {path}: {exc}")
-PY
-}
-
-spw_manifest_short_sha_or_empty() {
-  file="$1"
-  if ! version=$(spw_codex_json_get_or_empty "$file" "version"); then
-    return 1
-  fi
-  case "$version" in
-    *+manager.*)
-      short="${version##*.}"
-      case "$short" in
-        [0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])
-          printf '%s\n' "$short"
-          ;;
-      esac
-      ;;
-  esac
-}
-
-spw_installed_commit_or_empty() {
-  installed_metadata=$(spw_find_installed_metadata || true)
-  installed_manifest=$(spw_find_installed_manifest || true)
-  installed_commit=""
-  if [ -n "$installed_metadata" ]; then
-    installed_commit=$(spw_codex_metadata_commit_or_empty "$installed_metadata" || true)
-  fi
-  if [ -z "$installed_commit" ] && [ -n "$installed_manifest" ]; then
-    installed_commit=$(spw_manifest_short_sha_or_empty "$installed_manifest" || true)
-  fi
-  printf '%s\n' "$installed_commit"
-}
-
-spw_codex_emit() {
-  operation="$1"
-  ok="$2"
-  result_json="$3"
-  code="$4"
-  error_message="$5"
-  hints_file="$6"
-  messages_file="$7"
-  python3 - "$operation" "$ok" "$result_json" "$code" "$error_message" "$hints_file" "$messages_file" <<'PY'
-import json
-import sys
-
-operation, ok_text, result_text, code, error_message, hints_path, messages_path = sys.argv[1:]
-
-def has_terminal_control(value):
-    return any(
-        ord(char) < 0x20
-        or 0x7f <= ord(char) <= 0x9f
-        or 0xd800 <= ord(char) <= 0xdfff
-        for char in value
-    )
-
-if any(has_terminal_control(value) for value in (operation, code, error_message)):
-    raise SystemExit("protocol strings must not contain terminal control characters")
-
-messages = []
-if messages_path:
-    with open(messages_path, encoding="utf-8") as handle:
-        for number, raw in enumerate(handle, 1):
-            line = raw.rstrip("\n")
-            if "\t" not in line:
-                raise SystemExit(f"invalid message record at line {number}")
-            channel, text = line.split("\t", 1)
-            if (
-                channel not in {"stdout", "stderr"}
-                or not text
-                or "\t" in text
-                or "\r" in text
-                or has_terminal_control(text)
-            ):
-                raise SystemExit(f"invalid message record at line {number}")
-            messages.append({"channel": channel, "text": text})
-
-ok = ok_text == "true"
-if ok:
-    envelope = {
-        "protocol": 1,
-        "operation": operation,
-        "ok": True,
-        "messages": messages,
-        "result": json.loads(result_text),
-        "error": None,
-    }
-else:
-    hints = []
-    if hints_path:
-        with open(hints_path, encoding="utf-8") as handle:
-            hints = [line.rstrip("\n") for line in handle if line.rstrip("\n")]
-    if any(has_terminal_control(hint) for hint in hints):
-        raise SystemExit("protocol hints must not contain terminal control characters")
-    envelope = {
-        "protocol": 1,
-        "operation": operation,
-        "ok": False,
-        "messages": messages,
-        "result": None,
-        "error": {"code": code, "message": error_message, "hints": hints},
-    }
-json.dump(envelope, sys.stdout, allow_nan=False, separators=(",", ":"))
-sys.stdout.write("\n")
-PY
-}
-
-spw_codex_success() {
-  spw_codex_emit "$1" true "$2" "" "" "" "$3"
-}
-
-spw_codex_failure() {
-  spw_codex_emit "$1" false '{}' "$2" "$3" "$4" "$5"
-  exit 1
-}
-
-# Append command output as structured message records while keeping the
-# tab-delimited spool format unambiguous. Each physical command-output line is
-# escaped with Python's unicode_escape codec so literal backslashes remain
-# distinguishable from rendered control characters like \t and \r.
-spw_codex_append_messages() {
-  messages_file="$1"
-  channel="$2"
-  input_file="$3"
-  [ -f "$input_file" ] || return 0
-  python3 - "$messages_file" "$channel" "$input_file" <<'PY'
-from pathlib import Path
-import sys
-
-messages_path = Path(sys.argv[1])
-channel = sys.argv[2]
-input_path = Path(sys.argv[3])
-
-chunks = input_path.read_bytes().split(b"\n")
-with messages_path.open("a", encoding="utf-8") as handle:
-    for chunk in chunks:
-        if not chunk:
-            continue
-        text = chunk.decode("utf-8", errors="backslashreplace")
-        escaped = text.encode("unicode_escape").decode("ascii")
-        if not escaped:
-            continue
-        handle.write(f"{channel}\t{escaped}\n")
-PY
-}

package/scripts/adapters/codex/validate-generated-plugin.py

@@ -1,314 +0,0 @@
-#!/usr/bin/env python3
-"""Validate the manager-owned generated Superpowers plugin contract."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import re
-import sys
-from pathlib import Path
-from typing import Any, Sequence
-
-
-SEMVER_RE = re.compile(
-    r"^(0|[1-9][0-9]*)\."
-    r"(0|[1-9][0-9]*)\."
-    r"(0|[1-9][0-9]*)"
-    r"(?:-(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*)"
-    r"(?:\.(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*))*)?"
-    r"(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$"
-)
-MAX_JSON_NESTING = 256
-PROVENANCE_KEYS = {
-    "source",
-    "requested_ref",
-    "resolved_ref",
-    "commit",
-    "upstream_manifest_version",
-}
-
-
-def reject_json_constant(constant: str) -> None:
-    raise ValueError(f"non-standard numeric constant: {constant}")
-
-
-def json_nesting_exceeds_limit(value: Any) -> bool:
-    stack = [(value, 0)]
-    while stack:
-        current, depth = stack.pop()
-        if isinstance(current, dict):
-            next_depth = depth + 1
-            if next_depth > MAX_JSON_NESTING:
-                return True
-            stack.extend((child, next_depth) for child in current.values())
-        elif isinstance(current, list):
-            next_depth = depth + 1
-            if next_depth > MAX_JSON_NESTING:
-                return True
-            stack.extend((child, next_depth) for child in current)
-    return False
-
-
-def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Validate a generated Superpowers manager candidate."
-    )
-    parser.add_argument("--plugin-root", required=True)
-    parser.add_argument("--source", required=True)
-    parser.add_argument("--requested-ref", required=True)
-    parser.add_argument("--resolved-ref", required=True)
-    parser.add_argument("--commit", required=True)
-    parser.add_argument("--manifest-version", required=True)
-    parser.add_argument("--upstream-manifest-version", required=True)
-    return parser.parse_args(argv)
-
-
-def load_json_object(path: Path, label: str, errors: list[str]) -> dict[str, Any] | None:
-    try:
-        text = path.read_text(encoding="utf-8")
-    except (OSError, UnicodeError):
-        errors.append(f"{label} is unreadable UTF-8")
-        return None
-    try:
-        value = json.loads(text, parse_constant=reject_json_constant)
-    except RecursionError:
-        errors.append(f"{label} exceeds maximum JSON nesting")
-        return None
-    except (json.JSONDecodeError, ValueError):
-        errors.append(f"{label} must contain valid JSON")
-        return None
-    if json_nesting_exceeds_limit(value):
-        errors.append(f"{label} exceeds maximum JSON nesting")
-        return None
-    if not isinstance(value, dict):
-        errors.append(f"{label} must contain a JSON object")
-        return None
-    return value
-
-
-def validate_local_path(
-    plugin_root: Path,
-    raw_value: Any,
-    label: str,
-    errors: list[str],
-    *,
-    require_directory: bool = False,
-) -> None:
-    if not isinstance(raw_value, str) or not raw_value.strip():
-        errors.append(f"{label} must be a non-empty relative path")
-        return
-    raw_path = Path(raw_value)
-    if raw_path.is_absolute():
-        errors.append(f"{label} must be a relative path")
-        return
-    try:
-        root = plugin_root.resolve()
-        target = (root / raw_path).resolve(strict=False)
-    except (OSError, RuntimeError, ValueError):
-        errors.append(f"{label} could not be resolved")
-        return
-    try:
-        target.relative_to(root)
-    except ValueError:
-        errors.append(f"{label} escapes the plugin root")
-        return
-    try:
-        if not target.exists():
-            errors.append(f"{label} target `{raw_value}` does not exist")
-        elif require_directory and not target.is_dir():
-            errors.append(f"{label} target `{raw_value}` must be a directory")
-    except OSError:
-        errors.append(f"{label} target `{raw_value}` could not be inspected")
-
-
-def validate_manifest(plugin_root: Path, expected_version: str, errors: list[str]) -> None:
-    path = plugin_root / ".codex-plugin" / "plugin.json"
-    if not path.is_file():
-        errors.append("missing required file `.codex-plugin/plugin.json`")
-        return
-    manifest = load_json_object(path, "plugin manifest", errors)
-    if manifest is None:
-        return
-
-    if manifest.get("name") != "superpowers":
-        errors.append("plugin manifest field `name` must equal `superpowers`")
-    version = manifest.get("version")
-    if version != expected_version:
-        errors.append("plugin manifest field `version` must equal expected version")
-    if not isinstance(version, str) or SEMVER_RE.fullmatch(version) is None:
-        errors.append("plugin manifest field `version` must be SemVer 2.0.0")
-    description = manifest.get("description")
-    if not isinstance(description, str) or not description.strip():
-        errors.append("plugin manifest field `description` must be non-empty")
-    if manifest.get("skills") != "./skills/":
-        errors.append("plugin manifest field `skills` must equal `./skills/`")
-    if "hooks" in manifest:
-        errors.append("plugin manifest field `hooks` must be absent")
-
-    validate_local_path(
-        plugin_root,
-        manifest.get("skills"),
-        "plugin manifest field `skills`",
-        errors,
-        require_directory=True,
-    )
-    if "apps" in manifest:
-        validate_local_path(plugin_root, manifest["apps"], "plugin manifest field `apps`", errors)
-    if "mcpServers" in manifest:
-        mcp_servers = manifest["mcpServers"]
-        if isinstance(mcp_servers, str):
-            validate_local_path(
-                plugin_root, mcp_servers, "plugin manifest field `mcpServers`", errors
-            )
-        elif not isinstance(mcp_servers, dict):
-            errors.append("plugin manifest field `mcpServers` must be a string or object")
-
-    if "interface" not in manifest:
-        return
-    interface = manifest["interface"]
-    if not isinstance(interface, dict):
-        errors.append("plugin manifest field `interface` must be an object")
-        return
-    for field in ("composerIcon", "logo", "logoDark"):
-        if field in interface:
-            validate_local_path(
-                plugin_root,
-                interface[field],
-                f"plugin manifest field `interface.{field}`",
-                errors,
-            )
-    if "screenshots" in interface:
-        screenshots = interface["screenshots"]
-        if not isinstance(screenshots, list):
-            errors.append("plugin manifest field `interface.screenshots` must be an array")
-        else:
-            for index, value in enumerate(screenshots):
-                validate_local_path(
-                    plugin_root,
-                    value,
-                    f"plugin manifest field `interface.screenshots[{index}]`",
-                    errors,
-                )
-
-
-def validate_skill_frontmatter(skill_md: Path, skill_name: str, errors: list[str]) -> None:
-    try:
-        contents = skill_md.read_text(encoding="utf-8")
-    except (OSError, UnicodeError):
-        errors.append(f"skill `{skill_name}` has unreadable UTF-8 `SKILL.md`")
-        return
-    if not contents:
-        errors.append(f"skill `{skill_name}` has empty `SKILL.md`")
-        return
-    lines = contents.splitlines()
-    if not lines or lines[0] != "---":
-        errors.append(f"skill `{skill_name}` must start with `---`")
-        return
-    try:
-        closing_index = lines.index("---", 1)
-    except ValueError:
-        errors.append(f"skill `{skill_name}` frontmatter is not closed")
-        return
-    frontmatter = lines[1:closing_index]
-    for key in ("name", "description"):
-        matches = [line for line in frontmatter if line.startswith(f"{key}:")]
-        if len(matches) != 1:
-            errors.append(
-                f"skill `{skill_name}` frontmatter must contain exactly one top-level `{key}:`"
-            )
-            continue
-        value = matches[0].split(":", 1)[1].strip()
-        if value in {"", "''", '\"\"'} or value.startswith("#"):
-            errors.append(f"skill `{skill_name}` frontmatter field `{key}` must be non-empty")
-
-
-def validate_tree(plugin_root: Path, errors: list[str]) -> None:
-    required_files = (
-        ".codex-plugin/plugin.template.json",
-        ".superpowers-upstream.json",
-        "LICENSE",
-        "README.md",
-        "CODE_OF_CONDUCT.md",
-    )
-    for relative in required_files:
-        if not (plugin_root / relative).is_file():
-            errors.append(f"missing required file `{relative}`")
-    if os.path.lexists(plugin_root / "hooks"):
-        errors.append("generated plugin must not contain `hooks/`")
-
-    skills_root = plugin_root / "skills"
-    if not skills_root.is_dir():
-        errors.append("missing required directory `skills/`")
-        return
-    try:
-        skill_dirs = sorted(
-            path
-            for path in skills_root.iterdir()
-            if not path.name.startswith(".") and path.is_dir()
-        )
-    except OSError:
-        errors.append("skills directory could not be enumerated")
-        return
-    if not skill_dirs:
-        errors.append("`skills/` must contain at least one skill directory")
-        return
-    for skill_dir in skill_dirs:
-        skill_md = skill_dir / "SKILL.md"
-        if not skill_md.is_file():
-            errors.append(f"skill `{skill_dir.name}` is missing `SKILL.md`")
-            continue
-        validate_skill_frontmatter(skill_md, skill_dir.name, errors)
-
-
-def validate_provenance(args: argparse.Namespace, plugin_root: Path, errors: list[str]) -> None:
-    path = plugin_root / ".superpowers-upstream.json"
-    if not path.is_file():
-        return
-    provenance = load_json_object(path, "provenance", errors)
-    if provenance is None:
-        return
-    if set(provenance) != PROVENANCE_KEYS:
-        errors.append("provenance keys do not match the manager-owned contract")
-    expected = {
-        "source": args.source,
-        "requested_ref": args.requested_ref,
-        "resolved_ref": args.resolved_ref,
-        "commit": args.commit,
-        "upstream_manifest_version": args.upstream_manifest_version,
-    }
-    for key, value in expected.items():
-        if provenance.get(key) != value:
-            errors.append(f"provenance field `{key}` does not match expected value")
-    if re.fullmatch(r"[0-9a-f]{40}", args.commit) is None:
-        errors.append("commit must be 40 lowercase hexadecimal characters")
-
-
-def validate(args: argparse.Namespace) -> list[str]:
-    errors: list[str] = []
-    try:
-        plugin_root = Path(args.plugin_root).expanduser().resolve()
-    except (OSError, RuntimeError, ValueError):
-        errors.append("plugin root could not be resolved")
-        return errors
-    validate_manifest(plugin_root, args.manifest_version, errors)
-    validate_tree(plugin_root, errors)
-    validate_provenance(args, plugin_root, errors)
-    return errors
-
-
-def main(argv: Sequence[str] | None = None) -> int:
-    args = parse_args(argv)
-    errors = validate(args)
-    if errors:
-        print("Generated plugin validation failed:", file=sys.stderr)
-        for error in errors:
-            print(f"- {error}", file=sys.stderr)
-        return 1
-    print(f"generated plugin validation passed: {args.plugin_root}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())