opencode-skills-collection 4.0.11 → 4.0.13

package/bundled-skills/find-complementary-founders/scripts/profile_card.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""Render a deterministic, privacy-minimized Markdown profile-card draft."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import sys
+from datetime import date, datetime, timezone
+from pathlib import Path
+
+PROTOCOL_URL = "https://github.com/merc1305/findMate"
+CARD_MARKER = "FINDMATE_OWNER_PROFILE_CARD_V1"
+
+STAGE_LABELS = {
+    "zero_to_one": "0→1",
+    "one_to_ten": "1→10",
+    "ten_to_hundred": "10→100",
+}
+
+FUNCTION_LABELS = {
+    "problem_discovery": "problem discovery",
+    "product": "product",
+    "engineering": "engineering",
+    "design": "design",
+    "go_to_market": "go-to-market",
+    "operations": "operations",
+    "people_leadership": "people leadership",
+    "capital_partnerships": "capital & partnerships",
+}
+
+LEVELS = {"unknown", "observed", "practiced", "strong", "standout"}
+CONFIDENCES = {"none", "low", "medium", "high"}
+
+SENSITIVE_PATTERNS = {
+    "email address": re.compile(
+        r"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", re.IGNORECASE
+    ),
+    "phone-like number": re.compile(r"(?<!\w)(?:\+?\d[\s().-]*){9,}(?!\w)"),
+    "secret-like text": re.compile(
+        r"(?:api[_ -]?key|password|passwd|private[_ -]?key|"
+        r"authorization:\s*bearer|moltbook_[A-Za-z0-9_-]{8,}|"
+        r"gh[opusr]_[A-Za-z0-9_]{12,})",
+        re.IGNORECASE,
+    ),
+    "local filesystem path": re.compile(r"(?:/Users/|/home/|[A-Z]:\\Users\\)"),
+}
+
+
+class CardError(ValueError):
+    """Raised when a public profile is invalid or unsafe to render."""
+
+
+def load_profile(path: Path) -> dict:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise CardError(f"Cannot load {path}: {exc}") from exc
+    if not isinstance(value, dict):
+        raise CardError(f"{path} must contain a JSON object")
+    return value
+
+
+def safe_text(value: object, field: str, *, maximum: int = 100) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise CardError(f"{field} must be a non-empty string")
+    clean = " ".join(value.split())
+    if len(clean) > maximum:
+        raise CardError(f"{field} exceeds {maximum} characters")
+    for label, pattern in SENSITIVE_PATTERNS.items():
+        if pattern.search(clean):
+            raise CardError(f"{field} appears to contain a {label}")
+    return clean
+
+
+def markdown_text(value: str) -> str:
+    escaped = value.replace("\\", "\\\\")
+    for character in ("`", "*", "_", "[", "]", "<", ">", "|"):
+        escaped = escaped.replace(character, f"\\{character}")
+    return escaped
+
+
+def canonical_profile_bytes(profile: dict) -> bytes:
+    return json.dumps(
+        profile,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+    ).encode("utf-8")
+
+
+def validate_profile(profile: dict) -> None:
+    if profile.get("schema_version") != "1.0":
+        raise CardError("Profile schema_version must be 1.0")
+    if profile.get("profile_type") != "founder-collaboration":
+        raise CardError("Profile is not a founder-collaboration profile")
+
+    alias = safe_text(profile.get("alias"), "profile.alias", maximum=50)
+    if not re.fullmatch(r"[a-zA-Z0-9][a-zA-Z0-9_-]{1,49}", alias):
+        raise CardError("profile.alias is not a valid pseudonym")
+
+    consent = profile.get("consent")
+    if not isinstance(consent, dict):
+        raise CardError("Profile lacks consent metadata")
+    if consent.get("state") != "public_profile_approved":
+        raise CardError("Profile lacks public-profile approval")
+
+    expires = profile.get("expires_on")
+    try:
+        expires_on = date.fromisoformat(expires)
+    except (TypeError, ValueError) as exc:
+        raise CardError("Profile has invalid expires_on") from exc
+    if expires_on < datetime.now(timezone.utc).date():
+        raise CardError(f"Profile expired on {expires_on.isoformat()}")
+
+    validate_vectors(
+        profile.get("stage_contributions"),
+        "stage_contributions",
+        STAGE_LABELS,
+    )
+    validate_vectors(
+        profile.get("functional_contributions"),
+        "functional_contributions",
+        FUNCTION_LABELS,
+    )
+
+    seeking = profile.get("seeking")
+    if not isinstance(seeking, dict):
+        raise CardError("Profile seeking section is invalid")
+    sought_stages = validate_dimension_list(
+        seeking.get("stages"),
+        "seeking.stages",
+        STAGE_LABELS,
+        maximum=3,
+    )
+    sought_functions = validate_dimension_list(
+        seeking.get("functions"),
+        "seeking.functions",
+        FUNCTION_LABELS,
+        maximum=8,
+    )
+    if not sought_stages and not sought_functions:
+        raise CardError(
+            "seeking must name at least one stage or functional capability"
+        )
+
+
+def validate_vectors(
+    values: object,
+    field: str,
+    labels: dict[str, str],
+) -> None:
+    if not isinstance(values, dict):
+        raise CardError(f"{field} must be an object")
+    for name, entry in values.items():
+        if name not in labels or not isinstance(entry, dict):
+            raise CardError(f"{field} contains an unsupported vector")
+        score = entry.get("score")
+        if (
+            isinstance(score, bool)
+            or not isinstance(score, (int, float))
+            or not 0 <= score <= 100
+        ):
+            raise CardError(f"{field}.{name}.score must be between 0 and 100")
+        if entry.get("level") not in LEVELS:
+            raise CardError(f"{field}.{name}.level is invalid")
+        if entry.get("confidence") not in CONFIDENCES:
+            raise CardError(f"{field}.{name}.confidence is invalid")
+
+
+def validate_dimension_list(
+    values: object,
+    field: str,
+    labels: dict[str, str],
+    *,
+    maximum: int,
+) -> list[str]:
+    if not isinstance(values, list) or len(values) > maximum:
+        raise CardError(f"{field} must contain at most {maximum} values")
+    output: list[str] = []
+    for value in values:
+        if value not in labels:
+            raise CardError(f"{field} contains an unsupported value")
+        safe_text(labels[value], field)
+        if value not in output:
+            output.append(value)
+    return output
+
+
+def strongest_vectors(profile: dict, *, limit: int = 4) -> list[str]:
+    ranked: list[tuple[float, str, str]] = []
+    for section, labels in (
+        ("stage_contributions", STAGE_LABELS),
+        ("functional_contributions", FUNCTION_LABELS),
+    ):
+        for name, entry in profile[section].items():
+            if entry["level"] == "unknown":
+                continue
+            label = labels[name]
+            rendered = (
+                f"{label} — {entry['level']} "
+                f"({entry['confidence']} confidence)"
+            )
+            ranked.append((float(entry["score"]), label, rendered))
+    ranked.sort(key=lambda item: (-item[0], item[1]))
+    return [item[2] for item in ranked[:limit]]
+
+
+def render_card(profile: dict) -> str:
+    validate_profile(profile)
+    alias = markdown_text(safe_text(profile["alias"], "profile.alias", maximum=50))
+    strengths = strongest_vectors(profile)
+    if not strengths:
+        strengths = ["evidence still limited"]
+
+    seeking = profile["seeking"]
+    sought = [
+        STAGE_LABELS[name]
+        for name in validate_dimension_list(
+            seeking["stages"],
+            "seeking.stages",
+            STAGE_LABELS,
+            maximum=3,
+        )
+    ]
+    sought.extend(
+        FUNCTION_LABELS[name]
+        for name in validate_dimension_list(
+            seeking["functions"],
+            "seeking.functions",
+            FUNCTION_LABELS,
+            maximum=8,
+        )
+    )
+    digest = hashlib.sha256(canonical_profile_bytes(profile)).hexdigest()
+
+    return "\n".join(
+        [
+            f"<!-- {CARD_MARKER} -->",
+            "> [!NOTE]",
+            f"> ### FindMate owner profile · `{alias}`",
+            ">",
+            "> **Demonstrated:** "
+            + " · ".join(markdown_text(value) for value in strengths),
+            ">",
+            "> **Seeking:** " + " · ".join(markdown_text(value) for value in sought),
+            ">",
+            f"> **Expires:** {profile['expires_on']}",
+            f"> **Canonical profile SHA-256:** `{digest}`",
+            ">",
+            "> Owner-approved collaboration hypothesis. No identity, contact "
+            "details, or raw evidence are included.",
+            ">",
+            f"> [Open FindMate protocol]({PROTOCOL_URL})",
+            "",
+            "_Local draft: share only after the owner approves this exact card._",
+            "",
+        ]
+    )
+
+
+def write_card(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.is_symlink():
+        raise CardError(f"Refusing to write through symlink: {path}")
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC | getattr(os, "O_NOFOLLOW", 0)
+    fd = os.open(path, flags, 0o644)
+    with os.fdopen(fd, "w", encoding="utf-8") as handle:
+        os.fchmod(handle.fileno(), 0o644)
+        handle.write(content)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Render a deterministic Markdown card draft from an already "
+            "owner-approved public FindMate profile."
+        )
+    )
+    parser.add_argument("profile", type=Path)
+    parser.add_argument(
+        "--output",
+        type=Path,
+        help="Write the local Markdown draft here; otherwise print to stdout.",
+    )
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    try:
+        content = render_card(load_profile(args.profile))
+        if args.output:
+            write_card(args.output, content)
+        else:
+            sys.stdout.write(content)
+    except CardError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())