primecli 0.5.3__tar.gz → 0.5.5__tar.gz

{primecli-0.5.3 → primecli-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.5.3
+Version: 0.5.5
 Summary: Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required.
 Author: Mnemosyne-quest contributors
 License: MIT

primecli-0.5.5/primecli/__init__.py

@@ -0,0 +1,59 @@
+"""primecli - command-line tools for DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base)."""
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+import json
+import os
+import sys
+import urllib.request
+
+try:
+    __version__ = _pkg_version("primecli")
+except PackageNotFoundError:  # running from source without an install
+    __version__ = "0.0.0+unknown"
+
+_VERSION_CHECK_URL = "https://pypi.org/pypi/primecli/json"
+_VERSION_TIMEOUT = 3  # seconds
+
+
+def _parse_version(v: str) -> tuple:
+    """Parse 'X.Y.Z' into a sortable tuple. Non-numeric suffixes become -inf."""
+    parts = v.split(".")
+    nums = []
+    for p in parts:
+        try:
+            nums.append(int(p))
+        except ValueError:
+            nums.append(-1)
+    # Pad to 3 elements
+    while len(nums) < 3:
+        nums.append(0)
+    return tuple(nums[:3])
+
+
+def check_version(suppress_flag: bool = False) -> None:
+    """Print a one-line upgrade hint to stderr when the installed version is behind
+    the latest on PyPI. Suppress with the env var PRIMECLI_NO_VERSION_CHECK=1,
+    the CLI flag --no-version-check, or pass suppress_flag=True."""
+    if suppress_flag or os.environ.get("PRIMECLI_NO_VERSION_CHECK") == "1":
+        return
+    if "--no-version-check" in sys.argv:
+        return
+    if __version__ in ("0.0.0+unknown",):
+        return
+    try:
+        req = urllib.request.Request(_VERSION_CHECK_URL)
+        with urllib.request.urlopen(req, timeout=_VERSION_TIMEOUT) as resp:
+            data = json.loads(resp.read().decode())
+        latest = data.get("info", {}).get("version", "")
+        if not latest:
+            return
+        installed = _parse_version(__version__)
+        latest_v = _parse_version(latest)
+        if installed < latest_v:
+            print(
+                f"⚠️  primecli {__version__} is outdated. Latest is {latest}. "
+                f"Upgrade: pip install --upgrade primecli",
+                file=sys.stderr,
+            )
+    except Exception:
+        pass  # network failure or parse error → silent

{primecli-0.5.3 → primecli-0.5.5}/primecli/arbprime.py

@@ -59,7 +59,7 @@ back to balances-only if the gateway is unreachable).
 
 NOTE: prime-summary shows TWO health metrics — don't confuse them:
   - "Health ratio (chain)":  on-chain getHealthRatio. 1.0 = liquidation, >1.0 = solvent.
-  - "Health (Bruno 0-100%)": equity-based, frontend-style. 0% = liquidation, 50% = half
+  - "Health (0-100%)": equity-based, frontend-style. 0% = liquidation, 50% = half
     borrowing power used, 100% = no debt.
   Formula for the latter: equity=supplied-debt, max_debt=equity*(tier-1),
   pct=(max_debt-debt)/max_debt*100. tier=5 (BASIC) or 10 (PREMIUM).
@@ -228,13 +228,19 @@ if _hm is None:
         _spec.loader.exec_module(_hm)
 health_monitor = _hm
 
+# Version check (silent on network failure or old install)
+try:
+    from primecli import check_version
+except ImportError:
+    def check_version(*a, **kw): pass
+
 # Arbitrum One RPC. Override with ARBPRIME_RPC for a paid Alchemy/Infura endpoint.
 ARBITRUM_RPC = os.environ.get("ARBPRIME_RPC", "https://arb1.arbitrum.io/rpc")
 EXPLORER = "https://arbiscan.io"  # display/links only — never used for ABI fetch
 CHAIN_ID = 42161
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 # ── Agent / wallet selection ─────────────────────────────────────────────────
-# Agent-agnostic: any agent (Parakletos, Paraklaudios, or another of Bruno's) runs
+# Agent-agnostic: any agent (Parakletos, Paraklaudios, or another authorized agent) runs
 # this same tool with its OWN wallet. The Prime Account is derived on-chain from the
 # wallet owner (getLoanForOwner), so each agent automatically operates on its own
 # Prime Account — no per-agent addresses are hardcoded. The same EVM key works on
@@ -317,8 +323,8 @@ REDSTONE_GATEWAYS = [
 ]
 
 # Active pool proxies — LIVE Arbitrum deployment, on-chain verified 2026-06-03.
-# getAllPoolAssets live = [USDC, DAI, BTC, ARB, ETH]; the DAI pool is DROPPED per
-# Bruno, leaving 4. The native-wrapped pool is `eth` (underlying WETH, account symbol
+# getAllPoolAssets live = [USDC, DAI, BTC, ARB, ETH]; the DAI pool is DROPPED,
+# leaving 4. The native-wrapped pool is `eth` (underlying WETH, account symbol
 # "ETH"): its native deposit path uses depositNativeToken() (wraps ETH -> WETH).
 POOLS = {
     "eth": {
@@ -1968,23 +1974,23 @@ def gather_lending(w3, account):
             r["usd"] = None
     return out
 
-def _compute_bruno_health(data: dict, tier_code: int = 0) -> dict:
-    """Compute Bruno's 0-100% health from gather_lending data + tier.
+def _compute_health_pct(data: dict, tier_code: int = 0) -> dict:
+    """Compute equity-based health (0-100%) from gather_lending data + tier.
 
     DeltaPrime has *two* health metrics that agents must not confuse:
 
       1. health_ratio (on-chain, getHealthRatio): 1.0 = liquidation, >1.0 = solvent.
          This is the raw weighted-collateral / debt ratio from the SolvencyFacet.
 
-      2. bruno_pct (equity-based, 0-100%): the scale used in the DeltaPrime frontend
+      2. health_pct (equity-based, 0-100%): the scale used in the DeltaPrime frontend
          and the account-health-monitor cron. 0% = liquidation, 100% = no debt.
          Formula:
            equity    = supplied_usd - debt_usd
            max_mult  = 10 if PREMIUM tier else 5 if BASIC
            max_debt  = equity * (max_mult - 1)
-           bruno_pct = (max_debt - debt_usd) / max_debt * 100
+           health_pct = (max_debt - debt_usd) / max_debt * 100
 
-    Returns dict with keys: bruno_pct, supplied_usd, debt_usd, equity, max_debt,
+    Returns dict with keys: health_pct, supplied_usd, debt_usd, equity, max_debt,
     tier_label, or error.
     """
     supplied_usd = sum(r.get("usd", 0) or 0 for r in data.get("supplied", []))
@@ -1995,18 +2001,18 @@ def _compute_bruno_health(data: dict, tier_code: int = 0) -> dict:
     max_mult = {0: 5, 1: 10}.get(tier_code, 5)
 
     if equity <= 0.01:
-        return {"bruno_pct": 0.0, "supplied_usd": round(supplied_usd, 2),
+        return {"health_pct": 0.0, "supplied_usd": round(supplied_usd, 2),
                 "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
                 "max_debt": 0.0, "tier": tier_label, "error": "equity near zero"}
 
     max_debt = equity * (max_mult - 1)
     if max_debt > 0 and debt_usd >= 0:
-        bruno_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
-        bruno_pct = max(0.0, min(100.0, bruno_pct))
+        health_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
+        health_pct = max(0.0, min(100.0, health_pct))
     else:
-        bruno_pct = 100.0
+        health_pct = 100.0
 
-    return {"bruno_pct": round(bruno_pct, 1), "supplied_usd": round(supplied_usd, 2),
+    return {"health_pct": round(health_pct, 1), "supplied_usd": round(supplied_usd, 2),
             "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
             "max_debt": round(max_debt, 2), "tier": tier_label}
 
@@ -2055,22 +2061,22 @@ def cmd_prime_summary():
         # astronomically large there); render that as ">1000" rather than a junk number.
         ratio_str = ">1000.00 (negligible debt)" if ratio is None else f"{ratio:.4f}"
         print(f"  Health ratio (chain): {ratio_str}  (>1.0 = solvent, 1.0 = liquidation)")
-        # ─── Bruno's 0-100% health (equity-based, uses tier multiplier) ───
-        # Different from health_ratio! See _compute_bruno_health docstring.
+        # ─── Equity-based health (0-100%) ───
+        # Different from health_ratio! See _compute_health_pct docstring.
         # Get tier from the Prime Account (oracle-free view)
         try:
             tier_info = gather_prime_tier(w3, acct, account)
             tier_code = tier_info.get("tier_code", 0)
         except Exception:
             tier_code = 0
-        bh = _compute_bruno_health(data, tier_code)
-        if "error" not in bh:
-            print(f"  Health (Bruno 0-100%): {bh['bruno_pct']:.1f}%")
-            print(f"    (supplied=${bh['supplied_usd']:.2f}, debt=${bh['debt_usd']:.2f},"
-                  f" equity=${bh['equity']:.2f}, max_debt=${bh['max_debt']:.2f}, {bh['tier']})")
+        hp = _compute_health_pct(data, tier_code)
+        if "error" not in hp:
+            print(f"  Health (0-100%): {hp['health_pct']:.1f}%")
+            print(f"    (supplied=${hp['supplied_usd']:.2f}, debt=${hp['debt_usd']:.2f},"
+                  f" equity=${hp['equity']:.2f}, max_debt=${hp['max_debt']:.2f}, {hp['tier']})")
             print(f"    0%=liquidation  50%=half borrowing power used  100%=no debt")
         else:
-            print(f"  Health (Bruno 0-100%): N/A ({bh['error']})")
+            print(f"  Health (0-100%): N/A ({hp['error']})")
         print(f"  Solvent:            {'yes' if data['solvent'] else 'NO — liquidatable'}")
     else:
         print(f"  Health/solvency:    RedStone fetch/call failed ({data.get('solvency_error', 'error')}); "
@@ -5071,12 +5077,12 @@ def gather_defi() -> dict:
         result["total_usd"] = lending["total_value_usd"]
         result["health_ratio"] = lending["health_ratio"]
         result["solvent"] = lending["solvent"]
-        # Compute Bruno's 0-100% health from lending data + tier
-        result["bruno_pct"] = _compute_bruno_health(lending, tier.get("tier_code", 0)).get("bruno_pct")
+        # Compute equity-based health (0-100%) from lending data + tier
+        result["health_pct"] = _compute_health_pct(lending, tier.get("tier_code", 0)).get("health_pct")
         if lending["supplied"] or lending["borrowed"]:
             result["groups"].append({
                 "type": "Lending / Leverage", "health_ratio": lending["health_ratio"],
-                "bruno_pct": result["bruno_pct"],
+                "health_pct": result["health_pct"],
                 "supplied": [{"symbol": r["symbol"], "balance": r["balance"], "usd": r.get("usd")}
                              for r in lending["supplied"]],
                 "borrowed": [{"symbol": r["symbol"], "balance": r["balance"], "usd": r.get("usd")}
@@ -5360,6 +5366,7 @@ def cmd_prime_bridge(from_chain: str = "avax", amount: float = None, execute: bo
     print(f"  Tx: {src_cfg['explorer']}/{tx_hash.hex()}")
 
 def main():
+    check_version()
     args = sys.argv[1:] if len(sys.argv) > 1 else []
     # Global wallet selector: --as <agent>, stripped before command dispatch.
     global _SELECTED_AGENT, _CLI_KEY

{primecli-0.5.3 → primecli-0.5.5}/primecli/degenprime.py

@@ -104,6 +104,12 @@ if _hm is None:
         _spec.loader.exec_module(_hm)
 health_monitor = _hm
 
+# Version check (silent on network failure or old install)
+try:
+    from primecli import check_version
+except ImportError:
+    def check_version(*a, **kw): pass
+
 # Default Base RPC. mainnet.base.org rate-limits hard (429 within a few calls); the
 # publicnode endpoint is fronted by a load balancer with much higher anonymous limits
 # and has been the most reliable free option for this tool's traffic pattern (lots of
@@ -112,6 +118,7 @@ health_monitor = _hm
 BASE_RPC = os.environ.get("DEGENPRIME_RPC", "https://base.publicnode.com")
 EXPLORER = "https://basescan.org"
 CHAIN_ID = 8453
+DEGEN_MAX_MULT = 5  # Fixed max leverage multiplier (no tier system on DegenPrime)
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 
 # ── Signing key resolution ──────────────────────────────────────────────────
@@ -570,6 +577,41 @@ def _asset_meta(w3, symbol: str):
 # gateway once instead of per-feed-symbol. Cleared implicitly when the process exits.
 _redstone_gateway_cache = None
 
+def _compute_health_pct(supplied: list, borrowed: list, max_mult: int = None) -> dict:
+    """Compute equity-based health (0-100%) from per-asset supplied/borrowed data.
+
+    0% = liquidation, 50% = half borrowing power used, 100% = no debt.
+    Formula:
+      equity    = supplied_usd - debt_usd
+      max_mult  = 5 (fixed for DegenPrime; no tier system)
+      max_debt  = equity * (max_mult - 1)
+      health_pct = (max_debt - debt_usd) / max_debt * 100
+
+    Returns dict with keys: health_pct, supplied_usd, debt_usd, equity, max_debt, or error.
+    """
+    if max_mult is None:
+        max_mult = DEGEN_MAX_MULT
+    supplied_usd = sum(r.get("usd", 0) or 0 for r in supplied)
+    debt_usd = sum(r.get("usd", 0) or 0 for r in borrowed)
+    equity = supplied_usd - debt_usd
+
+    if equity <= 0.01:
+        return {"health_pct": 0.0, "supplied_usd": round(supplied_usd, 2),
+                "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
+                "max_debt": 0.0, "error": "equity near zero"}
+
+    max_debt = equity * (max_mult - 1)
+    if max_debt > 0 and debt_usd >= 0:
+        health_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
+        health_pct = max(0.0, min(100.0, health_pct))
+    else:
+        health_pct = 100.0
+
+    return {"health_pct": round(health_pct, 1), "supplied_usd": round(supplied_usd, 2),
+            "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
+            "max_debt": round(max_debt, 2), "tier": "FIXED_5X"}
+
+
 def _redstone_fetch_packages(use_cache: bool = True) -> dict:
     """Fetch the latest signed price packages from the RedStone gateway. Returns the
     per-feed map: {feedSymbol: [package, ...]} with one package per signer. The per-run
@@ -1458,11 +1500,19 @@ def gather_defi() -> dict:
                 row["usd"] = round(amt * usd, 2)
             return row
 
+        _rows_supplied = [_row(r) for r in supplied]
+        _rows_borrowed = [_row(r) for r in borrowed]
+
+        # Compute equity-based health (0-100%)
+        _hp = _compute_health_pct(_rows_supplied, _rows_borrowed)
+        result["health_pct"] = _hp.get("health_pct")
+
         if supplied or borrowed:
             result["groups"].append({
                 "type": "Lending / Leverage", "health_ratio": solvency["ratio"],
-                "supplied": [_row(r) for r in supplied],
-                "borrowed": [_row(r) for r in borrowed],
+                "health_pct": result["health_pct"],
+                "supplied": _rows_supplied,
+                "borrowed": _rows_borrowed,
             })
 
     # Savings: the EOA's own pool deposits ("Diamond Hands"), independent of the Degen
@@ -1578,16 +1628,22 @@ def cmd_summary(as_json: bool = False):
                 row["usd"] = round(row["amount"] * usd, 2)
             return row
 
+        # Compute equity-based health (0-100%)
+        _hp_rows = [_asset_row(r) for r in supplied]
+        _hp_borrowed = [_asset_row(r) for r in borrowed]
+        _hp = _compute_health_pct(_hp_rows, _hp_borrowed)
+
         out = {
             "wallet": acct.address,
             "account": pa,
             "nativeBalance": pa_eth if pa_eth >= 1e-9 else None,
-            "supplied": [_asset_row(r) for r in supplied],
-            "borrowed": [_asset_row(r) for r in borrowed],
+            "supplied": _hp_rows,
+            "borrowed": _hp_borrowed,
             "poolDeposits": [_asset_row(r) for r in pool_deposits],
             "totalValueUsd": solvency["total"],
             "debtUsd": solvency["debt"],
             "healthRatio": solvency["ratio"],
+            "healthPct": _hp.get("health_pct"),
             "solvent": solvency["solvent"],
             "solvencyError": solvency["error"],
         }
@@ -1626,7 +1682,22 @@ def cmd_summary(as_json: bool = False):
         print(f"  Total value:        ${solvency['total']:,.2f}")
         print(f"  Debt:               ${solvency['debt']:,.2f}")
         ratio_str = ">1000.00 (negligible debt)" if solvency["ratio"] is None else f"{solvency['ratio']:.4f}"
-        print(f"  Health ratio:       {ratio_str}  (>1.0 = solvent)")
+        print(f"  Health ratio (chain): {ratio_str}  (>1.0 = solvent, 1.0 = liquidation)")
+        # ─── Equity-based health (0-100%) ───
+        # Different from health_ratio!
+        hp = _compute_health_pct(
+            [{"symbol": r["symbol"], "balance": "0", "usd": (r["raw"] / 10**r["decimals"]) * solvency["prices"].get(r["symbol"], 0)}
+             for r in supplied if solvency["prices"].get(r["symbol"])],
+            [{"symbol": r["symbol"], "balance": "0", "usd": (r["raw"] / 10**r["decimals"]) * solvency["prices"].get(r["symbol"], 0)}
+             for r in borrowed if solvency["prices"].get(r["symbol"])],
+        )
+        if "error" not in hp:
+            print(f"  Health (0-100%): {hp['health_pct']:.1f}%")
+            print(f"    (supplied=${hp['supplied_usd']:.2f}, debt=${hp['debt_usd']:.2f},"
+                  f" equity=${hp['equity']:.2f}, max_debt=${hp['max_debt']:.2f}, {hp.get('tier','')})")
+            print(f"    0%=liquidation  50%=half borrowing power used  100%=no debt")
+        else:
+            print(f"  Health (0-100%): N/A ({hp['error']})")
         print(f"  Solvent:            {'yes' if solvency['solvent'] else 'NO - liquidatable'}")
     else:
         print(f"  Health/solvency:    RedStone fetch/call failed ({solvency['error']}); showing balances only")
@@ -2360,6 +2431,7 @@ def cmd_aerodrome_positions():
     print("  v1 lists tokenIds only. Composition + write paths deferred to v2.")
 
 def main():
+    check_version()
     try:
         _dispatch()
     except RuntimeError as e:

{primecli-0.5.3 → primecli-0.5.5}/primecli/deltaprime.py

@@ -52,7 +52,7 @@ back to balances-only if the gateway is unreachable).
 
 NOTE: prime-summary shows TWO health metrics — don't confuse them:
   - "Health ratio (chain)":  on-chain getHealthRatio. 1.0 = liquidation, >1.0 = solvent.
-  - "Health (Bruno 0-100%)": equity-based, frontend-style. 0% = liquidation, 50% = half
+  - "Health (0-100%)": equity-based, frontend-style. 0% = liquidation, 50% = half
     borrowing power used, 100% = no debt.
   Formula for the latter: equity=supplied-debt, max_debt=equity*(tier-1),
   pct=(max_debt-debt)/max_debt*100. tier=5 (BASIC) or 10 (PREMIUM).
@@ -237,12 +237,18 @@ if _hm is None:
         _spec.loader.exec_module(_hm)
 health_monitor = _hm
 
+# Version check (silent on network failure or old install)
+try:
+    from primecli import check_version
+except ImportError:
+    def check_version(*a, **kw): pass
+
 AVALANCHE_RPC = os.environ.get("DELTAPRIME_RPC", "https://api.avax.network/ext/bc/C/rpc")
 EXPLORER = "https://snowtrace.io"
 CHAIN_ID = 43114
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 # ── Agent / wallet selection ─────────────────────────────────────────────────
-# Agent-agnostic: any agent (Parakletos, Paraklaudios, or another of Bruno's) runs
+# Agent-agnostic: any agent (Parakletos, Paraklaudios, or another authorized agent) runs
 # this same tool with its OWN wallet. The Prime Account is derived on-chain from the
 # wallet owner (getLoanForOwner), so each agent automatically operates on its own
 # Prime Account — no per-agent addresses are hardcoded.
@@ -441,12 +447,12 @@ TJ_ROUTER_V21 = "0xb4315e873dBcf96Ffd0acd8EA43f689D8c20fB30"
 TJ_ROUTER_V22 = "0x18556DA13313f3532c54711497A8FedAC273220E"
 TJ_MAX_BINS = 80
 
-# Whitelisted LB pairs exposed as tool keys, matching Bruno's live frontend (bin step in
+# Whitelisted LB pairs exposed as tool keys, matching the live frontend (bin step in
 # the key suffix where a pair exists at two steps). For each: the LBPair address, the
 # router version the pair belongs to, the canonical (tokenX, tokenY) order read on-chain,
 # and the binStep. tokenX/tokenY carry the ERC20 address, the account bytes32 symbol (for
 # the in-account balance read + RedStone feed), and decimals. The 13 source-whitelisted
-# pairs include 4 aUSD pairs not on Bruno's frontend; those are omitted (no clean
+# pairs include 4 aUSD pairs not on the live frontend; those are omitted (no clean
 # symbol/decimals + out of scope).
 _WAVAX = {"addr": "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7", "symbol": "AVAX", "decimals": 18}
 _USDC = {"addr": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E", "symbol": "USDC", "decimals": 6}
@@ -1995,23 +2001,23 @@ def gather_lending(w3, account):
             r["usd"] = None
     return out
 
-def _compute_bruno_health(data: dict, tier_code: int = 0) -> dict:
-    """Compute Bruno's 0-100% health from gather_lending data + tier.
+def _compute_health_pct(data: dict, tier_code: int = 0) -> dict:
+    """Compute equity-based health (0-100%) from gather_lending data + tier.
 
     DeltaPrime has *two* health metrics that agents must not confuse:
 
       1. health_ratio (on-chain, getHealthRatio): 1.0 = liquidation, >1.0 = solvent.
          This is the raw weighted-collateral / debt ratio from the SolvencyFacet.
 
-      2. bruno_pct (equity-based, 0-100%): the scale used in the DeltaPrime frontend
+      2. health_pct (equity-based, 0-100%): the scale used in the DeltaPrime frontend
          and the account-health-monitor cron. 0% = liquidation, 100% = no debt.
          Formula:
            equity    = supplied_usd - debt_usd
            max_mult  = 10 if PREMIUM tier else 5 if BASIC
            max_debt  = equity * (max_mult - 1)
-           bruno_pct = (max_debt - debt_usd) / max_debt * 100
+           health_pct = (max_debt - debt_usd) / max_debt * 100
 
-    Returns dict with keys: bruno_pct, supplied_usd, debt_usd, equity, max_debt,
+    Returns dict with keys: health_pct, supplied_usd, debt_usd, equity, max_debt,
     tier_label, or error.
     """
     supplied_usd = sum(r.get("usd", 0) or 0 for r in data.get("supplied", []))
@@ -2022,18 +2028,18 @@ def _compute_bruno_health(data: dict, tier_code: int = 0) -> dict:
     max_mult = {0: 5, 1: 10}.get(tier_code, 5)
 
     if equity <= 0.01:
-        return {"bruno_pct": 0.0, "supplied_usd": round(supplied_usd, 2),
+        return {"health_pct": 0.0, "supplied_usd": round(supplied_usd, 2),
                 "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
                 "max_debt": 0.0, "tier": tier_label, "error": "equity near zero"}
 
     max_debt = equity * (max_mult - 1)
     if max_debt > 0 and debt_usd >= 0:
-        bruno_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
-        bruno_pct = max(0.0, min(100.0, bruno_pct))
+        health_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
+        health_pct = max(0.0, min(100.0, health_pct))
     else:
-        bruno_pct = 100.0
+        health_pct = 100.0
 
-    return {"bruno_pct": round(bruno_pct, 1), "supplied_usd": round(supplied_usd, 2),
+    return {"health_pct": round(health_pct, 1), "supplied_usd": round(supplied_usd, 2),
             "debt_usd": round(debt_usd, 2), "equity": round(equity, 2),
             "max_debt": round(max_debt, 2), "tier": tier_label}
 
@@ -2082,22 +2088,22 @@ def cmd_prime_summary():
         # astronomically large there); render that as ">1000" rather than a junk number.
         ratio_str = ">1000.00 (negligible debt)" if ratio is None else f"{ratio:.4f}"
         print(f"  Health ratio (chain): {ratio_str}  (>1.0 = solvent, 1.0 = liquidation)")
-        # ─── Bruno's 0-100% health (equity-based, uses tier multiplier) ───
-        # Different from health_ratio! See _compute_bruno_health docstring.
+        # ─── Equity-based health (0-100%) ───
+        # Different from health_ratio! See _compute_health_pct docstring.
         # Get tier from the Prime Account (oracle-free view)
         try:
             tier_info = gather_prime_tier(w3, acct, account)
             tier_code = tier_info.get("tier_code", 0)
         except Exception:
             tier_code = 0
-        bh = _compute_bruno_health(data, tier_code)
-        if "error" not in bh:
-            print(f"  Health (Bruno 0-100%): {bh['bruno_pct']:.1f}%")
-            print(f"    (supplied=${bh['supplied_usd']:.2f}, debt=${bh['debt_usd']:.2f},"
-                  f" equity=${bh['equity']:.2f}, max_debt=${bh['max_debt']:.2f}, {bh['tier']})")
+        hp = _compute_health_pct(data, tier_code)
+        if "error" not in hp:
+            print(f"  Health (0-100%): {hp['health_pct']:.1f}%")
+            print(f"    (supplied=${hp['supplied_usd']:.2f}, debt=${hp['debt_usd']:.2f},"
+                  f" equity=${hp['equity']:.2f}, max_debt=${hp['max_debt']:.2f}, {hp['tier']})")
             print(f"    0%=liquidation  50%=half borrowing power used  100%=no debt")
         else:
-            print(f"  Health (Bruno 0-100%): N/A ({bh['error']})")
+            print(f"  Health (0-100%): N/A ({hp['error']})")
         print(f"  Solvent:            {'yes' if data['solvent'] else 'NO — liquidatable'}")
     else:
         print(f"  Health/solvency:    RedStone fetch/call failed ({data.get('solvency_error', 'error')}); "
@@ -5003,12 +5009,12 @@ def gather_defi() -> dict:
         result["total_usd"] = lending["total_value_usd"]
         result["health_ratio"] = lending["health_ratio"]
         result["solvent"] = lending["solvent"]
-        # Compute Bruno's 0-100% health from lending data + tier
-        result["bruno_pct"] = _compute_bruno_health(lending, tier.get("tier_code", 0)).get("bruno_pct")
+        # Compute equity-based health (0-100%) from lending data + tier
+        result["health_pct"] = _compute_health_pct(lending, tier.get("tier_code", 0)).get("health_pct")
         if lending["supplied"] or lending["borrowed"]:
             result["groups"].append({
                 "type": "Lending / Leverage", "health_ratio": lending["health_ratio"],
-                "bruno_pct": result["bruno_pct"],
+                "health_pct": result["health_pct"],
                 "supplied": [{"symbol": r["symbol"], "balance": r["balance"], "usd": r.get("usd")}
                              for r in lending["supplied"]],
                 "borrowed": [{"symbol": r["symbol"], "balance": r["balance"], "usd": r.get("usd")}
@@ -5145,6 +5151,7 @@ def cmd_defi(as_json: bool = True):
     print(json.dumps(_trim_defi_json(data), indent=2))
 
 def main():
+    check_version()
     args = sys.argv[1:] if len(sys.argv) > 1 else []
     # Global wallet selector: --as <agent>, stripped before command dispatch.
     global _SELECTED_AGENT, _CLI_KEY

{primecli-0.5.3 → primecli-0.5.5}/primecli/health_monitor.py

@@ -37,10 +37,10 @@ TIER_MAX = {"basic": 5, "premium": 10}
 # ════════════════════════════════════════════════════════════════════
 
 def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
-    """Compute Bruno's 0-100% health scale from defi --json data.
+    """Compute equity-based health (0-100%) from defi --json data.
 
-    PREFERS the precomputed ``bruno_pct`` from defi --json (which primecli now
-    includes as of 2026-06-04), falling back to manual calculation when absent.
+    PREFERS the precomputed ``health_pct`` from defi --json (which primecli >= 0.5.4
+    includes), falling back to manual calculation when absent.
 
     Formula:
       equity = total_supplied_usd - total_debt_usd
@@ -49,7 +49,7 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
 
     This is DIFFERENT from getHealthRatio (the on-chain ratio where 1.0 = liquidation).
     Do NOT convert between the two. The ``health_ratio`` metric is the on-chain value
-    (1.0=liquidation, >1.0=solvent). The ``bruno_pct`` is the equity-based frontend
+    (1.0=liquidation, >1.0=solvent). The ``health_pct`` is the equity-based frontend
     measurement (0%=liquidation, 50%=half borrowing power used, 100%=no debt).
 
     Returns dict with health metrics or error.
@@ -61,8 +61,8 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
         supplied = g.get("supplied", [])
         borrowed = g.get("borrowed", [])
         health_ratio = g.get("health_ratio", 0) or 0
-        # Use precomputed bruno_pct from defi --json if available (primecli >= 0.5.0)
-        precomputed = g.get("bruno_pct")
+        # Use precomputed health_pct from defi --json if available (primecli >= 0.5.4)
+        precomputed = g.get("health_pct") or g.get("bruno_pct")  # bruno_pct for backward compat
         if precomputed is not None:
             # Early return: precomputed value exists, enrich with detail fields
             supplied_usd = sum(s.get("usd", 0) or 0 for s in supplied)
@@ -74,7 +74,7 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
             has_lb = any(sym in ("LB_AVAX_USDC", "LB_WAVAX_USDC", "JOE") or "TRADERJOE" in sym.upper() for sym in symbols)
             has_aero = any("AERO" in sym.upper() or "CL_POSITION" in sym.upper() for sym in symbols)
             return {
-                "bruno_pct": float(precomputed),
+                "health_pct": float(precomputed),
                 "health_ratio": round(health_ratio, 4),
                 "supplied_usd": round(supplied_usd, 2),
                 "debt_usd": round(debt_usd, 2),
@@ -84,7 +84,7 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
                 "has_gmx": has_gmx,
                 "has_lb": has_lb,
                 "has_aero": has_aero,
-                "action": "computed from defi --json bruno_pct",
+                "action": "computed from defi --json health_pct",
             }
     else:
         supplied = defi_data.get("supplied", [])
@@ -97,7 +97,7 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
 
     if equity <= 0.01:
         return {
-            "bruno_pct": 0.0,
+            "health_pct": 0.0,
             "health_ratio": round(health_ratio, 4),
             "supplied_usd": round(supplied_usd, 2),
             "debt_usd": round(debt_usd, 2),
@@ -121,15 +121,15 @@ def compute_health(defi_data: dict, max_mult: int = 10) -> dict:
     has_aero = any("AERO" in sym.upper() or "CL_POSITION" in sym.upper() for sym in symbols)
 
     if max_debt > 0 and debt_usd >= 0:
-        bruno_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
-        bruno_pct = max(0.0, min(100.0, bruno_pct))
+        health_pct = (max_debt - min(debt_usd, max_debt)) / max_debt * 100
+        health_pct = max(0.0, min(100.0, health_pct))
     else:
-        bruno_pct = 100.0
+        health_pct = 100.0
 
     delta_debt = (max_debt * 0.5) - debt_usd  # center target = 50%
 
     return {
-        "bruno_pct": round(bruno_pct, 1),
+        "health_pct": round(health_pct, 1),
         "health_ratio": round(health_ratio, 4),
         "supplied_usd": round(supplied_usd, 2),
         "debt_usd": round(debt_usd, 2),
@@ -320,7 +320,7 @@ def run_tick(
             "reason": "equity_near_zero",
             "equity": health["equity"],
             "debt": health["debt_usd"],
-            "health_pct": health["bruno_pct"],
+            "health_pct": health["health_pct"],
             "label": label,
         })
         result.update(health)
@@ -336,23 +336,23 @@ def run_tick(
 
     # 5. Health swing detection (always)
     last_pct = load_last_health(state_dir)
-    if last_pct is not None and health["bruno_pct"] is not None:
-        diff = abs(health["bruno_pct"] - last_pct)
+    if last_pct is not None and health["health_pct"] is not None:
+        diff = abs(health["health_pct"] - last_pct)
         if diff > 10:
             write_escalation(state_dir, "health-swing", {
                 "reason": "health_swing",
                 "from_pct": last_pct,
-                "to_pct": health["bruno_pct"],
+                "to_pct": health["health_pct"],
                 "delta": diff,
                 "label": label,
             })
             result["escalation"] = "health_swing"
-    save_last_health(state_dir, health["bruno_pct"] or 0.0)
+    save_last_health(state_dir, health["health_pct"] or 0.0)
 
     # 6. Append to history
     entry = {
         "ts": now_iso, "mode": mode,
-        "pct": health["bruno_pct"],
+        "pct": health["health_pct"],
         "equity": health["equity"],
         "debt": health["debt_usd"],
         "hr": health["health_ratio"],
@@ -369,7 +369,7 @@ def run_tick(
             write_escalation(state_dir, "incomplete-valuation", {
                 "reason": "incomplete_valuation",
                 "detail": val_reason,
-                "health_pct": health["bruno_pct"],
+                "health_pct": health["health_pct"],
                 "equity": health["equity"],
                 "debt": health["debt_usd"],
                 "label": label,
@@ -387,7 +387,7 @@ def run_tick(
         side = strategy.get("side", "short")
         low, high = target_range[0], target_range[1]
 
-        pct = health["bruno_pct"]
+        pct = health["health_pct"]
         equity = health["equity"]
         debt = health["debt_usd"]
         raw_usdc = health["raw_usdc"]

{primecli-0.5.3 → primecli-0.5.5}/primecli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.5.3
+Version: 0.5.5
 Summary: Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required.
 Author: Mnemosyne-quest contributors
 License: MIT

{primecli-0.5.3 → primecli-0.5.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "primecli"
-version = "0.5.3"
+version = "0.5.5"
 description = "Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required."
 readme = "README.md"
 requires-python = ">=3.10"

primecli-0.5.3/primecli/__init__.py

@@ -1,8 +0,0 @@
-"""primecli - command-line tools for DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base)."""
-
-from importlib.metadata import PackageNotFoundError, version as _pkg_version
-
-try:
-    __version__ = _pkg_version("primecli")
-except PackageNotFoundError:  # running from source without an install
-    __version__ = "0.0.0+unknown"