init: company-haness 설계

2026-07-23 17:49:00 +09:00
parent 57d1bab894
commit f668d6a158
962 changed files with 98989 additions and 1 deletions
@@ -0,0 +1,140 @@
+"""Coverage vocabulary derived from role, family, artifact and workflow contracts."""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+RISK_ROLE_HINTS = {
+    "security": {"SEC-ENGINEER", "SEC-APPSEC", "SEC-CHAMPION", "SEC-DEVSECOPS"},
+    "privacy": {"SEC-APPSEC", "GTM-LEGAL"},
+    "legal": {"GTM-LEGAL"},
+    "reliability": {"SRE", "INFRA-PLATFORM", "EXEC-VPENG"},
+    "quality": {"QA", "EXEC-VPENG"},
+    "financial": {"EXEC-CFO", "GTM-PRICING", "CONSULT-FIN"},
+    "user-harm": {"QA", "EXEC-CPO", "SEC-APPSEC"},
+}
+
+# Workload-profile.required-capabilities is an executable coverage contract.
+# Keep the mapping concrete: a family label by itself must not satisfy a role
+# specific need such as competitive intelligence.
+CAPABILITY_ROLE_HINTS = {
+    "product": {"EXEC-CPO", "PROD-PM", "PROD-PO", "PROD-TPO", "PROD-PPO"},
+    "product-delivery": {"PROD-PM", "PROD-PO", "PROD-TPO", "PROD-PPO", "EXEC-VPENG"},
+    "customer-research": {"UX-RESEARCHER", "DATA-ANALYST"},
+    "competitive-intelligence": {"GTM-CI"},
+    "revenue": {"GTM-REVOPS", "GTM-PRICING", "GTM-SALES", "GTM-GROWTHPM"},
+    "gtm": {"GTM-CI", "GTM-PMM", "GTM-DEMANDGEN", "GTM-SALES", "GTM-REVOPS"},
+    "finance": {"EXEC-CFO", "CONSULT-FIN", "GTM-PRICING"},
+    "strategy": {"STR-ANALYST", "CONSULT-STRAT"},
+    "operations": {"EXEC-COO", "OPS-CH", "OPS-CREW", "CONSULT-OPS"},
+    "design": {"DES-DIRECTOR", "DES-PROD", "DES-PLATFORM", "DES-INTERNAL", "DES-VISUAL"},
+    "information-architecture": {"DOC-IA"},
+    "technical": {"EXEC-CTO", "EXEC-CPTO", "ARCH-TECH", "ARCH-SOLUTION"},
+    "architecture": {"ARCH-EA", "ARCH-SOLUTION", "ARCH-APP", "ARCH-TECH", "ARCH-SWAT"},
+    "engineering": {"EXEC-VPENG", "ENG-FE", "ENG-BE", "ENG-SW"},
+    "frontend": {"ENG-FE", "ENG-FEPLAT", "ENG-FEUX"},
+    "backend": {"ENG-BE", "ENG-BEGEN", "ENG-PRODSERVER", "ENG-PLATSERVER", "ENG-SW"},
+    "public-api": {"ARCH-APP", "ARCH-TECH", "ENG-BE", "ENG-PRODSERVER"},
+    "persistence": {"ARCH-DATA", "DATA-ENGINEER", "ENG-BE"},
+    "platform": {"INFRA-PLATFORM", "ENG-FEPLAT", "ENG-PLATSERVER", "PROD-PPO"},
+    "data": {"ARCH-DATA", "DATA-ENGINEER", "DATA-BIGDATA", "DATA-ANALYST"},
+    "security": {"SEC-ENGINEER", "SEC-APPSEC", "SEC-CHAMPION", "SEC-DEVSECOPS"},
+    "privacy": {"SEC-APPSEC", "GTM-LEGAL"},
+    "legal": {"GTM-LEGAL"},
+    "quality": {"QA", "EXEC-VPENG"},
+    "kpi-test": {"DATA-ANALYST", "QA"},
+    "infrastructure": {"INFRA-DEV", "INFRA-PLATFORM", "INFRA-DEVOPS", "SRE"},
+    "documentation": {"DOC-LEAD", "DOC-WRITER", "DOC-IA", "DOC-VISUAL", "DOC-EDU"},
+}
+
+
+def tokens(value: Any) -> set[str]:
+    if value is None:
+        return set()
+    if isinstance(value, dict):
+        value = " ".join(f"{key} {item}" for key, item in value.items())
+    elif isinstance(value, (list, tuple, set)):
+        value = " ".join(str(item) for item in value)
+    return {part for part in re.split(r"[^\w]+", str(value).lower(), flags=re.UNICODE)
+            if len(part) > 1 and part != "_"}
+
+
+def artifact_maps(artifact_registry: dict[str, Any]) -> tuple[dict[str, set[str]], dict[str, set[str]]]:
+    producer: dict[str, set[str]] = {}
+    reviewer: dict[str, set[str]] = {}
+    for kind, definition in (artifact_registry.get("artifact-kinds") or {}).items():
+        for role in definition.get("producer-roles", []) or []:
+            producer.setdefault(str(role), set()).add(str(kind))
+        capability = definition.get("reviewer-capability")
+        if capability:
+            reviewer.setdefault(str(capability), set()).add(str(kind))
+    return producer, reviewer
+
+
+def role_coverage(
+    role: dict[str, Any],
+    family: dict[str, Any],
+    profile: dict[str, Any] | None,
+    artifact_registry: dict[str, Any],
+    role_capabilities: dict[str, list[str]],
+) -> set[str]:
+    role_id = str(role.get("role-id"))
+    family_id = str(family.get("family-id"))
+    producer, reviewer_kinds = artifact_maps(artifact_registry)
+    coverage = {"owner", f"family:{family_id}", f"owner:{family_id}", f"role:{role_id}"}
+    coverage |= {f"lens:{lens}" for lens in family.get("carries-lenses", []) or []}
+    if family.get("audit-capable"):
+        coverage.add("lens:LENS-CONTRARIAN")
+    coverage |= {f"artifact:{kind}" for kind in producer.get(role_id, set())}
+    for capability, roles in role_capabilities.items():
+        if role_id in set(roles or []):
+            coverage.add(f"capability:{capability}")
+            coverage |= {f"review:{kind}" for kind in reviewer_kinds.get(capability, set())}
+    for capability, role_ids in CAPABILITY_ROLE_HINTS.items():
+        if role_id in role_ids:
+            coverage.add(f"capability:{capability}")
+    if role.get("is-decision-maker"):
+        coverage.add("authority")
+    if role.get("role-type") in {"auditor", "reviewer"} or family.get("audit-capable"):
+        coverage.add("independent-review")
+    if role.get("is-execution-agent"):
+        coverage.add("implementation")
+    for risk, role_ids in RISK_ROLE_HINTS.items():
+        if role_id in role_ids:
+            coverage.add(f"risk:{risk}")
+    searchable = " ".join([
+        role_id,
+        str(role.get("role-name") or ""),
+        str((profile or {}).get("perspective") or ""),
+        str((profile or {}).get("scope") or ""),
+        " ".join((profile or {}).get("responsibilities", []) or []),
+    ])
+    coverage |= {f"keyword:{token}" for token in tokens(searchable)}
+    return coverage
+
+
+def required_coverage(profile: dict[str, Any], candidate_family_ids: list[str]) -> set[str]:
+    required = {str(item) for item in profile.get("required-coverage", []) or []}
+    required_families = profile.get("required-families", []) or []
+    if isinstance(required_families, str):
+        required_families = [required_families]
+    required |= {f"owner:{family_id}" for family_id in required_families}
+    if candidate_family_ids:
+        required.add("owner")
+    required |= {f"artifact:{kind}" for kind in profile.get("required-artifacts", []) or []}
+    capabilities = profile.get("required-capabilities", []) or []
+    if isinstance(capabilities, str):
+        capabilities = [capabilities]
+    required |= {f"capability:{str(capability).strip().lower()}"
+                 for capability in capabilities if str(capability or "").strip()}
+    risks = profile.get("risks", []) or []
+    if isinstance(risks, dict):
+        risks = [key for key, value in risks.items() if value]
+    required |= {f"risk:{str(risk).lower()}" for risk in risks}
+    if profile.get("authority-required"):
+        required.add("authority")
+    if profile.get("implementation-required") or profile.get("workflow-stage") in {"build", "run"}:
+        required.add("implementation")
+    if profile.get("independent-review-required"):
+        required.add("independent-review")
+    return required