alloc-context 0.1.0__py3-none-any.whl

alloccontext/store/db.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+SCHEMA_VERSION = 8
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS schema_meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS ingest_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  finished_at TEXT,
+  rows_upserted INTEGER NOT NULL DEFAULT 0,
+  error TEXT
+);
+
+CREATE TABLE IF NOT EXISTS portfolio_snapshots (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts TEXT NOT NULL UNIQUE,
+  nav_usd REAL,
+  cash_usd REAL,
+  allocation_json TEXT,
+  raw_json TEXT
+);
+
+CREATE TABLE IF NOT EXISTS market_bars (
+  pair TEXT NOT NULL,
+  interval_minutes INTEGER NOT NULL,
+  bar_ts INTEGER NOT NULL,
+  open REAL NOT NULL,
+  high REAL NOT NULL,
+  low REAL NOT NULL,
+  close REAL NOT NULL,
+  PRIMARY KEY (pair, interval_minutes, bar_ts)
+);
+
+CREATE TABLE IF NOT EXISTS fear_greed (
+  ts TEXT PRIMARY KEY,
+  value INTEGER NOT NULL,
+  classification TEXT,
+  fetched_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS kalshi_snapshots (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts TEXT NOT NULL,
+  tape_summary TEXT,
+  cluster_json TEXT,
+  raw_json TEXT
+);
+
+CREATE TABLE IF NOT EXISTS context_snapshots (
+  scope TEXT NOT NULL,
+  as_of TEXT NOT NULL,
+  context_json TEXT NOT NULL,
+  PRIMARY KEY (scope, as_of)
+);
+
+CREATE INDEX IF NOT EXISTS idx_context_snapshots_scope_as_of
+  ON context_snapshots(scope, as_of);
+
+CREATE TABLE IF NOT EXISTS macro_events (
+  event_id TEXT PRIMARY KEY,
+  event_ts TEXT NOT NULL,
+  country TEXT NOT NULL,
+  name TEXT NOT NULL,
+  impact TEXT NOT NULL,
+  category TEXT,
+  actual TEXT,
+  estimate TEXT,
+  previous TEXT,
+  unit TEXT,
+  source TEXT NOT NULL,
+  raw_json TEXT,
+  fetched_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_macro_events_ts ON macro_events(event_ts);
+
+CREATE TABLE IF NOT EXISTS etf_flow_days (
+  asset TEXT NOT NULL,
+  flow_date TEXT NOT NULL,
+  net_flow_usd REAL,
+  total_value_traded_usd REAL,
+  total_net_assets_usd REAL,
+  cum_net_inflow_usd REAL,
+  source TEXT NOT NULL,
+  fetched_at TEXT NOT NULL,
+  PRIMARY KEY (asset, flow_date)
+);
+
+CREATE TABLE IF NOT EXISTS etf_ticker_flows (
+  asset TEXT NOT NULL,
+  ticker TEXT NOT NULL,
+  flow_date TEXT NOT NULL,
+  net_flow_usd REAL,
+  net_assets_usd REAL,
+  institute TEXT,
+  source TEXT NOT NULL,
+  fetched_at TEXT NOT NULL,
+  PRIMARY KEY (asset, ticker, flow_date)
+);
+
+CREATE TABLE IF NOT EXISTS crypto_market_snapshots (
+  source TEXT NOT NULL,
+  snapshot_ts TEXT NOT NULL,
+  total_market_cap_usd REAL,
+  btc_dominance_pct REAL,
+  eth_dominance_pct REAL,
+  btc_rank INTEGER,
+  eth_rank INTEGER,
+  btc_price_usd REAL,
+  eth_price_usd REAL,
+  btc_market_cap_usd REAL,
+  eth_market_cap_usd REAL,
+  btc_change_pct_24h REAL,
+  eth_change_pct_24h REAL,
+  fetched_at TEXT NOT NULL,
+  PRIMARY KEY (source, snapshot_ts)
+);
+
+CREATE INDEX IF NOT EXISTS idx_crypto_market_snapshots_ts ON crypto_market_snapshots(snapshot_ts);
+
+CREATE TABLE IF NOT EXISTS fred_observations (
+  series_id TEXT NOT NULL,
+  obs_date TEXT NOT NULL,
+  value REAL,
+  fetched_at TEXT NOT NULL,
+  PRIMARY KEY (series_id, obs_date)
+);
+
+CREATE INDEX IF NOT EXISTS idx_fred_observations_series_date
+  ON fred_observations(series_id, obs_date);
+"""
+
+
+def connect(db_path: Path) -> sqlite3.Connection:
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA busy_timeout = 5000")
+    migrate(conn)
+    return conn
+
+
+def _migrate_brief_archive_to_context_snapshots(conn: sqlite3.Connection) -> None:
+    row = conn.execute(
+        """
+        SELECT name FROM sqlite_master
+        WHERE type = 'table' AND name = 'brief_archive'
+        """
+    ).fetchone()
+    if row is None:
+        return
+    conn.execute(
+        """
+        INSERT INTO context_snapshots(scope, as_of, context_json)
+        SELECT scope, as_of, context_json
+        FROM brief_archive
+        WHERE context_json IS NOT NULL AND context_json != ''
+        ON CONFLICT(scope, as_of) DO NOTHING
+        """
+    )
+
+
+def migrate(conn: sqlite3.Connection) -> None:
+    conn.executescript(_SCHEMA)
+    row = conn.execute(
+        "SELECT value FROM schema_meta WHERE key = 'version'"
+    ).fetchone()
+    if row is None:
+        conn.execute(
+            "INSERT INTO schema_meta(key, value) VALUES ('version', ?)",
+            (str(SCHEMA_VERSION),),
+        )
+        conn.commit()
+    elif int(row["value"]) < SCHEMA_VERSION:
+        if int(row["value"]) <= 7:
+            _migrate_brief_archive_to_context_snapshots(conn)
+        conn.execute(
+            "UPDATE schema_meta SET value = ? WHERE key = 'version'",
+            (str(SCHEMA_VERSION),),
+        )
+        conn.commit()
+    elif int(row["value"]) > SCHEMA_VERSION:
+        raise RuntimeError(
+            f"database schema version {row['value']} is newer than "
+            f"supported {SCHEMA_VERSION}; upgrade the application"
+        )
+
+
+def record_ingest_run(
+    conn: sqlite3.Connection,
+    *,
+    source: str,
+    started_at: str,
+    finished_at: str,
+    rows_upserted: int,
+    error: str | None = None,
+) -> None:
+    conn.execute(
+        """
+        INSERT INTO ingest_runs(source, started_at, finished_at, rows_upserted, error)
+        VALUES (?, ?, ?, ?, ?)
+        """,
+        (source, started_at, finished_at, rows_upserted, error),
+    )
+    conn.commit()

alloccontext/store/jsonutil.py

@@ -0,0 +1,10 @@
+"""Canonical JSON serialization for persisted snapshots."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def canonical_json(obj: Any) -> str:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"))

alloccontext/store/meta.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import sqlite3
+
+
+def get_meta(conn: sqlite3.Connection, key: str) -> str | None:
+    row = conn.execute(
+        "SELECT value FROM schema_meta WHERE key = ?", (key,)
+    ).fetchone()
+    return str(row["value"]) if row else None
+
+
+def set_meta(conn: sqlite3.Connection, key: str, value: str) -> None:
+    conn.execute(
+        """
+        INSERT INTO schema_meta(key, value) VALUES (?, ?)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value
+        """,
+        (key, value),
+    )

alloccontext/store/retention.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timezone
+from typing import Any
+
+from alloccontext.horizon import cutoff_iso, cutoff_unix, horizon_days
+
+
+def prune_to_horizon(conn: sqlite3.Connection, config) -> dict[str, int]:
+    """Drop rows older than the configured quarterly horizon."""
+    days = horizon_days(config)
+    fg_cutoff = str(cutoff_unix(days=days))
+    bar_cutoff = cutoff_unix(days=days)
+    ts_cutoff = cutoff_iso(days=days)
+
+    deleted: dict[str, int] = {}
+    deleted["fear_greed"] = conn.execute(
+        "DELETE FROM fear_greed WHERE CAST(ts AS INTEGER) < ?",
+        (fg_cutoff,),
+    ).rowcount
+    deleted["market_bars"] = conn.execute(
+        "DELETE FROM market_bars WHERE bar_ts < ?",
+        (bar_cutoff,),
+    ).rowcount
+    deleted["portfolio_snapshots"] = conn.execute(
+        "DELETE FROM portfolio_snapshots WHERE ts < ?",
+        (ts_cutoff,),
+    ).rowcount
+    deleted["kalshi_snapshots"] = conn.execute(
+        "DELETE FROM kalshi_snapshots WHERE ts < ?",
+        (ts_cutoff,),
+    ).rowcount
+    deleted["context_snapshots"] = conn.execute(
+        "DELETE FROM context_snapshots WHERE as_of < ?",
+        (ts_cutoff,),
+    ).rowcount
+    deleted["macro_events"] = conn.execute(
+        "DELETE FROM macro_events WHERE event_ts < ?",
+        (ts_cutoff,),
+    ).rowcount
+    deleted["etf_flow_days"] = conn.execute(
+        "DELETE FROM etf_flow_days WHERE flow_date < ?",
+        (ts_cutoff[:10],),
+    ).rowcount
+    deleted["etf_ticker_flows"] = conn.execute(
+        "DELETE FROM etf_ticker_flows WHERE flow_date < ?",
+        (ts_cutoff[:10],),
+    ).rowcount
+    deleted["crypto_market_snapshots"] = conn.execute(
+        "DELETE FROM crypto_market_snapshots WHERE snapshot_ts < ?",
+        (ts_cutoff,),
+    ).rowcount
+    deleted["fred_observations"] = conn.execute(
+        "DELETE FROM fred_observations WHERE obs_date < ?",
+        (ts_cutoff[:10],),
+    ).rowcount
+    deleted["ingest_runs"] = conn.execute(
+        "DELETE FROM ingest_runs WHERE finished_at < ?",
+        (ts_cutoff,),
+    ).rowcount
+    conn.commit()
+    return deleted

alloccontext/store/status.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime
+from typing import Any
+
+from alloccontext.mcp.staleness import age_seconds, parse_as_of
+from alloccontext.timeutil import utc_now
+
+
+def _finished_age_seconds(
+    finished_at: str | None,
+    *,
+    now: datetime | None = None,
+) -> int | None:
+    if not finished_at:
+        return None
+    try:
+        return age_seconds(parse_as_of(str(finished_at)), now=now)
+    except (TypeError, ValueError):
+        return None
+
+
+def _source_health(
+    last_by_source: dict[str, dict[str, Any]],
+    *,
+    now: datetime | None = None,
+) -> dict[str, dict[str, Any]]:
+    ref = now or utc_now()
+    health: dict[str, dict[str, Any]] = {}
+    for source, row in last_by_source.items():
+        error = row.get("error")
+        finished_at = row.get("finished_at")
+        health[source] = {
+            "ok": error is None,
+            "finished_at": finished_at,
+            "age_seconds": _finished_age_seconds(finished_at, now=ref),
+            "rows_upserted": row.get("rows_upserted"),
+            "error": error,
+        }
+    return health
+
+
+def ingest_status(
+    conn: sqlite3.Connection,
+    *,
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    fg = conn.execute(
+        """
+        SELECT ts, value, classification, fetched_at
+        FROM fear_greed ORDER BY CAST(ts AS INTEGER) DESC LIMIT 1
+        """
+    ).fetchone()
+    portfolio = conn.execute(
+        """
+        SELECT ts, nav_usd, cash_usd, allocation_json
+        FROM portfolio_snapshots ORDER BY ts DESC LIMIT 1
+        """
+    ).fetchone()
+    bars = conn.execute(
+        """
+        SELECT pair, interval_minutes, MAX(bar_ts) AS latest_bar_ts, COUNT(*) AS bar_count
+        FROM market_bars
+        GROUP BY pair, interval_minutes
+        ORDER BY pair
+        """
+    ).fetchall()
+    recent_ingest = conn.execute(
+        """
+        SELECT source, started_at, finished_at, rows_upserted, error
+        FROM ingest_runs ORDER BY id DESC LIMIT 20
+        """
+    ).fetchall()
+    last_by_source: dict[str, dict[str, Any]] = {}
+    for row in recent_ingest:
+        source = str(row["source"])
+        if source not in last_by_source:
+            last_by_source[source] = dict(row)
+
+    ref = now or utc_now()
+    return {
+        "fear_greed_latest": dict(fg) if fg else None,
+        "portfolio_latest": dict(portfolio) if portfolio else None,
+        "market_bars": [dict(row) for row in bars],
+        "last_ingest_by_source": last_by_source,
+        "source_health": _source_health(last_by_source, now=ref),
+        "recent_ingest": [dict(row) for row in recent_ingest[:10]],
+    }

alloccontext/timeutil.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc).replace(microsecond=0)
+
+
+def utc_now_iso() -> str:
+    return utc_now().isoformat()

alloccontext/x402_production_check.py

@@ -0,0 +1,193 @@
+"""x402 production verification (CDP facilitator + discovery endpoints)."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Mapping
+
+
+class X402ProductionCheckError(RuntimeError):
+    """One or more production checks failed."""
+
+
+@dataclass(frozen=True)
+class X402CheckConfig:
+    public_url: str
+    local_url: str
+    pay_to: str
+    network: str
+    facilitator: str
+    cdp_api_key_id: str | None
+    cdp_api_key_secret: str | None
+
+
+def load_check_config(env: Mapping[str, str] | None = None) -> X402CheckConfig:
+    source = env if env is not None else os.environ
+    public_url = source.get("X402_PUBLIC_URL", "").rstrip("/")
+    if not public_url:
+        raise X402ProductionCheckError("X402_PUBLIC_URL is required")
+    pay_to = source.get("X402_PAY_TO", "").strip()
+    if not pay_to:
+        raise X402ProductionCheckError("X402_PAY_TO is required")
+    return X402CheckConfig(
+        public_url=public_url,
+        local_url=source.get("X402_CHECK_LOCAL", "http://127.0.0.1:8000").rstrip("/"),
+        pay_to=pay_to,
+        network=source.get("X402_NETWORK", "eip155:84532").strip(),
+        facilitator=source.get(
+            "X402_FACILITATOR_URL",
+            "https://x402.org/facilitator",
+        ).strip(),
+        cdp_api_key_id=source.get("CDP_API_KEY_ID"),
+        cdp_api_key_secret=source.get("CDP_API_KEY_SECRET"),
+    )
+
+
+def check_cdp_facilitator(config: X402CheckConfig) -> str:
+    if not config.facilitator.startswith("https://api.cdp.coinbase.com"):
+        return f"facilitator {config.facilitator} (non-CDP)"
+    if not (config.cdp_api_key_id and config.cdp_api_key_secret):
+        raise X402ProductionCheckError(
+            "CDP facilitator requires CDP_API_KEY_ID and CDP_API_KEY_SECRET"
+        )
+    try:
+        import httpx
+        from cdp.x402 import create_facilitator_config
+    except ImportError as exc:
+        raise X402ProductionCheckError(
+            "cdp-sdk and httpx required for CDP facilitator check"
+        ) from exc
+    cfg = create_facilitator_config()
+    headers = cfg["create_headers"]()["supported"]
+    with httpx.Client(timeout=30) as client:
+        response = client.get(f"{cfg['url']}/supported", headers=headers)
+    if response.status_code != 200:
+        raise X402ProductionCheckError(
+            f"CDP /supported returned {response.status_code}: {response.text[:200]}"
+        )
+    return "CDP facilitator /supported authenticated"
+
+
+def _fetch_ok(url: str, *, timeout: float = 20) -> tuple[int, bytes]:
+    with urllib.request.urlopen(url, timeout=timeout) as response:
+        return response.status, response.read()
+
+
+def check_discovery_paths(config: X402CheckConfig) -> list[str]:
+    messages: list[str] = []
+    paths = ("/health", "/llms.txt", "/.well-known/x402.json")
+    for path in paths:
+        checked = False
+        for base in (config.local_url, config.public_url):
+            if not base:
+                continue
+            url = f"{base}{path}"
+            try:
+                status, _body = _fetch_ok(url)
+            except urllib.error.HTTPError as exc:
+                if base == config.local_url:
+                    continue
+                raise X402ProductionCheckError(f"{path} returned HTTP {exc.code}") from exc
+            except urllib.error.URLError:
+                if base == config.local_url:
+                    continue
+                raise
+            else:
+                if status != 200:
+                    if base == config.local_url:
+                        continue
+                    raise X402ProductionCheckError(f"{path} returned HTTP {status}")
+                messages.append(f"GET {path} -> 200 ({base})")
+                checked = True
+                break
+        if not checked:
+            raise X402ProductionCheckError(
+                f"could not reach {path} on local or public URL"
+            )
+    return messages
+
+
+def check_manifest_pay_to(config: X402CheckConfig) -> None:
+    manifest_base = config.local_url or config.public_url
+    _status, body = _fetch_ok(f"{manifest_base}/.well-known/x402.json")
+    manifest = json.loads(body)
+    if manifest.get("payment", {}).get("payTo") != config.pay_to:
+        raise X402ProductionCheckError("x402.json payTo does not match X402_PAY_TO")
+
+
+def check_discovery_metadata(config: X402CheckConfig) -> list[str]:
+    """Assert static discovery copy includes Bazaar title, tags, and keywords."""
+    from alloccontext.mcp.bazaar import (
+        BAZAAR_INDEX_TAGS,
+        BAZAAR_SERVICE_NAME,
+        DISCOVERY_KEYWORD_MARKERS,
+        SERVICE_NAME,
+        SERVICE_TITLE,
+    )
+
+    messages: list[str] = []
+    manifest_base = config.local_url or config.public_url
+    _status, manifest_body = _fetch_ok(f"{manifest_base}/.well-known/x402.json")
+    manifest = json.loads(manifest_body)
+    if manifest.get("name") != SERVICE_NAME:
+        raise X402ProductionCheckError("x402.json name missing or wrong")
+    if manifest.get("title") != SERVICE_TITLE:
+        raise X402ProductionCheckError("x402.json title missing or wrong")
+    manifest_tags = manifest.get("tags") or []
+    for tag in BAZAAR_INDEX_TAGS:
+        if tag not in manifest_tags:
+            raise X402ProductionCheckError(f"x402.json missing tag {tag!r}")
+    messages.append(f"x402.json title/tags ok ({len(manifest_tags)} tags)")
+
+    _status, llms_body = _fetch_ok(f"{manifest_base}/llms.txt")
+    llms = llms_body.decode("utf-8")
+    if BAZAAR_SERVICE_NAME not in llms and SERVICE_TITLE not in llms:
+        raise X402ProductionCheckError("llms.txt missing service title")
+    for marker in DISCOVERY_KEYWORD_MARKERS:
+        if marker not in llms.lower():
+            raise X402ProductionCheckError(f"llms.txt missing keyword marker {marker!r}")
+    messages.append("llms.txt discovery keywords ok")
+    return messages
+
+
+def check_mcp_payment_gate(config: X402CheckConfig) -> str:
+    mcp_base = config.local_url or config.public_url
+    req = urllib.request.Request(
+        f"{mcp_base}/mcp",
+        data=b'{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}',
+        headers={"Content-Type": "application/json", "Accept": "application/json"},
+        method="POST",
+    )
+    try:
+        urllib.request.urlopen(req, timeout=20)
+        raise X402ProductionCheckError("POST /mcp should return 402 without payment")
+    except urllib.error.HTTPError as exc:
+        if exc.code != 402:
+            raise X402ProductionCheckError(
+                f"POST /mcp returned HTTP {exc.code}, expected 402"
+            ) from exc
+        payment_required = exc.headers.get("PAYMENT-REQUIRED") or exc.headers.get(
+            "payment-required"
+        )
+        if not payment_required:
+            raise X402ProductionCheckError("POST /mcp 402 missing PAYMENT-REQUIRED header")
+    return "POST /mcp returns 402 with PAYMENT-REQUIRED"
+
+
+def run_production_checks(env: Mapping[str, str] | None = None) -> list[str]:
+    """Run all x402 production checks; return OK messages."""
+    config = load_check_config(env)
+    messages = [
+        f"public URL {config.public_url}",
+        f"network {config.network}",
+    ]
+    messages.append(check_cdp_facilitator(config))
+    messages.extend(check_discovery_paths(config))
+    check_manifest_pay_to(config)
+    messages.extend(check_discovery_metadata(config))
+    messages.append(check_mcp_payment_gate(config))
+    return messages

alloccontext/x402_smoke_redact.py

@@ -0,0 +1,41 @@
+"""Redact EVM addresses from paid smoke logs (CI-safe output)."""
+
+from __future__ import annotations
+
+import os
+import re
+
+_EVM_ADDRESS = re.compile(r"0x[a-fA-F0-9]{40}")
+
+
+def smoke_log_addresses_enabled() -> bool:
+    """When true, print full 0x addresses (local debugging only)."""
+    return os.environ.get("SMOKE_LOG_ADDRESSES", "").strip().lower() in (
+        "1",
+        "true",
+        "yes",
+    )
+
+
+def mask_evm_address(address: str) -> str:
+    """Return a shortened address safe for CI logs."""
+    value = address.strip()
+    if not value.startswith("0x") or len(value) < 10:
+        return value
+    return f"{value[:6]}…{value[-4:]}"
+
+
+def redact_evm_addresses(text: str) -> str:
+    """Replace EVM addresses in free-form text unless logging is enabled."""
+    if smoke_log_addresses_enabled():
+        return text
+
+    def _replace(match: re.Match[str]) -> str:
+        return mask_evm_address(match.group(0))
+
+    return _EVM_ADDRESS.sub(_replace, text)
+
+
+def smoke_log(message: str) -> None:
+    """Print a line with addresses redacted unless SMOKE_LOG_ADDRESSES is set."""
+    print(redact_evm_addresses(message))