@trac3er/oh-my-god 2.2.3 → 2.2.5

package/runtime/subscription_tiers.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import NotRequired, TypedDict, cast
+
+from runtime.canonical_taxonomy import SUBSCRIPTION_TIERS
+
+
+@dataclass(frozen=True)
+class TierSpec:
+    budget_usd_per_session: float
+    max_parallel_agents: int
+    features: tuple[str, ...]
+
+
+class TierDetectionResult(TypedDict):
+    tier: str
+    provenance: str
+    confidence: float
+    budget_usd_per_session: float
+    max_parallel_agents: int
+    reason: NotRequired[str]
+
+
+TIER_REGISTRY: dict[str, TierSpec] = {
+    "free": TierSpec(
+        budget_usd_per_session=5.0,
+        max_parallel_agents=1,
+        features=("baseline",),
+    ),
+    "pro": TierSpec(
+        budget_usd_per_session=20.0,
+        max_parallel_agents=3,
+        features=("baseline", "higher_budget"),
+    ),
+    "team": TierSpec(
+        budget_usd_per_session=50.0,
+        max_parallel_agents=8,
+        features=("baseline", "collaboration", "higher_budget"),
+    ),
+    "enterprise_tier": TierSpec(
+        budget_usd_per_session=200.0,
+        max_parallel_agents=20,
+        features=("baseline", "collaboration", "governance_plus"),
+    ),
+}
+
+_CACHE_MAX_AGE_SECONDS = 24 * 60 * 60
+_PLAN_ENV_BY_PROVIDER: dict[str, tuple[str, ...]] = {
+    "claude": ("ANTHROPIC_PLAN",),
+    "codex": ("CODEX_PLAN", "OPENAI_PLAN"),
+    "openai": ("OPENAI_PLAN",),
+    "gemini": ("GEMINI_PLAN",),
+    "kimi": ("KIMI_PLAN",),
+}
+
+
+def detect_tier(provider: str, *, project_dir: str | None = None) -> TierDetectionResult:
+    reasons: list[str] = []
+    normalized_provider = (provider or "").strip().lower() or "unknown"
+
+    try:
+        provider_tier = _detect_provider_tier(normalized_provider)
+    except Exception as exc:
+        provider_tier = None
+        reasons.append(str(exc) or "provider_api_failed")
+
+    if provider_tier:
+        result = _build_result(provider_tier, "provider_api", 0.95, reasons)
+        _write_tier_cache(normalized_provider, provider_tier)
+        return result
+
+    local_tier = _detect_local_tier(normalized_provider, project_dir)
+    if local_tier:
+        result = _build_result(local_tier, "local_config", 0.80, reasons)
+        _write_tier_cache(normalized_provider, local_tier)
+        return result
+
+    cached_tier = _read_cached_tier(normalized_provider)
+    if cached_tier:
+        return _build_result(cached_tier, "cache", 0.65, reasons)
+
+    return _build_result("free", "default", 0.40, reasons)
+
+
+def _build_result(tier: str, provenance: str, confidence: float, reasons: list[str]) -> TierDetectionResult:
+    normalized_tier = _normalize_tier_value(tier) or "free"
+    spec = TIER_REGISTRY[normalized_tier]
+    result: TierDetectionResult = {
+        "tier": normalized_tier,
+        "provenance": provenance,
+        "confidence": max(0.0, min(1.0, float(confidence))),
+        "budget_usd_per_session": spec.budget_usd_per_session,
+        "max_parallel_agents": spec.max_parallel_agents,
+    }
+    if reasons:
+        result["reason"] = "; ".join(reason for reason in reasons if reason)
+    return result
+
+
+def _detect_provider_tier(provider: str) -> str | None:
+    keys = _PLAN_ENV_BY_PROVIDER.get(provider, ())
+    if not keys:
+        keys = ("ANTHROPIC_PLAN", "CODEX_PLAN", "OPENAI_PLAN", "GEMINI_PLAN", "KIMI_PLAN")
+
+    for key in keys:
+        error_key = f"{key}_ERROR"
+        error_value = os.environ.get(error_key, "").strip()
+        if error_value:
+            raise RuntimeError(f"provider_api: {error_value}")
+
+        value = os.environ.get(key, "").strip()
+        if value:
+            normalized = _normalize_tier_value(value)
+            if normalized:
+                return normalized
+
+    return None
+
+
+def _detect_local_tier(provider: str, project_dir: str | None) -> str | None:
+    from_env = _normalize_tier_value(os.environ.get("OMG_SUBSCRIPTION_TIER", ""))
+    if from_env:
+        return from_env
+
+    root = Path(project_dir) if project_dir else Path.cwd()
+    settings_tier = _read_settings_tier(root)
+    if settings_tier:
+        return settings_tier
+
+    cli_tier = _read_cli_config_tier(root, provider)
+    if cli_tier:
+        return cli_tier
+
+    return None
+
+
+def _read_settings_tier(project_root: Path) -> str | None:
+    settings_path = project_root / "settings.json"
+    if not settings_path.exists():
+        return None
+    try:
+        raw_obj = json.loads(settings_path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+    if not isinstance(raw_obj, dict):
+        return None
+    raw = cast(dict[str, object], raw_obj)
+
+    omg_cfg = raw.get("_omg")
+    if not isinstance(omg_cfg, dict):
+        return None
+    maybe = omg_cfg.get("subscription_tier")
+    return _normalize_tier_value(maybe)
+
+
+def _read_cli_config_tier(project_root: Path, provider: str) -> str | None:
+    config_path = project_root / ".omg" / "state" / "cli-config.yaml"
+    if not config_path.exists():
+        return None
+
+    try:
+        lines = config_path.read_text(encoding="utf-8").splitlines()
+    except Exception:
+        return None
+
+    in_provider_block = False
+    provider_indent = ""
+    for line in lines:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+
+        if stripped.endswith(":") and stripped[:-1].strip() == provider:
+            in_provider_block = True
+            provider_indent = line[: len(line) - len(line.lstrip())]
+            continue
+
+        if in_provider_block:
+            if stripped.endswith(":") and not line.startswith(provider_indent + "  "):
+                in_provider_block = False
+                continue
+            if stripped.startswith("subscription:"):
+                _, _, value = stripped.partition(":")
+                return _normalize_tier_value(value.strip())
+
+    return None
+
+
+def _tier_cache_path() -> Path:
+    return Path.home() / ".omg" / "state" / "tier-cache.json"
+
+
+def _read_cached_tier(provider: str) -> str | None:
+    path = _tier_cache_path()
+    if not path.exists():
+        return None
+
+    try:
+        payload_obj = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+    if not isinstance(payload_obj, dict):
+        return None
+    payload = cast(dict[str, object], payload_obj)
+
+    cache_ts = payload.get("timestamp")
+    if not isinstance(cache_ts, (int, float)):
+        return None
+
+    age = time.time() - float(cache_ts)
+    if age > _CACHE_MAX_AGE_SECONDS:
+        return None
+
+    cache_provider_raw = payload.get("provider", "")
+    cache_provider = str(cache_provider_raw).strip().lower()
+    if cache_provider and cache_provider != provider:
+        return None
+
+    return _normalize_tier_value(payload.get("tier"))
+
+
+def _write_tier_cache(provider: str, tier: str) -> None:
+    path = _tier_cache_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "provider": provider,
+        "tier": tier,
+        "timestamp": time.time(),
+    }
+    try:
+        _ = path.write_text(json.dumps(payload, separators=(",", ":")), encoding="utf-8")
+    except Exception:
+        return
+
+
+def _normalize_tier_value(raw: object) -> str | None:
+    value = str(raw or "").strip().lower()
+    if not value:
+        return None
+    aliases = {
+        "enterprise": "enterprise_tier",
+        "enterprise-tier": "enterprise_tier",
+    }
+    value = aliases.get(value, value)
+    if value in TIER_REGISTRY:
+        return value
+    return None
+
+
+if set(TIER_REGISTRY.keys()) != set(SUBSCRIPTION_TIERS):
+    raise ValueError("TIER_REGISTRY must exactly match SUBSCRIPTION_TIERS")

package/runtime/test_intent_lock.py

@@ -144,18 +144,40 @@ def verify_lock(project_dir: str, run_id: str | None, lock_id: str | None = None
 
 def verify_done_when(metadata: dict[str, Any] | None, run_id: str | None) -> dict[str, Any]:
     metadata_obj = metadata if isinstance(metadata, dict) else {}
+    normalized_run_id = str(run_id or "").strip() or None
+
+    if metadata is None:
+        # No metadata provided at all -- treat the same as metadata without
+        # a done_when key.  This is the common case for CLI / non-Claude
+        # invocations and should not block.
+        return {
+            "status": "ok",
+            "reason": "done_when_not_provided",
+            "run_id": normalized_run_id,
+            "done_when_declared": False,
+            "done_when_completed": False,
+        }
+
+    if "done_when" not in metadata_obj:
+        return {
+            "status": "ok",
+            "reason": "done_when_not_declared",
+            "run_id": normalized_run_id,
+            "done_when_declared": False,
+            "done_when_completed": False,
+        }
+
     criteria = _extract_done_when_criteria(metadata_obj.get("done_when"))
     if not criteria:
         return {
             "status": "missing_done_when",
             "reason": "done_when_required",
-            "run_id": str(run_id or "").strip() or None,
+            "run_id": normalized_run_id,
             "done_when_declared": False,
             "done_when_completed": False,
         }
 
     done_when_run_id = _extract_done_when_run_id(metadata_obj.get("done_when"))
-    normalized_run_id = str(run_id or "").strip()
     if done_when_run_id and normalized_run_id and done_when_run_id != normalized_run_id:
         return {
             "status": "done_when_contract_mismatch",

package/runtime/verdict_schema.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from typing import Any, Literal, TypedDict
+
+VerdictStatus = Literal["pass", "fail", "action_required", "pending"]
+
+
+class VerdictReceipt(TypedDict):
+    status: VerdictStatus
+    verdict: VerdictStatus
+    blockers: list[str]
+    planned_actions: list[Any]
+    executed_actions: list[Any]
+    provenance: str | None
+    evidence_paths: dict[str, str]
+    next_steps: list[str]
+    executed: bool
+    metadata: dict[str, Any]
+
+
+_STATUS_ALIASES: dict[str, VerdictStatus] = {
+    "pass": "pass",
+    "passed": "pass",
+    "ok": "pass",
+    "success": "pass",
+    "approved": "pass",
+    "fail": "fail",
+    "failed": "fail",
+    "error": "fail",
+    "reject": "fail",
+    "rejected": "fail",
+    "block": "fail",
+    "blocked": "fail",
+    "action_required": "action_required",
+    "action-required": "action_required",
+    "needs_action": "action_required",
+    "needs-action": "action_required",
+    "required": "action_required",
+    "warn": "action_required",
+    "warning": "action_required",
+    "pending": "pending",
+    "unknown": "pending",
+    "inconclusive": "pending",
+}
+
+
+def _as_status(value: Any) -> VerdictStatus:
+    text = str(value).strip().lower()
+    return _STATUS_ALIASES.get(text, "pending")
+
+
+def _as_str_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    items: list[str] = []
+    for item in value:
+        text = str(item).strip()
+        if text:
+            items.append(text)
+    return items
+
+
+def _as_list(value: Any) -> list[Any]:
+    if isinstance(value, list):
+        return list(value)
+    return []
+
+
+def _as_dict_of_str(value: Any) -> dict[str, str]:
+    if not isinstance(value, dict):
+        return {}
+    normalized: dict[str, str] = {}
+    for key, item in value.items():
+        name = str(key).strip()
+        text = str(item).strip()
+        if name and text:
+            normalized[name] = text
+    return normalized
+
+
+def normalize_verdict(raw: dict[str, Any]) -> VerdictReceipt:
+    payload = raw if isinstance(raw, dict) else {}
+    status = _as_status(payload.get("status", payload.get("verdict", "pending")))
+    blockers = _as_str_list(payload.get("blockers"))
+    if not blockers:
+        blockers = _as_str_list(payload.get("unresolved_risks"))
+    if not blockers:
+        blockers = _as_str_list(payload.get("evidence_gaps"))
+
+    planned_actions = _as_list(payload.get("planned_actions"))
+    if not planned_actions:
+        planned_actions = _as_list(payload.get("actions"))
+
+    executed_actions = _as_list(payload.get("executed_actions"))
+    if not executed_actions:
+        executed_actions = _as_list(payload.get("fix_receipts"))
+
+    next_steps = _as_str_list(payload.get("next_steps"))
+    if not next_steps:
+        next_steps = _as_str_list(payload.get("actions"))
+
+    provenance_value = payload.get("provenance", payload.get("source"))
+    provenance = str(provenance_value).strip() if provenance_value is not None else None
+    if provenance == "":
+        provenance = None
+
+    evidence_paths = _as_dict_of_str(payload.get("evidence_paths"))
+    metadata = dict(payload.get("metadata", {})) if isinstance(payload.get("metadata"), dict) else {}
+
+    known_fields = {
+        "status",
+        "verdict",
+        "blockers",
+        "planned_actions",
+        "executed_actions",
+        "provenance",
+        "source",
+        "evidence_paths",
+        "next_steps",
+        "executed",
+        "metadata",
+        "unresolved_risks",
+        "evidence_gaps",
+        "actions",
+        "fix_receipts",
+    }
+    for key, value in payload.items():
+        if key not in known_fields and key not in metadata:
+            metadata[key] = value
+
+    executed = bool(payload.get("executed", False))
+    return {
+        "status": status,
+        "verdict": status,
+        "blockers": blockers,
+        "planned_actions": planned_actions,
+        "executed_actions": executed_actions,
+        "provenance": provenance,
+        "evidence_paths": evidence_paths,
+        "next_steps": next_steps,
+        "executed": executed,
+        "metadata": metadata,
+    }
+
+
+def action_required_verdict(blockers: list[str], *, next_steps: list[str] | None = None) -> VerdictReceipt:
+    return {
+        "status": "action_required",
+        "verdict": "action_required",
+        "blockers": _as_str_list(blockers),
+        "planned_actions": [],
+        "executed_actions": [],
+        "provenance": None,
+        "evidence_paths": {},
+        "next_steps": _as_str_list(next_steps or []),
+        "executed": False,
+        "metadata": {},
+    }
+
+
+def pass_verdict(*, evidence_paths: dict[str, str] | None = None) -> VerdictReceipt:
+    return {
+        "status": "pass",
+        "verdict": "pass",
+        "blockers": [],
+        "planned_actions": [],
+        "executed_actions": [],
+        "provenance": None,
+        "evidence_paths": _as_dict_of_str(evidence_paths),
+        "next_steps": [],
+        "executed": True,
+        "metadata": {},
+    }
+
+
+def fail_verdict(blockers: list[str], *, evidence_paths: dict[str, str] | None = None) -> VerdictReceipt:
+    return {
+        "status": "fail",
+        "verdict": "fail",
+        "blockers": _as_str_list(blockers),
+        "planned_actions": [],
+        "executed_actions": [],
+        "provenance": None,
+        "evidence_paths": _as_dict_of_str(evidence_paths),
+        "next_steps": [],
+        "executed": False,
+        "metadata": {},
+    }
+
+
+__all__ = [
+    "VerdictReceipt",
+    "VerdictStatus",
+    "action_required_verdict",
+    "fail_verdict",
+    "normalize_verdict",
+    "pass_verdict",
+]