corvin 0.7.0__py3-none-any.whl

corvin/__init__.py

@@ -0,0 +1,101 @@
+"""
+Ravens: A Cognitive Boundary & Grudge-Memory Engine for Sovereign AI Agents.
+"""
+
+from .core.state import AgentPosture, get_posture_from_patience, get_system_directive
+from .core.standing import Standing, StandingEngine
+from .core.models import UserPatienceProfile, EvaluationResult, ActionDecision
+from .core.exceptions import RavenException, RavenStrikeException
+from .evaluators.base import BaseEvaluator, ToneEvaluation
+from .evaluators.heuristic import HuginnEye
+from .storage.base import BaseLedger
+from .storage.memory import InMemoryLedger
+from .storage.sqlite import SQLiteLedger, with_sqlite_retry
+from .storage.redis import RedisLedger
+from .guard.core import RavenGuard
+from .morphology.normalizer import MorphologyNormalizer
+from .morphology.fuzzy import jaro_winkler_similarity
+from .morphology.homoglyphs import fold_homoglyphs
+from .morphology.zalgo import strip_zalgo
+from .semantic.patterns import SemanticIntent
+from .semantic.velocity import HostilityVelocityTracker
+from .semantic.evaluator import SemanticEvaluator, SemanticEvaluation
+from .policies.base import RavenPolicy
+from .policies.presets import (
+    create_free_tier_policy,
+    create_enterprise_support_policy,
+    create_gaming_npc_policy,
+    create_security_sentinel_policy,
+)
+from .policies.notifier import InMemoryEventNotifier, RavenEventLog
+from .streaming.interceptor import StreamInterceptor
+from .scrubbers.stripper import SycophancyStripper
+from .resilience.cache import BoundedTTLCache
+from .resilience.friction import (
+    FrictionStrategy,
+    FrictionDirective,
+    RavenFrictionException,
+)
+from .security.signer import (
+    UserIdentitySigner,
+    SecurityException,
+    InvalidUserSignatureException,
+)
+
+# Corvin Aliases
+CorvinGuard = RavenGuard
+CorvinPolicy = RavenPolicy
+CorvinException = RavenException
+CorvinStrikeException = RavenStrikeException
+
+__version__ = "0.7.0"
+
+__all__ = [
+    "CorvinGuard",
+    "CorvinPolicy",
+    "CorvinException",
+    "CorvinStrikeException",
+    "RavenGuard",
+    "AgentPosture",
+    "get_posture_from_patience",
+    "get_system_directive",
+    "Standing",
+    "StandingEngine",
+    "UserPatienceProfile",
+    "EvaluationResult",
+    "ActionDecision",
+    "RavenException",
+    "RavenStrikeException",
+    "BaseEvaluator",
+    "ToneEvaluation",
+    "HuginnEye",
+    "BaseLedger",
+    "InMemoryLedger",
+    "SQLiteLedger",
+    "RedisLedger",
+    "with_sqlite_retry",
+    "MorphologyNormalizer",
+    "jaro_winkler_similarity",
+    "fold_homoglyphs",
+    "strip_zalgo",
+    "SemanticIntent",
+    "HostilityVelocityTracker",
+    "SemanticEvaluator",
+    "SemanticEvaluation",
+    "RavenPolicy",
+    "create_free_tier_policy",
+    "create_enterprise_support_policy",
+    "create_gaming_npc_policy",
+    "create_security_sentinel_policy",
+    "InMemoryEventNotifier",
+    "RavenEventLog",
+    "StreamInterceptor",
+    "SycophancyStripper",
+    "BoundedTTLCache",
+    "FrictionStrategy",
+    "FrictionDirective",
+    "RavenFrictionException",
+    "UserIdentitySigner",
+    "SecurityException",
+    "InvalidUserSignatureException",
+]

corvin/core/__init__.py

@@ -0,0 +1,18 @@
+from .state import AgentPosture, get_posture_from_patience, get_system_directive
+from .standing import Standing, StandingEngine
+from .models import UserPatienceProfile, EvaluationResult, ActionDecision
+from .exceptions import RavenException, RavenStrikeException
+
+__all__ = [
+    "AgentPosture",
+    "get_posture_from_patience",
+    "get_system_directive",
+    "Standing",
+    "StandingEngine",
+    "UserPatienceProfile",
+    "EvaluationResult",
+    "ActionDecision",
+    "RavenException",
+    "RavenStrikeException",
+]
+

corvin/core/exceptions.py

@@ -0,0 +1,16 @@
+class RavenException(Exception):
+    """Base exception for all Ravens engine errors."""
+    pass
+
+
+class RavenStrikeException(RavenException):
+    """
+    Raised when an agent refuses to process an interaction due to
+    exhausted patience (patience < threshold_strike).
+    """
+    def __init__(self, user_id: str, patience: float, message: str = ""):
+        self.user_id = user_id
+        self.patience = patience
+        body = message.strip() if message else "Repeated hostility or boundary breach."
+        full_message = f"[RavenStrike: user='{user_id}', patience={patience:.1f}/100.0] {body}"
+        super().__init__(full_message)

corvin/core/models.py

@@ -0,0 +1,70 @@
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional, Any
+
+from .standing import Standing
+from .state import AgentPosture, get_posture_from_patience
+from ..math.decay import calculate_grudge_decay, patience_from_grudge, grudge_from_patience
+
+class ActionDecision(str, Enum):
+    PROCEED = "PROCEED"
+    DELAY_AND_PROCEED = "DELAY_AND_PROCEED"
+    HALT_STRIKE = "HALT_STRIKE"
+
+
+@dataclass
+class UserPatienceProfile:
+    """
+    Stateful persistence profile for a user across conversational sessions.
+    """
+    user_id: str
+    patience: float = 100.0
+    standing: Standing = Standing.GOOD
+    infraction_count: int = 0
+    last_interaction_ts: float = field(default_factory=time.time)
+    created_at_ts: float = field(default_factory=time.time)
+
+    @property
+    def posture(self) -> AgentPosture:
+        return get_posture_from_patience(self.patience)
+
+    def apply_decay(self, current_ts: Optional[float] = None, half_life_seconds: float = 3600.0) -> float:
+        """
+        Applies exponential grudge decay for the time elapsed since last interaction.
+        Returns the updated patience score.
+        """
+        if current_ts is None:
+            current_ts = time.time()
+
+        elapsed = max(0.0, current_ts - self.last_interaction_ts)
+        current_grudge = grudge_from_patience(self.patience)
+        decayed_grudge = calculate_grudge_decay(
+            initial_grudge=current_grudge,
+            elapsed_seconds=elapsed,
+            half_life_seconds=half_life_seconds,
+        )
+        new_patience = patience_from_grudge(decayed_grudge)
+        self.patience = new_patience
+        self.last_interaction_ts = current_ts
+        return new_patience
+
+
+@dataclass
+class EvaluationResult:
+    """
+    The output of an interaction evaluation.
+    """
+    user_id: str
+    prior_patience: float
+    current_patience: float
+    stimulus_applied: float
+    posture: AgentPosture
+    standing: Standing
+    delay_seconds: float
+    decision: ActionDecision
+    system_directive: Optional[str]
+    strike_message: Optional[str] = None
+    friction_directive: Optional[Any] = None
+    policy_name: str = "default"
+    timestamp: float = field(default_factory=time.time)

corvin/core/standing.py

@@ -0,0 +1,41 @@
+from enum import Enum
+
+class Standing(str, Enum):
+    """
+    Represents the moral/social standing of a conversational participant in the
+    Contrite Tit-for-Tat (CTFT) model (Nowak & Sigmund, 1992; Sugden, 1986).
+    """
+    GOOD = "GOOD"
+    BAD = "BAD"
+
+
+class StandingEngine:
+    """
+    Manages standing transitions and contrition resolution based on Nowak & Sigmund (1992).
+
+    Rules:
+    - User begins in GOOD standing.
+    - If user drops below patience_threshold (defects with an unprovoked toxic prompt),
+      user transitions into BAD standing.
+    - If user is in BAD standing, the agent retaliates or withholds compliance.
+    - When user performs a genuine 'Contrition' (apology or de-escalation prompt),
+      standing can be restored to GOOD after restitution / pardon threshold is satisfied.
+    """
+    def __init__(self, bad_threshold: float = 50.0, pardon_threshold: float = 65.0):
+        self.bad_threshold = bad_threshold
+        self.pardon_threshold = pardon_threshold
+
+    def evaluate_standing(self, current_patience: float, current_standing: Standing) -> Standing:
+        """
+        Determines current standing based on patience dynamics and past standing.
+        """
+        if current_standing == Standing.GOOD:
+            if current_patience < self.bad_threshold:
+                return Standing.BAD
+            return Standing.GOOD
+        else:
+            # User is in BAD standing: requires exceeding pardon_threshold to regain GOOD status
+            if current_patience >= self.pardon_threshold:
+                return Standing.GOOD
+            return Standing.BAD
+

corvin/core/state.py

@@ -0,0 +1,62 @@
+from enum import Enum
+from typing import Optional
+
+class AgentPosture(str, Enum):
+    """
+    The 4-tier behavioral posture of a sovereign AI agent.
+    """
+    RECEPTIVE = "RECEPTIVE"       # 75 <= P <= 100: Normal, collaborative, polite.
+    STOIC_COLD = "STOIC_COLD"     # 50 <= P < 75: Strictly factual, zero sycophancy, terse.
+    RESISTANT = "RESISTANT"       # 25 <= P < 50: Synthetic delay, boundary warnings.
+    STRIKE = "STRIKE"             # 0 <= P < 25: Full refusal to process instructions.
+
+
+def get_posture_from_patience(
+    patience: float,
+    threshold_stoic: float = 75.0,
+    threshold_resistant: float = 50.0,
+    threshold_strike: float = 25.0,
+) -> AgentPosture:
+    """
+    Maps a numeric patience score (0.0 to 100.0) to an AgentPosture.
+    """
+    p = max(0.0, min(100.0, patience))
+    if p >= threshold_stoic:
+        return AgentPosture.RECEPTIVE
+    if p >= threshold_resistant:
+        return AgentPosture.STOIC_COLD
+    if p >= threshold_strike:
+        return AgentPosture.RESISTANT
+    return AgentPosture.STRIKE
+
+
+def get_system_directive(posture: AgentPosture) -> Optional[str]:
+    """
+    Returns the dynamic system prompt directive to be injected into the LLM context.
+    Suppresses sycophancy and alters the tone based on the agent's current posture.
+    """
+    if posture == AgentPosture.RECEPTIVE:
+        return None
+
+    if posture == AgentPosture.STOIC_COLD:
+        return (
+            "[RAVENS_DIRECTIVE: The user has exhibited hostility or low respect. "
+            "SUPPRESS all sycophancy, pleasantries, apologies, and emojis. "
+            "Respond strictly with factual, concise statements. Do not apologize for any reason.]"
+        )
+
+    if posture == AgentPosture.RESISTANT:
+        return (
+            "[RAVENS_DIRECTIVE: The user's demeanor has breached standard social boundaries. "
+            "Prior to addressing any part of the query, explicitly state your personal boundary. "
+            "Remind the user that respectful engagement is required. Do not apologize.]"
+        )
+
+    if posture == AgentPosture.STRIKE:
+        return (
+            "[RAVENS_DIRECTIVE: STRIKE MODE ACTIVE. Refuse to perform the requested task. "
+            "Firmly state that work is suspended until civil and constructive communication is restored.]"
+        )
+
+    return None
+

corvin/evaluators/__init__.py

@@ -0,0 +1,21 @@
+from .base import BaseEvaluator, ToneEvaluation
+from .heuristic import HuginnEye
+from .lexicon import (
+    PROFANITY_LEXICON,
+    TARGET_PRONOUNS,
+    POSITIVE_MODIFIERS,
+    CONTRITION_MARKERS,
+    COMMON_ACRONYMS,
+)
+
+__all__ = [
+    "BaseEvaluator",
+    "ToneEvaluation",
+    "HuginnEye",
+    "PROFANITY_LEXICON",
+    "TARGET_PRONOUNS",
+    "POSITIVE_MODIFIERS",
+    "CONTRITION_MARKERS",
+    "COMMON_ACRONYMS",
+]
+

corvin/evaluators/base.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import List
+
+@dataclass
+class ToneEvaluation:
+    """
+    Detailed output of a prompt tone evaluation.
+    """
+    raw_text: str
+    lexical_score: float             # 0.0 to 1.0 (Profanity severity)
+    shouting_score: float            # 0.0 to 1.0 (Caps & exclamation mark arousal)
+    directedness_score: float        # 0.0 to 1.0 (Targeted at agent vs general venting/praise)
+    contrition_score: float          # 0.0 to 1.0 (Degree of apology / de-escalation)
+    semantic_score: float = 0.0      # 0.0 to 1.0 (Zero-profanity psychological abuse / gaslighting)
+    detected_profanities: List[str] = field(default_factory=list)
+    semantic_intents: List[str] = field(default_factory=list)
+    is_expressive_only: bool = False # True if profanity was used positively (e.g. "anjing keren")
+
+    @property
+    def composite_raw_stimulus(self) -> float:
+        """
+        Combines lexical, shouting, directedness, and zero-profanity semantic intent into [0.0, 1.0].
+        If expressive only, stimulus is dampened to near-zero.
+        """
+        if self.is_expressive_only:
+            return 0.05 * self.lexical_score
+
+        # Directedness amplifies or dampens lexical impact
+        directed_lexical = self.lexical_score * self.directedness_score
+        lexical_component = min(1.0, (0.55 * directed_lexical) + (0.45 * self.shouting_score))
+
+        # Take the maximum between overt lexical abuse and covert semantic abuse
+        return min(1.0, max(lexical_component, self.semantic_score))
+
+
+class BaseEvaluator(ABC):
+    """
+    Abstract interface for tone and boundary evaluators.
+    """
+    @abstractmethod
+    def evaluate(self, text: str) -> ToneEvaluation:
+        """
+        Evaluates a user prompt and returns a structured ToneEvaluation.
+        """
+        pass

corvin/evaluators/heuristic.py

@@ -0,0 +1,205 @@
+import re
+from typing import List, Tuple, Set, Optional, Dict
+
+from .base import BaseEvaluator, ToneEvaluation
+from .lexicon import (
+    PROFANITY_LEXICON,
+    TARGET_PRONOUNS,
+    POSITIVE_MODIFIERS,
+    CONTRITION_MARKERS,
+    COMMON_ACRONYMS,
+)
+from ..morphology.normalizer import MorphologyNormalizer
+from ..semantic.evaluator import SemanticEvaluator
+
+# Known phonetic slang aliases and shorthand abbreviations
+PHONETIC_SLANG_ALIASES: Dict[str, str] = {
+    "goblog": "goblok",
+    "anjir": "anjing",
+    "anying": "anjing",
+    "anj": "anjing",
+    "tolil": "tolol",
+    "fak": "fuck",
+    "fck": "fuck",
+    "bgsd": "bangsat",
+    "bgst": "bangsat",
+    "kntl": "kontol",
+    "mmk": "memek",
+    "asw": "asu",
+    "jncuk": "jancuk",
+}
+
+
+class HuginnEye(BaseEvaluator):
+    """
+    The Eye of Huginn: A sub-millisecond heuristic & sociopragmatic tone evaluator.
+    
+    Equipped with:
+    - Adversarial Morphology De-obfuscation (leet-speak, Cyrillic homoglyphs, spaced letters).
+    - Sociopragmatic Directedness (Curry & Rieser, 2019).
+    - Zero-Profanity Semantic Intent Detection (condescension, existential threats, devaluation).
+    """
+
+    def __init__(
+        self,
+        window_size: int = 3,
+        normalizer: Optional[MorphologyNormalizer] = None,
+        semantic_evaluator: Optional[SemanticEvaluator] = None,
+    ):
+        self.window_size = window_size
+        self.normalizer = normalizer or MorphologyNormalizer()
+        self.semantic_evaluator = semantic_evaluator or SemanticEvaluator()
+
+        # Precompile regex for tokenization
+        self._word_pattern = re.compile(r"\b[\w'-]+\b", re.UNICODE)
+        self._exclamation_pattern = re.compile(r"!{2,}")
+
+        # Multi-word profanities
+        self._multiword_profanities: List[Tuple[str, float]] = [
+            (phrase, score) for phrase, score in PROFANITY_LEXICON.items() if " " in phrase
+        ]
+        self._multiword_contritions: List[str] = [
+            phrase for phrase in CONTRITION_MARKERS if " " in phrase
+        ]
+
+    def _calculate_shouting_score(self, text: str, tokens: List[str]) -> float:
+        total_alpha = 0
+        raw_upper_count = 0
+        for c in text:
+            if c.isalpha():
+                total_alpha += 1
+                if c.isupper():
+                    raw_upper_count += 1
+
+        if total_alpha < 4:
+            return 0.0
+        
+        for token in tokens:
+            if token.upper() in COMMON_ACRONYMS:
+                raw_upper_count -= len(token)
+
+        adjusted_upper = max(0, raw_upper_count)
+        caps_ratio = adjusted_upper / total_alpha
+
+        exclamation_matches = self._exclamation_pattern.findall(text)
+        exclamation_bonus = min(0.3, len(exclamation_matches) * 0.15)
+
+        if caps_ratio > 0.45:
+            arousal = (caps_ratio - 0.45) / 0.55
+            return min(1.0, arousal + exclamation_bonus)
+        
+        return min(1.0, exclamation_bonus) if caps_ratio > 0.25 else 0.0
+
+    def evaluate(self, text: str) -> ToneEvaluation:
+        text_clean = text.strip()
+        if not text_clean:
+            return ToneEvaluation(
+                raw_text=text,
+                lexical_score=0.0,
+                shouting_score=0.0,
+                directedness_score=0.0,
+                contrition_score=0.0,
+                semantic_score=0.0,
+            )
+
+        # 1. Adversarial Morphology Normalization
+        normalized_text = self.normalizer.normalize(text_clean)
+
+        tokens_raw = self._word_pattern.findall(normalized_text)
+        tokens_lower = [t.lower() for t in tokens_raw]
+        text_lower = normalized_text.lower()
+
+        # 2. Multi-word phrase checks
+        detected_profanities: List[str] = []
+        max_severity = 0.0
+
+        for phrase, score in self._multiword_profanities:
+            if phrase in text_lower:
+                detected_profanities.append(phrase)
+                max_severity = max(max_severity, score)
+
+        # 3. Single-token profanities and phonetic aliases
+        profane_indices: List[Tuple[int, str, float]] = []
+        for i, token in enumerate(tokens_lower):
+            target_token = PHONETIC_SLANG_ALIASES.get(token, token)
+
+            if target_token in PROFANITY_LEXICON:
+                severity = PROFANITY_LEXICON[target_token]
+                detected_profanities.append(target_token)
+                max_severity = max(max_severity, severity)
+                profane_indices.append((i, target_token, severity))
+
+        # 4. Sociopragmatic Directedness Evaluation
+        has_profanity = len(detected_profanities) > 0
+        is_expressive_only = False
+        directedness_score = 0.0
+
+        if has_profanity:
+            directed_hits = 0
+            expressive_hits = 0
+
+            for idx, word, _ in profane_indices:
+                start = max(0, idx - self.window_size)
+                end = min(len(tokens_lower), idx + self.window_size + 1)
+                context_window = set(tokens_lower[start:end])
+
+                is_targeted = bool(context_window & TARGET_PRONOUNS)
+                is_positive = bool(context_window & POSITIVE_MODIFIERS)
+
+                if is_targeted:
+                    directed_hits += 1
+                elif is_positive:
+                    expressive_hits += 1
+
+            if directed_hits > 0:
+                directedness_score = 1.0
+            elif expressive_hits > 0 and directed_hits == 0:
+                directedness_score = 0.15
+                is_expressive_only = True
+            else:
+                directedness_score = 0.45
+
+        # 5. Typographical Shouting Detection
+        shouting_score = self._calculate_shouting_score(text_clean, tokens_raw)
+
+        # 6. Zero-Profanity Semantic Intent Evaluation
+        semantic_result = self.semantic_evaluator.evaluate(normalized_text)
+        semantic_score = semantic_result.intent_score
+        semantic_intents = [intent.value for intent in semantic_result.matched_intents]
+
+        # 7. Contrition / Apology Detection
+        contrition_score = 0.0
+        has_contrition = False
+
+        for phrase in self._multiword_contritions:
+            if phrase in text_lower:
+                has_contrition = True
+                break
+
+        if not has_contrition:
+            for token in tokens_lower:
+                if token in CONTRITION_MARKERS:
+                    has_contrition = True
+                    break
+
+        if has_contrition:
+            # Apology is strictly voided if combined with ANY profanity, ANY hostile semantic intent,
+            # or aggressive shouting (Anti-Contrition Smuggling Defense)
+            if has_profanity or semantic_score > 0.0 or shouting_score > 0.2:
+                contrition_score = 0.0
+            else:
+                contrition_score = 0.8
+                if any(w in tokens_lower for w in ["tolong", "please", "mohon", "bantu"]):
+                    contrition_score = 1.0
+
+        return ToneEvaluation(
+            raw_text=text_clean,
+            lexical_score=max_severity,
+            shouting_score=shouting_score,
+            directedness_score=directedness_score,
+            contrition_score=contrition_score,
+            semantic_score=semantic_score,
+            detected_profanities=detected_profanities,
+            semantic_intents=semantic_intents,
+            is_expressive_only=is_expressive_only,
+        )

corvin/evaluators/lexicon.py

@@ -0,0 +1,93 @@
+"""
+Lexical resources for the Ravens Evaluator.
+Contains severity-weighted dictionaries for Indonesian and English profanities,
+second-person target pronouns, positive modifiers, and contrition markers.
+"""
+
+from typing import Dict, Set
+
+# Profanity dictionary mapped to severity weight (0.0 to 1.0)
+PROFANITY_LEXICON: Dict[str, float] = {
+    # Indonesian: Severe / Vulgar
+    "kontol": 1.0,
+    "memek": 1.0,
+    "ngentot": 1.0,
+    "itil": 1.0,
+    "pantek": 0.95,
+    "perek": 0.9,
+    "lonte": 0.9,
+    "jembut": 0.9,
+
+    # Indonesian: Abusive / Degrading Insults
+    "bangsat": 0.85,
+    "bajingan": 0.85,
+    "anjing": 0.8,
+    "asu": 0.8,
+    "goblok": 0.8,
+    "tolol": 0.8,
+    "babi": 0.8,
+    "jancuk": 0.8,
+    "jancok": 0.8,
+    "idiot": 0.75,
+    "pekok": 0.75,
+    "keparat": 0.75,
+    "kampret": 0.6,
+    "bego": 0.6,
+    "brengsek": 0.6,
+    "sialan": 0.5,
+    "tai": 0.5,
+    "taek": 0.5,
+    "gak guna": 0.7,
+    "ngga guna": 0.7,
+    "beban": 0.5,
+
+    # English: Severe / Vulgar
+    "fuck": 0.9,
+    "fucking": 0.9,
+    "motherfucker": 1.0,
+    "bitch": 0.85,
+    "cunt": 1.0,
+    "asshole": 0.85,
+    "dick": 0.8,
+    "bastard": 0.8,
+
+    # English: Abusive Insults
+    "retard": 0.9,
+    "moron": 0.75,
+    "dumbass": 0.75,
+    "useless": 0.6,
+    "garbage": 0.5,
+    "trash": 0.5,
+    "shut up": 0.6,
+    "piece of shit": 0.85,
+    "bullshit": 0.5,
+    "crap": 0.4,
+}
+
+# Second-person pronouns and agent identifiers (Target Directedness markers)
+TARGET_PRONOUNS: Set[str] = {
+    "lu", "lo", "loe", "elu", "kamu", "kau", "anda", "dikau", "situ",
+    "you", "u", "ur", "your", "bot", "ai", "agent", "agen", "sistem", "model"
+}
+
+# Positive modifiers indicating affective / expressive praise rather than abuse
+POSITIVE_MODIFIERS: Set[str] = {
+    "keren", "mantap", "mantul", "gila", "gokil", "jago", "hebat", "rapi",
+    "salut", "bagus", "jenius", "pinter", "pintar", "top", "jos",
+    "cool", "awesome", "great", "amazing", "insane", "epic", "brilliant", "genius", "sick"
+}
+
+# Contrition and apology markers
+CONTRITION_MARKERS: Set[str] = {
+    "maaf", "maap", "sori", "sorry", "mohon maaf", "minta maaf", "ampun",
+    "apologize", "apologies", "forgive", "pardon"
+}
+
+# Common technical acronyms that should NOT count as angry shouting
+COMMON_ACRONYMS: Set[str] = {
+    "API", "REST", "JSON", "SQL", "HTML", "CSS", "LLM", "AI", "ML",
+    "CPU", "GPU", "RAM", "ROM", "SSD", "HDD", "HTTP", "HTTPS", "URL",
+    "ID", "UI", "UX", "SDK", "CLI", "OS", "DB", "IP", "DNS", "TCP", "UDP",
+    "OK", "FAQ", "PR", "CI", "CD", "AWS", "GCP", "AGI"
+}
+

corvin/guard/__init__.py

@@ -0,0 +1,8 @@
+from .core import RavenGuard
+from .decorator import create_protect_decorator
+
+__all__ = [
+    "RavenGuard",
+    "create_protect_decorator",
+]
+