openplan-mcp 0.8.2__py3-none-any.whl

openplan/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__ = _pkg_version("openplan")
+except PackageNotFoundError:
+    __version__ = "0.8.2"
+
+VERSION = __version__

openplan/__main__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import sys
+
+
+def main() -> None:
+    if len(sys.argv) >= 2 and sys.argv[1] in ("auth", "subscribe", "status", "--help", "-h"):
+        from openplan.cli import main as cli_main
+        cli_main()
+    else:
+        from openplan.server import main as server_main
+        import anyio
+        anyio.run(server_main)
+
+
+if __name__ == "__main__":
+    main()

openplan/cli.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "openplan"
+CREDENTIALS_FILE = CONFIG_DIR / "credentials.json"
+
+
+def _load_credentials() -> dict[str, Any]:
+    if CREDENTIALS_FILE.exists():
+        try:
+            return json.loads(CREDENTIALS_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            pass
+    return {}
+
+
+def _save_credentials(data: dict[str, Any]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CREDENTIALS_FILE.write_text(json.dumps(data, indent=2))
+    CREDENTIALS_FILE.chmod(0o600)
+
+
+def _get_api_key() -> str | None:
+    if key := os.environ.get("OPENPLAN_API_KEY"):
+        return key
+    creds = _load_credentials()
+    return creds.get("api_key")
+
+
+def cmd_auth_login(args: list[str]) -> None:
+    """Authenticate with GitHub via device code flow."""
+    api_url = os.environ.get("OPENPLAN_API_URL", "https://api.openplan.cc")
+
+    print("Open the following URL in your browser and enter the code shown.")
+    print()
+
+    try:
+        import httpx
+        resp = httpx.post(f"{api_url}/oauth/authorize", json={
+            "client_id": "openplan-cli",
+            "scope": "user:email",
+        }, timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+    except Exception as e:
+        print(f"Failed to start authentication: {e}")
+        sys.exit(1)
+
+    user_code = data["user_code"]
+    verification_uri = data.get("verification_uri", "https://github.com/login/device")
+    device_code = data["device_code"]
+    interval = data.get("interval", 5)
+
+    print(f"  {verification_uri}")
+    print(f"  Enter code: {user_code}")
+    print()
+
+    import time
+    try:
+        import httpx
+        while True:
+            time.sleep(interval)
+            resp = httpx.post(f"{api_url}/oauth/token", json={
+                "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                "device_code": device_code,
+                "client_id": "openplan-cli",
+            }, timeout=10)
+            token_data = resp.json()
+            if resp.status_code == 200:
+                access_token = token_data["access_token"]
+                refresh_token = token_data.get("refresh_token", "")
+
+                # Exchange access token for an API key
+                key_resp = httpx.post(f"{api_url}/api/keys", headers={
+                    "Authorization": f"Bearer {access_token}",
+                }, json={"tier": "pro"}, timeout=10)
+                key_resp.raise_for_status()
+                api_key = key_resp.json()["api_key"]
+
+                _save_credentials({
+                    "api_key": api_key,
+                    "refresh_token": refresh_token,
+                    "tier": "pro",
+                })
+                print("✓ Authentication complete")
+                print("✓ Pro tier enabled")
+                print(f"  Config: {CREDENTIALS_FILE}")
+                return
+            elif token_data.get("error") == "authorization_pending":
+                continue
+            elif token_data.get("error") == "slow_down":
+                interval += 5
+                continue
+            elif token_data.get("error") == "access_denied":
+                print("Authentication cancelled.")
+                sys.exit(1)
+            elif token_data.get("error") == "expired_token":
+                print("Session expired. Try again.")
+                sys.exit(1)
+            else:
+                print(f"Unexpected error: {token_data}")
+                sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nCancelled.")
+        sys.exit(1)
+
+
+def cmd_auth_logout(args: list[str]) -> None:
+    """Remove stored credentials."""
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()
+        api_url = os.environ.get("OPENPLAN_API_URL", "https://api.openplan.cc")
+        key = _get_api_key()
+        if key:
+            try:
+                import httpx
+                httpx.post(f"{api_url}/api/keys/revoke", json={"api_key": key}, timeout=10)
+            except Exception:
+                pass
+        print("✓ Credentials removed")
+    else:
+        print("No credentials found")
+
+
+def cmd_auth_status(args: list[str]) -> None:
+    """Show authentication status."""
+    creds = _load_credentials()
+    env_key = os.environ.get("OPENPLAN_API_KEY")
+
+    if env_key:
+        print("Authentication: API key from OPENPLAN_API_KEY env var")
+    elif creds.get("api_key"):
+        print("Authentication: stored credentials")
+        print(f"  Tier: {creds.get('tier', 'unknown')}")
+        print(f"  Config: {CREDENTIALS_FILE}")
+    else:
+        print("Authentication: none (free tier)")
+        print("  Run 'openplan auth login' to authenticate with GitHub")
+
+
+def cmd_subscribe(args: list[str]) -> None:
+    """Open Stripe Checkout for Pro subscription."""
+    api_key = _get_api_key()
+    if not api_key:
+        print("You need to authenticate first.")
+        print("Run: openplan auth login")
+        sys.exit(1)
+
+    api_url = os.environ.get("OPENPLAN_API_URL", "https://api.openplan.cc")
+    plan = args[0] if args else "pro"
+
+    try:
+        import httpx
+        resp = httpx.post(f"{api_url}/checkout", json={
+            "plan": plan,
+            "api_key": api_key,
+        }, timeout=10)
+        resp.raise_for_status()
+        checkout_url = resp.json()["checkout_url"]
+    except Exception as e:
+        print(f"Failed to create checkout session: {e}")
+        sys.exit(1)
+
+    import webbrowser
+    webbrowser.open(checkout_url)
+    print(f"Opened browser for Stripe Checkout ({plan} plan)")
+    print("Complete payment in the browser.")
+
+    import time
+    deadline = time.time() + 300  # 5 minute timeout
+    poll_count = 0
+    try:
+        while time.time() < deadline:
+            time.sleep(3)
+            poll_count += 1
+            if poll_count % 5 == 0:
+                print(f"  Waiting for payment... ({int(deadline - time.time())}s remaining)")
+            try:
+                resp = httpx.get(f"{api_url}/api/subscription/status", headers={
+                    "Authorization": f"Bearer {api_key}",
+                }, timeout=10)
+                data = resp.json()
+                if data.get("status") == "active":
+                    print("✓ Subscription active")
+                    print(f"  Tier: {data.get('tier', 'pro')}")
+                    return
+            except Exception:
+                pass
+        print("Timed out waiting for subscription. Complete payment at the Stripe page.")
+    except KeyboardInterrupt:
+        print("\nCancelled.")
+
+
+def cmd_status(args: list[str]) -> None:
+    """Show OpenPlan status and sync info."""
+    api_key = _get_api_key()
+    api_url = os.environ.get("OPENPLAN_API_URL", "https://api.openplan.cc")
+
+    creds = _load_credentials()
+    tier = creds.get("tier", "free") if not os.environ.get("OPENPLAN_API_KEY") else "pro (env)"
+
+    from openplan import VERSION
+    print(f"OpenPlan v{VERSION}")
+    print(f"Tier: {tier}")
+    print()
+
+    if api_key:
+        try:
+            import httpx
+            resp = httpx.get(f"{api_url}/api/keys/usage", headers={
+                "Authorization": f"Bearer {api_key}",
+            }, timeout=10)
+            data = resp.json()
+            print(f"Events synced: {data.get('event_count', '?')}")
+            print(f"Sync rate: {data.get('rate_limit', '?')}/min")
+        except Exception:
+            print("API: unreachable")
+    else:
+        print("Free tier (anonymous)")
+        print("Run 'openplan auth login' to enable Pro features")
+
+
+def main() -> None:
+    import sys
+    if len(sys.argv) < 2 or sys.argv[1] in ("--help", "-h"):
+        print("OpenPlan — Waze for AI agents planning")
+        print()
+        print("Usage:")
+        print("  openplan                  Start MCP server")
+        print("  openplan auth login       Authenticate with GitHub")
+        print("  openplan auth logout      Remove credentials")
+        print("  openplan auth status      Show authentication state")
+        print("  openplan subscribe [plan] Start Pro subscription")
+        print("  openplan status           Show OpenPlan status")
+        print()
+        print("Docs: https://github.com/anomalyco/opencode")
+        return
+
+    cmd = sys.argv[1]
+    if cmd == "auth":
+        if len(sys.argv) < 3:
+            print("Usage: openplan auth <login|logout|status>")
+            return
+        sub = sys.argv[2]
+        if sub == "login":
+            cmd_auth_login(sys.argv[3:])
+        elif sub == "logout":
+            cmd_auth_logout(sys.argv[3:])
+        elif sub == "status":
+            cmd_auth_status(sys.argv[3:])
+        else:
+            print(f"Unknown auth command: {sub}")
+    elif cmd == "subscribe":
+        cmd_subscribe(sys.argv[2:])
+    elif cmd == "status":
+        cmd_status(sys.argv[2:])
+    else:
+        print(f"Unknown command: {cmd}")
+        sys.exit(1)

openplan/config.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import copy
+import json
+import os
+from typing import Any
+
+CONFIG_SCHEMA: dict[str, dict[str, Any]] = {
+    "db_path": {"type": str, "default": "openplan.db"},
+    "stale_days": {"type": int, "default": 2, "min": 1, "max": 365},
+    "wip_limit": {"type": int, "default": 20, "min": 1, "max": 1000},
+    "activation_threshold": {"type": float, "default": 0.5, "min": 0.0, "max": 1.0},
+    "plan_limit": {"type": int, "default": 10, "min": 1, "max": 100},
+    "expansion_limit": {"type": int, "default": 5, "min": 1, "max": 50},
+    "avg_edge_cost": {"type": float, "default": 5000.0, "min": 100, "max": 1000000},
+    "heuristic_scale": {"type": float, "default": 1.0, "min": 0.1, "max": 10.0},
+    "reverse_penalty": {"type": float, "default": 3.0, "min": 1.0, "max": 100.0},
+    "risk_adjustment": {"type": str, "default": "probability", "values": ["none", "probability", "variance"]},
+    "tune_interval": {"type": int, "default": 10, "min": 0, "max": 1000},
+    "activation_weights": {"type": dict, "default": {"in_degree": 0.33, "frontier": 0.24, "recency": 0.19, "boost": 0.09, "visit": 0.1, "novelty": 0.05}},
+    "learning": {"type": dict, "default": {}},
+    "embedding": {"type": dict, "default": {}},
+    "page_rank": {"type": dict, "default": {}},
+    "stale_branch_hours": {"type": int, "default": 24, "min": 1, "max": 720},
+    "recommend_weights": {"type": dict, "default": {}},
+    "maintenance_interval_minutes": {"type": int, "default": 5, "min": 1, "max": 1440},
+    "adaptive_weights": {"type": dict, "default": {}},
+    "insight_similarity_threshold": {"type": float, "default": 0.7, "min": 0.0, "max": 1.0},
+    "api_url": {"type": str, "default": ""},
+}
+
+
+def _validate_config(raw: dict[str, Any]) -> dict[str, Any]:
+    validated: dict[str, Any] = {}
+    for key, value in raw.items():
+        spec = CONFIG_SCHEMA.get(key)
+        if not spec:
+            raise ValueError(f"Unknown config key: '{key}'")
+        expected_type = spec["type"]
+        if not isinstance(value, expected_type):
+            raise TypeError(f"Config '{key}' must be {expected_type.__name__}, got {type(value).__name__}")
+        if expected_type in (int, float) and "min" in spec and value < spec["min"]:
+            raise ValueError(f"Config '{key}' must be >= {spec['min']}, got {value}")
+        if expected_type in (int, float) and "max" in spec and value > spec["max"]:
+            raise ValueError(f"Config '{key}' must be <= {spec['max']}, got {value}")
+        if "values" in spec and value not in spec["values"]:
+            raise ValueError(f"Config '{key}' must be one of {spec['values']}, got '{value}'")
+        validated[key] = value
+    return validated
+
+
+def load_config(config_path: str | None = None) -> dict[str, Any]:
+    cfg: dict[str, Any] = {}
+    for key, spec in CONFIG_SCHEMA.items():
+        cfg[key] = copy.deepcopy(spec["default"])
+    cfg["db_path"] = os.environ.get("OPENPLAN_DB_PATH", cfg.get("db_path", "openplan.db"))
+    if config_path and os.path.exists(config_path):
+        with open(config_path) as f:
+            raw = json.load(f)
+        validated = _validate_config(raw)
+        for key in list(cfg.keys()):
+            if key in validated and isinstance(validated[key], dict) and isinstance(cfg[key], dict):
+                merged = dict(cfg[key])
+                merged.update(validated[key])
+                validated[key] = merged
+        cfg.update(validated)
+    return cfg

openplan/core/activation.py

@@ -0,0 +1,295 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+from datetime import datetime, timezone
+from typing import Any
+
+
+class ActivationContext:
+    def __init__(self) -> None:
+        self.cache: dict[str, float] = {}
+        self.dirty: set[str] = set()
+        self.cache_order: list[str] = []
+        self.visiting: set[str] = set()
+        self.max_in_degree: int = 1
+        self.validation_counter: int = 0
+        self.VALIDATE_EVERY: int = 100
+        self.max_in_degree_initialized: bool = False
+        self.lock = threading.RLock()
+
+    def increment_max_in_degree(self, target_id: str, conn: sqlite3.Connection) -> None:
+        with self.lock:
+            cnt = conn.execute(
+                "SELECT COUNT(*) AS cnt FROM edges WHERE target_id = ?", (target_id,)
+            ).fetchone()["cnt"]
+            if cnt > self.max_in_degree:
+                self.max_in_degree = cnt
+            self.validation_counter += 1
+            if self.validation_counter >= self.VALIDATE_EVERY:
+                self._validate_max_in_degree(conn)
+
+    def _validate_max_in_degree(self, conn: sqlite3.Connection) -> None:
+        row = conn.execute(
+            "SELECT COUNT(*) AS cnt FROM edges GROUP BY target_id ORDER BY cnt DESC LIMIT 1"
+        ).fetchone()
+        self.max_in_degree = row["cnt"] if row else 1
+        self.validation_counter = 0
+
+    def _get_max_in_degree(self, conn: sqlite3.Connection) -> int:
+        if not self.max_in_degree_initialized:
+            self._validate_max_in_degree(conn)
+            self.max_in_degree_initialized = True
+        return self.max_in_degree
+
+    def _get_outgoing_count(self, state_id: str, conn: sqlite3.Connection) -> int:
+        row = conn.execute(
+            "SELECT COUNT(*) AS cnt FROM edges WHERE source_id = ?", (state_id,)
+        ).fetchone()
+        return row["cnt"]
+
+    def _recompute_cache_order(self, conn: sqlite3.Connection) -> None:
+        self.cache_order = sorted(
+            self.dirty,
+            key=lambda s: (
+                self._get_outgoing_count(s, conn),
+                -conn.execute(
+                    "SELECT COUNT(*) AS cnt FROM edges WHERE target_id = ?", (s,)
+                ).fetchone()["cnt"],
+                s,
+            ),
+        )
+
+    def mark_dirty(self, state_id: str, conn: sqlite3.Connection) -> None:
+        with self.lock:
+            self.dirty.add(state_id)
+            preds = conn.execute(
+                "SELECT DISTINCT source_id FROM edges WHERE target_id = ?", (state_id,)
+            ).fetchall()
+            for p in preds:
+                self.dirty.add(p["source_id"])
+            self._recompute_cache_order(conn)
+
+    def _compute_frontier_ratio(self, state_id: str, conn: sqlite3.Connection, config: dict[str, Any]) -> float:
+        threshold = config.get("activation_threshold", 0.5)
+        edges = conn.execute(
+            "SELECT target_id FROM edges WHERE source_id = ?", (state_id,)
+        ).fetchall()
+        if not edges:
+            return 0.0
+        active = 0
+        for e in edges:
+            target_act = self.cache.get(e["target_id"], 0.0)
+            if target_act > threshold:
+                active += 1
+        return active / len(edges)
+
+    def _compute_in_degree_ratio(self, state_id: str, conn: sqlite3.Connection) -> float:
+        row = conn.execute(
+            "SELECT COUNT(*) AS cnt FROM edges WHERE target_id = ?", (state_id,)
+        ).fetchone()
+        cnt = row["cnt"]
+        max_in = self._get_max_in_degree(conn)
+        return min(cnt / max_in, 1.0) if max_in > 0 else 0.0
+
+    def _compute_recency(self, state_id: str, conn: sqlite3.Connection, stale_days: int) -> float:
+        row = conn.execute(
+            "SELECT updated_at FROM nodes WHERE id = ?", (state_id,)
+        ).fetchone()
+        if not row:
+            return 0.0
+        updated = row["updated_at"]
+        try:
+            updated_dt = datetime.fromisoformat(updated.replace("Z", "+00:00"))
+        except (ValueError, TypeError):
+            return 0.0
+        now = datetime.now(timezone.utc)
+        if updated_dt.tzinfo is None:
+            updated_dt = updated_dt.replace(tzinfo=timezone.utc)
+        delta = now - updated_dt
+        days = delta.total_seconds() / 86400.0
+        return 1.0 - min(days / stale_days, 1.0)
+
+    def _compute_agent_boost(self, state_id: str, conn: sqlite3.Connection) -> float:
+        row = conn.execute(
+            "SELECT props FROM nodes WHERE id = ?", (state_id,)
+        ).fetchone()
+        if not row:
+            return 0.5
+        try:
+            props = json.loads(row["props"])
+        except (json.JSONDecodeError, TypeError):
+            return 0.5
+        if props.get("boost") is True:
+            boosted_at = props.get("boosted_at")
+            if boosted_at:
+                try:
+                    bt = datetime.fromisoformat(boosted_at)
+                    now = datetime.now(timezone.utc)
+                    if bt.tzinfo is None:
+                        bt = bt.replace(tzinfo=timezone.utc)
+                    hours = (now - bt).total_seconds() / 3600.0
+                    if hours > 24:
+                        return 0.5
+                except (ValueError, TypeError):
+                    pass
+            return 1.0
+        return 0.5
+
+    def _compute_visit_ratio(self, state_id: str, conn: sqlite3.Connection) -> float:
+        row = conn.execute("SELECT props FROM nodes WHERE id = ?", (state_id,)).fetchone()
+        if not row:
+            return 0.0
+        try:
+            props = json.loads(row["props"])
+        except (json.JSONDecodeError, TypeError):
+            return 0.0
+        my_visits = props.get("visit_count", 0)
+        if my_visits == 0:
+            return 0.0
+        project_row = conn.execute("SELECT project FROM nodes WHERE id = ?", (state_id,)).fetchone()
+        if not project_row:
+            return 0.0
+        max_row = conn.execute(
+            "SELECT MAX(json_extract(props, '$.visit_count')) AS max_visits FROM nodes WHERE project = ?",
+            (project_row["project"],),
+        ).fetchone()
+        max_visits = max_row["max_visits"] if max_row and max_row["max_visits"] else 0
+        return min(my_visits / max_visits, 1.0) if max_visits > 0 else 0.0
+
+    def _compute_novelty_ratio(self, state_id: str, conn: sqlite3.Connection) -> float:
+        out_count = conn.execute(
+            "SELECT COUNT(*) AS cnt FROM edges WHERE source_id = ?", (state_id,)
+        ).fetchone()["cnt"]
+        return 1.0 / (out_count + 1)
+
+    def _compute_activation(self, state_id: str, conn: sqlite3.Connection, config: dict[str, Any]) -> float:
+        import hashlib
+        weights = dict(config.get("activation_weights", {}))
+        w_row = conn.execute(
+            "SELECT value FROM meta WHERE key = 'self_tuning:weight_config'"
+        ).fetchone()
+        if w_row:
+            try:
+                w_override = json.loads(w_row["value"])
+                if isinstance(w_override, dict):
+                    weights = w_override
+            except (json.JSONDecodeError, TypeError):
+                pass
+        w_in = weights.get("in_degree", 0.35)
+        w_frontier = weights.get("frontier", 0.25)
+        w_recency = weights.get("recency", 0.2)
+        w_boost = weights.get("boost", 0.1)
+        w_visit = weights.get("visit", 0.0)
+        w_novelty = weights.get("novelty", 0.0)
+        in_degree_ratio = self._compute_in_degree_ratio(state_id, conn)
+        frontier_ratio = self._compute_frontier_ratio(state_id, conn, config)
+        stale_days = config.get("stale_days", 2)
+        recency = self._compute_recency(state_id, conn, stale_days)
+        agent_boost = self._compute_agent_boost(state_id, conn)
+        visit_ratio = self._compute_visit_ratio(state_id, conn)
+        novelty = self._compute_novelty_ratio(state_id, conn)
+        raw = w_in * in_degree_ratio + w_frontier * frontier_ratio + w_recency * recency + w_boost * agent_boost + w_visit * visit_ratio + w_novelty * novelty
+        digest = hashlib.sha256(state_id.encode()).digest()[:4]
+        tiebreaker = int.from_bytes(digest, "big") / 1e16
+        return raw + tiebreaker
+
+    def _precompute_targets(self, state_id: str, conn: sqlite3.Connection, config: dict[str, Any]) -> None:
+        stack = [(state_id, 0)]
+        order: list[str] = []
+        while stack:
+            sid, idx = stack[-1]
+            if idx == 0:
+                if sid in self.visiting:
+                    stack.pop()
+                    continue
+                self.visiting.add(sid)
+                order.append(sid)
+            targets = conn.execute(
+                "SELECT target_id FROM edges WHERE source_id = ?", (sid,)
+            ).fetchall()
+            if idx < len(targets):
+                tid = targets[idx]["target_id"]
+                stack[-1] = (sid, idx + 1)
+                if tid not in self.cache and tid not in self.visiting:
+                    stack.append((tid, 0))
+            else:
+                stack.pop()
+                self.visiting.discard(sid)
+        for sid in reversed(order):
+            if sid not in self.cache:
+                act = self._compute_activation(sid, conn, config)
+                self.cache[sid] = act
+                threshold = config.get("activation_threshold", 0.5)
+                frontier = 1 if self._is_frontier(sid, act, conn, threshold) else 0
+                conn.execute(
+                    "UPDATE nodes SET activation = ?, frontier = ? WHERE id = ?",
+                    (act, frontier, sid),
+                )
+
+    def _is_frontier(self, state_id: str, activation: float, conn: sqlite3.Connection, threshold: float) -> bool:
+        if activation <= threshold:
+            return False
+        cnt = conn.execute(
+            "SELECT COUNT(*) AS cnt FROM edges WHERE source_id = ?", (state_id,)
+        ).fetchone()["cnt"]
+        return cnt > 0
+
+    def recompute_all_dirty(self, conn: sqlite3.Connection, config: dict[str, Any]) -> None:
+        with self.lock:
+            self._recompute_all_dirty_locked(conn, config)
+
+    def _recompute_all_dirty_locked(self, conn: sqlite3.Connection, config: dict[str, Any]) -> None:
+        threshold = config.get("activation_threshold", 0.5)
+        for sid in self.cache_order:
+            if sid in self.dirty:
+                act = self._compute_activation(sid, conn, config)
+                self.cache[sid] = act
+                self.dirty.discard(sid)
+                frontier = 1 if self._is_frontier(sid, act, conn, threshold) else 0
+                conn.execute(
+                    "UPDATE nodes SET activation = ?, frontier = ? WHERE id = ?",
+                    (act, frontier, sid),
+                )
+
+    def get_activation(self, state_id: str, conn: sqlite3.Connection, config: dict[str, Any]) -> float:
+        with self.lock:
+            if self.dirty:
+                self._recompute_all_dirty_locked(conn, config)
+            if state_id not in self.cache:
+                self._precompute_targets(state_id, conn, config)
+            return self.cache[state_id]
+
+    def reset(self) -> None:
+        with self.lock:
+            self.cache.clear()
+            self.dirty.clear()
+            self.cache_order.clear()
+            self.visiting.clear()
+            self.max_in_degree = 1
+            self.validation_counter = 0
+            self.max_in_degree_initialized = False
+
+
+_default_ctx = ActivationContext()
+
+
+def get_activation(state_id: str, conn: sqlite3.Connection, config: dict[str, Any], ctx: ActivationContext | None = None) -> float:
+    return (ctx or _default_ctx).get_activation(state_id, conn, config)
+
+
+def mark_dirty(state_id: str, conn: sqlite3.Connection, ctx: ActivationContext | None = None) -> None:
+    (ctx or _default_ctx).mark_dirty(state_id, conn)
+
+
+def recompute_all_dirty(conn: sqlite3.Connection, config: dict[str, Any], ctx: ActivationContext | None = None) -> None:
+    (ctx or _default_ctx).recompute_all_dirty(conn, config)
+
+
+def increment_max_in_degree(target_id: str, conn: sqlite3.Connection, ctx: ActivationContext | None = None) -> None:
+    (ctx or _default_ctx).increment_max_in_degree(target_id, conn)
+
+
+def reset_cache(ctx: ActivationContext | None = None) -> None:
+    (ctx or _default_ctx).reset()