sibyl-memory-cli 0.1.4__tar.gz → 0.3.2__tar.gz

{sibyl_memory_cli-0.1.4 → sibyl_memory_cli-0.3.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: sibyl-memory-cli
-Version: 0.1.4
-Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats.
+Version: 0.3.2
+Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats, `sibyl whoami` gives a one-line account summary, `sibyl devices` lists active devices and supports per-device revoke.
 Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
 License: MIT
 Project-URL: Homepage, https://sibyllabs.org/plugin

{sibyl_memory_cli-0.1.4 → sibyl_memory_cli-0.3.2}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sibyl-memory-cli"
-version = "0.1.4"
-description = "Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats."
+version = "0.3.2"
+description = "Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats, `sibyl whoami` gives a one-line account summary, `sibyl devices` lists active devices and supports per-device revoke."
 authors = [{ name = "SIBYL, Sibyl Labs LLC", email = "sibyl@sibyllabs.org" }]
 license = { text = "MIT" }
 readme = "README.md"

sibyl_memory_cli-0.3.2/src/sibyl_memory_cli/_aesthetic.py

@@ -0,0 +1,279 @@
+"""Shared visual identity for the sibyl CLI surface.
+
+Sister module to `_banner.py`. Where the banner is the identity-reveal
+moment for `sibyl init`, this module supplies the granular building
+blocks every subcommand uses to share one coherent look:
+
+  - 24-bit-truecolor → 256-color → plain-text degradation cascade
+  - Brand palette derived from the lab creme paper face (rule 46)
+  - Letter-spaced eyebrow labels, gradient titles, ASCII rule dividers
+  - Key/value rows, status chips, success/warn/error glyphs
+  - Pulsing accents for live states (activation, upgrade, watching)
+
+Voice constraint: precise, editorial, restrained. Gradients flow over
+2–3 stops max. No rainbow. The terminal is paper.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from typing import Iterable
+
+# ─── Palette (RGB · derived from rule 46 creme-paper tokens) ─────────
+# Names map 1:1 to CSS custom properties on lab artifacts.
+
+PAPER       = (245, 241, 230)   # --paper        — foreground accent on dark
+PAPER_DEEP  = (237, 230, 211)   # --paper-deep   — depth on creme
+CARD        = (253, 251, 245)   # --card         — slightly lifted creme
+INK         = (21,  17,  10)    # --ink          — main text on creme
+INK_SOFT    = (44,  39,  29)    # --ink-soft     — body text
+INK_MUTE    = (106, 99,  86)    # --ink-mute     — secondary text
+INK_FAINT   = (152, 145, 127)   # --ink-faint    — tertiary text
+RULE        = (216, 208, 187)   # --rule         — hairline
+RULE_STRONG = (184, 174, 147)   # --rule-strong  — emphasised hairline
+ACCENT      = (138, 106, 42)    # --accent       — ochre highlight
+ACCENT_WARM = (160, 132, 56)    # --accent-warm  — softer ochre
+ACCENT_GOLD = (224, 194, 119)   # mid gold       — gradient bridge
+ACCENT_PALE = (244, 229, 184)   # pale gold      — gradient top
+JADE        = (45,  110, 106)   # --jade         — cool counterpoint
+PULSE       = (29,  138, 130)   # --pulse        — brighter jade (live signal)
+ERROR       = (162, 58,  42)    # --error        — measured red
+
+# Status glyphs (Unicode, terminal-safe in modern fonts)
+GLYPH_OK    = "✓"
+GLYPH_WARN  = "⚠"
+GLYPH_ERR   = "✗"
+GLYPH_DOT   = "·"
+GLYPH_ARROW = "→"
+GLYPH_BULLET = "▸"
+
+
+# ─── Terminal capability detection ────────────────────────────────────
+
+def supports_truecolor() -> bool:
+    """24-bit RGB ANSI. Same heuristic as _banner.py."""
+    if os.environ.get("NO_COLOR"):
+        return False
+    if os.environ.get("TERM", "").lower() == "dumb":
+        return False
+    # SIBYL_FORCE_COLOR=1 — explicit override for non-tty rendering
+    # (CI logs, doc captures, dev inspection inside the Claude harness).
+    if os.environ.get("SIBYL_FORCE_COLOR") == "1":
+        return True
+    if not sys.stdout.isatty():
+        return False
+    colorterm = os.environ.get("COLORTERM", "").lower()
+    if "truecolor" in colorterm or "24bit" in colorterm:
+        return True
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+    if term_program in {"iterm.app", "wezterm", "ghostty", "vscode", "tabby"}:
+        return True
+    term = os.environ.get("TERM", "").lower()
+    if any(k in term for k in ("256color", "kitty", "alacritty", "xterm-direct")):
+        return True
+    return False
+
+
+def supports_color() -> bool:
+    """Any color at all (3/4-bit fallback)."""
+    if os.environ.get("NO_COLOR"):
+        return False
+    if os.environ.get("TERM", "").lower() == "dumb":
+        return False
+    if os.environ.get("SIBYL_FORCE_COLOR") == "1":
+        return True
+    return sys.stdout.isatty()
+
+
+_TC = supports_truecolor()
+_C  = supports_color()
+RESET = "\033[0m" if _C else ""
+
+
+def rgb(r: int, g: int, b: int) -> str:
+    """24-bit foreground escape (no-op if color disabled)."""
+    if not _TC:
+        return ""
+    return f"\033[38;2;{r};{g};{b}m"
+
+
+def rgb_bg(r: int, g: int, b: int) -> str:
+    if not _TC:
+        return ""
+    return f"\033[48;2;{r};{g};{b}m"
+
+
+def color(text: str, c: tuple[int, int, int]) -> str:
+    if not _TC:
+        return text
+    return f"{rgb(*c)}{text}{RESET}"
+
+
+# ─── Gradient · char-by-char RGB interpolation ────────────────────────
+
+def _interp(a: int, b: int, t: float) -> int:
+    return round(a + (b - a) * t)
+
+
+def gradient(text: str, *stops: tuple[int, int, int]) -> str:
+    """Color a string with a gradient across N stops, one char at a time.
+
+    Plain-text fallback: returns the input unchanged when color is off.
+    Whitespace is preserved (uncolored to keep terminals consistent).
+    """
+    if not _TC or len(stops) < 2 or not text:
+        return text
+    out = []
+    chars = list(text)
+    # Distribute char index across stop segments
+    n = max(1, len(chars) - 1)
+    segs = len(stops) - 1
+    for i, ch in enumerate(chars):
+        if ch == " ":
+            out.append(ch)
+            continue
+        seg_f = (i / n) * segs
+        seg_i = min(int(seg_f), segs - 1)
+        t = seg_f - seg_i
+        a = stops[seg_i]
+        b = stops[seg_i + 1]
+        r = _interp(a[0], b[0], t)
+        g = _interp(a[1], b[1], t)
+        bb = _interp(a[2], b[2], t)
+        out.append(f"\033[38;2;{r};{g};{bb}m{ch}")
+    return "".join(out) + RESET
+
+
+def gradient_gold(text: str) -> str:
+    """Pale-gold → deep-ochre flow. The brand's headline gradient."""
+    return gradient(text, ACCENT_PALE, ACCENT_GOLD, ACCENT)
+
+
+def gradient_jade(text: str) -> str:
+    """Pulse → jade. Used for success states + live indicators."""
+    return gradient(text, PULSE, JADE)
+
+
+# ─── Style primitives ─────────────────────────────────────────────────
+
+def dim(s: str) -> str:
+    return color(s, INK_FAINT)
+
+
+def muted(s: str) -> str:
+    return color(s, INK_MUTE)
+
+
+def soft(s: str) -> str:
+    return color(s, INK_SOFT)
+
+
+def ink(s: str) -> str:
+    return color(s, INK)
+
+
+def ok(s: str) -> str:
+    return color(s, PULSE)
+
+
+def warn(s: str) -> str:
+    return color(s, ACCENT_WARM)
+
+
+def err(s: str) -> str:
+    return color(s, ERROR)
+
+
+def accent(s: str) -> str:
+    return color(s, ACCENT)
+
+
+def bold(s: str) -> str:
+    if not _C:
+        return s
+    return f"\033[1m{s}{RESET}"
+
+
+# ─── Composite primitives ─────────────────────────────────────────────
+
+def eyebrow(label: str) -> str:
+    """Uppercase letter-spaced ochre label. Editorial section marker."""
+    spaced = " ".join(label.upper())
+    return color(spaced, ACCENT)
+
+
+def divider(width: int = 60, *, glyph: str = "─") -> str:
+    """Creme-paper rule line."""
+    return color(glyph * width, RULE)
+
+
+def section_header(name: str, *, subtitle: str | None = None, width: int = 60) -> str:
+    """The standard subcommand opener.
+
+       ─ <name> ────────────────────────────────────────
+       <subtitle, dim>
+    """
+    name_part = f" {gradient_gold(name)} "
+    # Stripped-color length for visible width calc
+    visible_name_len = len(f" {name} ")
+    rule_left = "─"
+    rule_right = "─" * max(3, width - 1 - visible_name_len)
+    head = color(rule_left, RULE) + name_part + color(rule_right, RULE)
+    if subtitle:
+        return head + "\n" + dim(subtitle)
+    return head
+
+
+def chip(text: str, *, palette: str = "accent") -> str:
+    """Compact inline label · [text]."""
+    palettes = {
+        "accent": ACCENT,
+        "jade":   PULSE,
+        "warn":   ACCENT_WARM,
+        "error":  ERROR,
+        "mute":   INK_MUTE,
+    }
+    c = palettes.get(palette, ACCENT)
+    return color(f"[{text}]", c)
+
+
+def kv(label: str, value: str, *, label_width: int = 16, value_color: str = "ink") -> str:
+    """One left-aligned label / value row.
+
+    Used across status / whoami / devices for the LOCAL / SERVER blocks.
+    """
+    palettes = {
+        "ink": INK, "soft": INK_SOFT, "mute": INK_MUTE, "faint": INK_FAINT,
+        "accent": ACCENT, "ok": PULSE, "warn": ACCENT_WARM, "err": ERROR,
+    }
+    val_color = palettes.get(value_color, INK_SOFT)
+    return f"  {color(label.ljust(label_width), INK_FAINT)} {color(value, val_color)}"
+
+
+def block_title(text: str) -> str:
+    """Sub-section title within a command output. Like 'LOCAL' or 'SERVER'."""
+    return "\n" + eyebrow(text)
+
+
+def success_line(text: str) -> str:
+    """Single-line success marker with gradient + glyph."""
+    return f"  {ok(GLYPH_OK)} {gradient_jade(text)}"
+
+
+def warn_line(text: str) -> str:
+    return f"  {warn(GLYPH_WARN)} {warn(text)}"
+
+
+def err_line(text: str) -> str:
+    return f"  {err(GLYPH_ERR)} {err(text)}"
+
+
+def hr_caption(caption: str, *, width: int = 60) -> str:
+    """Caption line under a divider — small, muted, centered."""
+    pad = max(0, (width - len(caption)) // 2)
+    return " " * pad + dim(caption)
+
+
+def footer_credits(*, width: int = 60) -> str:
+    """Bottom-of-output line. Used at end of long outputs."""
+    return color("─" * width, RULE) + "\n" + dim("  sibyl labs · memory you can hold in your hand")

{sibyl_memory_cli-0.1.4 → sibyl_memory_cli-0.3.2}/src/sibyl_memory_cli/_banner.py

@@ -45,6 +45,7 @@ _GRADIENT = (
 )
 
 _TAGLINE = "memory you can hold in your hand"
+_ATTRIBUTION = "a Sibyl Labs LLC Product. Agentic Infrastructure and Memory Products"
 
 
 def _supports_truecolor() -> bool:
@@ -97,8 +98,9 @@ def render_banner(*, force_color: bool | None = None) -> str:
     if not use_truecolor:
         # Plain text — still visually clean, just no color.
         body = "\n".join("  " + line for line in _LINES)
-        tagline = f"\n  {_TAGLINE}\n"
-        return body + tagline
+        tagline = f"\n  {_TAGLINE}"
+        attribution = f"\n  {_ATTRIBUTION}\n"
+        return body + tagline + attribution
 
     # Colored — apply per-row gradient.
     colored_lines = []
@@ -106,10 +108,14 @@ def render_banner(*, force_color: bool | None = None) -> str:
         colored_lines.append(f"  {_rgb(r, g, b)}{line}{_RESET}")
 
     body = "\n".join(colored_lines)
-    # Tagline in dim italic-feeling color (the deepest gold)
+    # Tagline in the deepest gold — present, but not competing with the wordmark.
     r, g, b = _GRADIENT[-1]
-    tagline = f"\n  {_rgb(r, g, b)}{_TAGLINE}{_RESET}\n"
-    return body + tagline
+    tagline = f"\n  {_rgb(r, g, b)}{_TAGLINE}{_RESET}"
+    # Attribution dimmer still — a half-step below the tagline so the hierarchy
+    # reads SIBYL > tagline > attribution at a glance. ANSI dim (\033[2m) gives
+    # ~55% perceived opacity across the supported terminals.
+    attribution = f"\n  \033[2m{_rgb(r, g, b)}{_ATTRIBUTION}{_RESET}\n"
+    return body + tagline + attribution
 
 
 def print_banner(*, force_color: bool | None = None) -> None:

{sibyl_memory_cli-0.1.4 → sibyl_memory_cli-0.3.2}/src/sibyl_memory_cli/cli.py

@@ -59,6 +59,8 @@ UPGRADE_TIMEOUT_SEC = 15 * 60   # 15 minutes for upgrade — wallet ux can be sl
 
 # ---- Color / output ----------------------------------------------------
 
+from . import _aesthetic as a
+
 _NO_COLOR = bool(os.environ.get("NO_COLOR")) or not sys.stdout.isatty()
 
 
@@ -106,7 +108,7 @@ class HttpError(Exception):
         self.url = url
 
 
-def http_request(
+def http_request(  # noqa: D401
     method: str,
     path: str,
     *,
@@ -215,10 +217,12 @@ def cmd_init(args: argparse.Namespace) -> int:
     cred_path = Path(args.credentials).expanduser()
     if cred_path.exists() and not args.force:
         existing = read_credentials(cred_path) or {}
-        print(yellow("Already activated.") + " Use --force to re-activate.")
-        print_status("Account", short(existing.get("account_id")))
-        print_status("Tier", (existing.get("tier") or "free").upper())
-        print_status("Credentials", str(cred_path))
+        print(a.section_header("already activated", subtitle="use --force to re-activate"))
+        print()
+        print(a.kv("Account", short(existing.get("account_id"))))
+        print(a.kv("Tier", (existing.get("tier") or "free").upper(), value_color="accent"))
+        print(a.kv("Credentials", str(cred_path)))
+        print()
         return 0
 
     # SEC-1 mitigation (v0.1.2): the URL parameter is an opaque pairing
@@ -258,14 +262,16 @@ def cmd_init(args: argparse.Namespace) -> int:
         print(yellow(f"Warning: session-init failed ({e.status}). Wallet path still works; email path may not."))
 
     print()
-    print(bold("Sibyl Memory Plugin · activation"))
+    print(a.section_header("activation", subtitle="three paths · pick whichever fits your device"))
     print()
-    print(f"  {dim('Session:')}     {short(session_id)}")
-    # Format the code with a visual break to make it easier to read off the screen
-    print(f"  {dim('Code:')}        {bold(pairing_code[:3] + ' ' + pairing_code[3:])}   {dim('(use this in the email panel)')}")
-    print(f"  {dim('Opening:')}     {activate_url}")
+    print(a.kv("Session", short(session_id)))
+    formatted_code = pairing_code[:3] + " " + pairing_code[3:]
+    print(a.kv("Code", a.gradient_gold(formatted_code), value_color="accent")
+          + "  " + a.dim("(use this in the email panel)"))
+    print(a.kv("Opening", activate_url))
     print()
-    print(dim("Pick wallet (SIWE) or email + the code above. This terminal will pick up automatically."))
+    print(a.dim("  desktop wallet · email + code · or send USDC from any mobile wallet"))
+    print(a.dim("  this terminal will pick up automatically when you bind."))
     print()
 
     try:
@@ -312,38 +318,46 @@ def cmd_init(args: argparse.Namespace) -> int:
             creds["session_token"] = bearer
             path = write_credentials_atomic(creds, cred_path)
             print(f"\r{' ' * 80}\r", end="")  # clear spinner line
-            print(green("✓ Activated."))
-            print_status("Account", short(creds.get("account_id")))
-            print_status("Tier", (creds.get("tier") or "free").upper())
-            print_status("Wallet", creds.get("wallet") or "—")
-            print_status("Email", creds.get("email") or "—")
-            print_status("Credentials", str(path))
             print()
-            print(dim("Activate Sibyl in Hermes:"))
-            print(dim("    sibyl-memory-hermes install-plugin"))
-            print(dim("    # then edit ~/.hermes/config.yaml:"))
-            print(dim("    #   memory:"))
-            print(dim("    #     provider: sibyl"))
+            print(a.success_line("Activated."))
+            print()
+            print(a.kv("Account", short(creds.get("account_id"))))
+            print(a.kv("Tier", (creds.get("tier") or "free").upper(), value_color="accent"))
+            print(a.kv("Wallet", creds.get("wallet") or "—"))
+            print(a.kv("Email", creds.get("email") or "—"))
+            print(a.kv("Credentials", str(path)))
+            print()
+            print(a.section_header("wire it into your agent"))
             print()
-            print(dim("Or use the MCP server (Claude Code / Codex / Cursor / Continue):"))
-            print(dim("    pip install sibyl-memory-mcp"))
+            print(a.dim("  hermes:"))
+            print(a.dim("    sibyl-memory-hermes install-plugin"))
+            print(a.dim("    # then edit ~/.hermes/config.yaml:"))
+            print(a.dim("    #   memory:"))
+            print(a.dim("    #     provider: sibyl"))
+            print()
+            print(a.dim("  claude code / codex / cursor / continue (MCP):"))
+            print(a.dim("    pip install sibyl-memory-mcp"))
+            print()
+            print(a.dim("  python orchestration (langchain / llamaindex / custom):"))
+            print(a.dim("    from sibyl_memory_hermes import SibylMemoryProvider"))
+            print(a.dim("    provider = SibylMemoryProvider()"))
             print()
-            print(dim("Or call the SDK directly from any Python orchestration:"))
-            print(dim("    from sibyl_memory_hermes import SibylMemoryProvider"))
-            print(dim("    provider = SibylMemoryProvider()"))
             return 0
 
         # Spinner tick
         spin_i = (spin_i + 1) % len(spinner)
         remaining = int(deadline - time.time())
-        status = f"\r  {cyan(spinner[spin_i])} waiting for browser activation … {dim(f'{remaining // 60}:{remaining % 60:02d} left')}"
+        spin_glyph = a.color(spinner[spin_i], a.PULSE)
+        status = f"\r  {spin_glyph} {a.dim('watching the network for your bind')} … {a.dim(f'{remaining // 60}:{remaining % 60:02d} left')}"
         if status != last_status:
             sys.stdout.write(status)
             sys.stdout.flush()
             last_status = status
         time.sleep(POLL_INTERVAL_SEC)
 
-    print(red("\nActivation timed out. Re-run `sibyl init` to try again."))
+    print()
+    print(a.err_line("Activation timed out."))
+    print(a.dim("  Re-run `sibyl init` to try again."))
     return 1
 
 
@@ -353,7 +367,8 @@ def cmd_upgrade(args: argparse.Namespace) -> int:
     """Upgrade flow. Read existing creds → open upgrade page → poll /access until tier flips."""
     creds = read_credentials(Path(args.credentials).expanduser())
     if not creds:
-        print(red("Not activated.") + " Run `sibyl init` first.")
+        print(a.err_line("Not activated."))
+        print(a.dim("  Run `sibyl init` first."))
         return 1
 
     account_id = creds.get("account_id")
@@ -361,21 +376,22 @@ def cmd_upgrade(args: argparse.Namespace) -> int:
     current_tier = (creds.get("tier") or "free").lower()
 
     if not account_id or not session_token:
-        print(red("credentials.json is missing account_id or session_token. Re-run `sibyl init`."))
+        print(a.err_line("credentials.json is missing account_id or session_token."))
+        print(a.dim("  Re-run `sibyl init`."))
         return 1
 
     upgrade_url = f"{UPGRADE_BASE}?session={session_token}"
 
     print()
-    print(bold("Sibyl Memory Plugin · upgrade"))
+    print(a.section_header("upgrade", subtitle="lift the 2 MB free-tier cap"))
     print()
-    print_status("Account", short(account_id))
-    print_status("Current tier", current_tier.upper())
-    print_status("Opening", upgrade_url)
+    print(a.kv("Account", short(account_id)))
+    print(a.kv("Current tier", current_tier.upper(), value_color="accent"))
+    print(a.kv("Opening", upgrade_url))
     print()
-    print(dim("Two paths in your browser:"))
-    print(dim("  1. Stake $SIBYL on Base (free unlimited if you qualify)"))
-    print(dim("  2. Subscribe in USDC (monthly / quarterly / annual)"))
+    print(a.dim("  two paths in the browser:"))
+    print(a.dim("    1. stake $SIBYL on Base (free unlimited if you qualify)"))
+    print(a.dim("    2. subscribe in USDC (monthly / quarterly / annual)"))
     print()
 
     try:
@@ -416,78 +432,90 @@ def cmd_upgrade(args: argparse.Namespace) -> int:
             invalidate_tier_cache()
 
             print(f"\r{' ' * 80}\r", end="")
-            print(green(f"✓ Upgraded to {new_tier.upper()} via {source}."))
-            print_status("Source", source)
+            print()
+            print(a.success_line(f"Upgraded to {new_tier.upper()} via {source}."))
+            print()
+            print(a.kv("Source", source))
             if resp.get("expires_at"):
-                print_status("Expires", resp["expires_at"])
+                print(a.kv("Expires", resp["expires_at"]))
             if resp.get("cap_bytes") is None:
-                print_status("Storage cap", "unlimited")
+                print(a.kv("Storage cap", "unlimited", value_color="ok"))
             else:
-                print_status("Storage cap", f"{resp['cap_bytes']:,} bytes")
+                print(a.kv("Storage cap", f"{resp['cap_bytes']:,} bytes"))
             if resp.get("staker"):
                 s = resp["staker"]
-                print_status("Wallet", s.get("wallet", "—"))
-                print_status("$SIBYL held", s.get("total_sibyl", "—"))
+                print(a.kv("Wallet", s.get("wallet", "—")))
+                print(a.kv("$SIBYL held", str(s.get("total_sibyl", "—"))))
             print()
-            print(dim("Local tier cache cleared. Your next write will sync the new tier."))
+            print(a.dim("  local tier cache cleared. your next write will sync the new tier."))
             return 0
 
         spin_i = (spin_i + 1) % len(spinner)
         remaining = int(deadline - time.time())
-        status = f"\r  {cyan(spinner[spin_i])} waiting for browser upgrade … current: {current_tier.upper()}  {dim(f'{remaining // 60}:{remaining % 60:02d} left')}"
+        spin_glyph = a.color(spinner[spin_i], a.PULSE)
+        tier_glyph = a.color(current_tier.upper(), a.ACCENT)
+        status = f"\r  {spin_glyph} {a.dim('waiting for browser upgrade')} · current: {tier_glyph}  {a.dim(f'{remaining // 60}:{remaining % 60:02d} left')}"
         if status != last_status:
             sys.stdout.write(status)
             sys.stdout.flush()
             last_status = status
         time.sleep(POLL_INTERVAL_SEC)
 
-    print(red("\nUpgrade timed out. Tier unchanged. Re-run `sibyl upgrade` to retry."))
+    print()
+    print(a.err_line("Upgrade timed out. Tier unchanged."))
+    print(a.dim("  Re-run `sibyl upgrade` to retry."))
     return 1
 
 
 # ---- `sibyl status` ----------------------------------------------------
 
 def cmd_status(args: argparse.Namespace) -> int:
-    """Show local + server-side state without modifying anything."""
+    """Show local + server-side state without modifying anything.
+
+    LIGHT treatment: utilitarian dashboard. No banner, no section header,
+    no chrome. Eyebrow labels + kv rows + ↓ status drift surfaces. Same
+    convention as `git status`, `ls -la`, `btop` panel bodies."""
     cred_path = Path(args.credentials).expanduser()
     creds = read_credentials(cred_path)
 
-    print()
-    print(bold("Sibyl Memory Plugin · status"))
     print()
 
     if not creds:
-        print(yellow("Not activated.") + " Run `sibyl init`.")
+        print(a.warn_line("Not activated."))
+        print(a.dim("  Run `sibyl init`."))
         return 0
 
     # Local view
-    print(dim("LOCAL"))
-    print_status("Credentials", str(cred_path))
-    print_status("Account", short(creds.get("account_id")))
-    print_status("Tier", (creds.get("tier") or "free").upper())
-    print_status("Wallet", creds.get("wallet") or "—")
-    print_status("Email", creds.get("email") or "—")
-    print_status("Issued", creds.get("issued_at") or "—")
+    print(a.eyebrow("local"))
+    print(a.kv("Credentials", str(cred_path)))
+    print(a.kv("Account", short(creds.get("account_id"))))
+    print(a.kv("Tier", (creds.get("tier") or "free").upper(), value_color="accent"))
+    print(a.kv("Wallet", creds.get("wallet") or "—"))
+    print(a.kv("Email", creds.get("email") or "—"))
+    print(a.kv("Issued", creds.get("issued_at") or "—"))
 
     db_path = Path(args.db).expanduser()
     if db_path.exists():
         size = db_path.stat().st_size
-        print_status("DB path", str(db_path))
-        print_status("DB size", f"{size:,} bytes ({size / (1024 * 1024):.2f} MB)")
+        pct = size / 2_097_152 * 100
+        size_label = f"{size:,} bytes ({size / (1024 * 1024):.2f} MB · {pct:.1f}% of free cap)"
+        size_color = "warn" if pct > 80 else "soft"
+        print(a.kv("DB path", str(db_path)))
+        print(a.kv("DB size", size_label, value_color=size_color))
     else:
-        print_status("DB path", f"{db_path} (not created)")
+        print(a.kv("DB path", f"{db_path} (not created)"))
 
     tier_cache = Path(args.tier_cache).expanduser()
     if tier_cache.exists():
         cache = json.loads(tier_cache.read_text(encoding="utf-8"))
-        print_status("Tier cache", f"{cache.get('tier','?')} (checked {cache.get('checked_at','?')[:19]})")
+        print(a.kv("Tier cache", f"{cache.get('tier','?')} (checked {cache.get('checked_at','?')[:19]})"))
     else:
-        print_status("Tier cache", "—")
+        print(a.kv("Tier cache", "—"))
 
     # Server view (only if account_id + session_token are present)
     if creds.get("account_id") and creds.get("session_token"):
         print()
-        print(dim("SERVER"))
+        print(a.eyebrow("server"))
         try:
             resp = http_request(
                 "POST",
@@ -495,25 +523,26 @@ def cmd_status(args: argparse.Namespace) -> int:
                 body={"account_id": creds["account_id"], "session_token": creds["session_token"]},
                 timeout=10.0,
             )
-            print_status("Tier", (resp.get("tier") or "free").upper())
-            print_status("Source", resp.get("source") or "—")
-            print_status("Cap bytes", "unlimited" if resp.get("cap_bytes") is None else f"{resp['cap_bytes']:,}")
+            print(a.kv("Tier", (resp.get("tier") or "free").upper(), value_color="accent"))
+            print(a.kv("Source", resp.get("source") or "—"))
+            print(a.kv("Cap bytes", "unlimited" if resp.get("cap_bytes") is None else f"{resp['cap_bytes']:,}"))
             if resp.get("expires_at"):
-                print_status("Expires", resp["expires_at"])
+                print(a.kv("Expires", resp["expires_at"]))
             if resp.get("staker"):
                 s = resp["staker"]
-                print_status("$SIBYL held", s.get("total_sibyl", "—"))
-                print_status("Threshold", str(s.get("threshold_sibyl", "—")))
-                print_status("Qualified", "yes" if s.get("qualified") else "no")
+                print(a.kv("$SIBYL held", str(s.get("total_sibyl", "—"))))
+                print(a.kv("Threshold", str(s.get("threshold_sibyl", "—"))))
+                print(a.kv("Qualified", "yes" if s.get("qualified") else "no",
+                           value_color="ok" if s.get("qualified") else "soft"))
             # Detect server/local drift
             srv_tier = (resp.get("tier") or "free").lower()
             loc_tier = (creds.get("tier") or "free").lower()
             if srv_tier != loc_tier:
                 print()
-                print(yellow(f"⚠ Local tier ({loc_tier}) differs from server tier ({srv_tier})."))
-                print(dim("  Run `sibyl upgrade` to refresh, or remove credentials.json + `sibyl init` to re-activate."))
+                print(a.warn_line(f"Local tier ({loc_tier}) differs from server tier ({srv_tier})."))
+                print(a.dim("  Run `sibyl upgrade` to refresh, or `sibyl init --force` to re-activate."))
         except HttpError as e:
-            print_status("Tier", red(f"server error: {e.status}"))
+            print(a.kv("Tier", f"server error: {e.status}", value_color="err"))
 
     print()
     return 0
@@ -550,6 +579,151 @@ def cmd_dashboard(args: argparse.Namespace) -> int:
     return cmd_status(args)
 
 
+# ---- `sibyl whoami` ----------------------------------------------------
+
+def _mask_email(e: str | None) -> str:
+    if not e or "@" not in e:
+        return "—"
+    user, _, domain = e.partition("@")
+    if "." not in domain:
+        return f"{user[0]}***@{domain[0]}***"
+    name, _, tld = domain.rpartition(".")
+    return f"{user[0]}***@{name[0]}***.{tld}"
+
+
+def _mask_wallet(w: str | None) -> str:
+    if not w or not w.startswith("0x") or len(w) < 12:
+        return w or "—"
+    return f"{w[:6]}…{w[-4:]}"
+
+
+def cmd_whoami(args: argparse.Namespace) -> int:
+    """One-line account summary. Shows account_id + tier + linked email/wallet + this device.
+
+    LIGHT treatment: 4-line glance. No banner, no section header. Same shape
+    as `whoami` on unix, `gh auth status`, `aws sts get-caller-identity`."""
+    creds = read_credentials(Path(args.credentials).expanduser())
+    if not creds:
+        print(a.warn_line("Not activated."))
+        print(a.dim("  Run `sibyl init`."))
+        return 1
+
+    full = bool(getattr(args, "full", False))
+    acct = creds.get("account_id") or ""
+    tier = (creds.get("tier") or "free").upper()
+    email = creds.get("email") if full else _mask_email(creds.get("email"))
+    wallet = creds.get("wallet") if full else _mask_wallet(creds.get("wallet"))
+
+    print()
+    print(f"  {a.color('account', a.INK_FAINT)}  {a.bold(short(acct))}  {a.dim(a.GLYPH_DOT)}  {a.gradient_gold(tier)}")
+    print(f"  {a.color('wallet ', a.INK_FAINT)}  {a.color(wallet or '—', a.INK)}")
+    print(f"  {a.color('email  ', a.INK_FAINT)}  {a.color(email or '—', a.INK)}")
+    os_label = _detect_os_family() or "unknown"
+    device_line = f"sibyl-memory-cli/{_client_version()} {os_label}"
+    print(f"  {a.color('device ', a.INK_FAINT)}  {a.dim(device_line)}")
+    print()
+    return 0
+
+
+# ---- `sibyl devices` ---------------------------------------------------
+
+def cmd_devices(args: argparse.Namespace) -> int:
+    """List active bearer tokens (devices) for the account. Optional: revoke by index."""
+    creds = read_credentials(Path(args.credentials).expanduser())
+    if not creds:
+        print(a.err_line("Not activated."))
+        print(a.dim("  Run `sibyl init`."))
+        return 1
+    account_id = creds.get("account_id")
+    session_token = creds.get("session_token")
+    if not account_id or not session_token:
+        print(a.err_line("credentials.json missing account_id or session_token."))
+        print(a.dim("  Run `sibyl init`."))
+        return 1
+
+    sub = getattr(args, "sub", None)
+
+    # `sibyl devices revoke <index>` path
+    if sub == "revoke":
+        idx = getattr(args, "index", None)
+        if idx is None:
+            print(red("usage: sibyl devices revoke <index>"))
+            return 1
+        # List first to map index → bearer_id
+        try:
+            resp = http_request(
+                "GET",
+                f"/api/plugin/devices?account_id={urllib.parse.quote(account_id)}",
+                headers={"Authorization": f"Bearer {session_token}"},
+                timeout=10.0,
+            )
+        except HttpError as e:
+            print(red(f"server error: {e.status} {e.body}"))
+            return 2
+        devices = resp.get("devices", [])
+        try:
+            target = devices[idx]
+        except (IndexError, TypeError):
+            print(red(f"no device at index {idx}. Run `sibyl devices` to see indexes."))
+            return 1
+        if target.get("is_this_device"):
+            print(red("refusing to revoke your own device — that would lock you out. Run `sibyl logout` instead, then `sibyl init` on a fresh activation."))
+            return 1
+        try:
+            revoke_resp = http_request(
+                "POST",
+                "/api/plugin/devices",
+                body={"bearer_id": target["bearer_id"]},
+                headers={"Authorization": f"Bearer {session_token}"},
+                timeout=10.0,
+            )
+        except HttpError as e:
+            print(red(f"revoke failed: {e.status} {e.body}"))
+            return 2
+        print(green(f"✓ Revoked device {target.get('device_label') or target['bearer_id']}"))
+        return 0 if revoke_resp.get("revoked") else 1
+
+    # Default: list devices
+    try:
+        resp = http_request(
+            "GET",
+            f"/api/plugin/devices?account_id={urllib.parse.quote(account_id)}",
+            headers={"Authorization": f"Bearer {session_token}"},
+            timeout=10.0,
+        )
+    except HttpError as e:
+        if e.status == 401:
+            print(a.err_line("Session expired."))
+            print(a.dim("  Re-run `sibyl init`."))
+        else:
+            print(a.err_line(f"server error: {e.status} {e.body}"))
+        return 2
+
+    devices = resp.get("devices", [])
+    # LIGHT treatment: table-like dashboard. Eyebrow line with count + the rows. No banner.
+    print()
+    print(f"  {a.eyebrow('devices')}  {a.dim(f'· {len(devices)} active')}")
+    print()
+    if not devices:
+        print(a.dim("  no active devices"))
+        print()
+        return 0
+
+    for i, d in enumerate(devices):
+        is_this = d.get("is_this_device")
+        marker = a.ok("▶") if is_this else " "
+        label = d.get("device_label") or "(unlabeled)"
+        installed = d.get("install_method") or "—"
+        last_seen = d.get("last_seen_at", "")[:19].replace("T", " ")
+        idx_chip = a.chip(str(i), palette="jade" if is_this else "mute")
+        label_color = a.gradient_gold(label) if is_this else a.color(label, a.INK)
+        meta = f"{a.dim(installed)} {a.dim(a.GLYPH_DOT)} {a.dim('last seen ' + last_seen)}"
+        note = a.color("(this device)", a.PULSE) if is_this else a.dim(f"revoke: sibyl devices revoke {i}")
+        print(f"  {marker} {idx_chip} {label_color}  {meta}  {note}")
+    print()
+    return 0
+
+
 # ---- `sibyl logout` ----------------------------------------------------
 
 def cmd_logout(args: argparse.Namespace) -> int:
@@ -565,16 +739,17 @@ def cmd_logout(args: argparse.Namespace) -> int:
         tier_cache.unlink()
         deleted.append(str(tier_cache))
 
+    # LIGHT treatment: quick confirmation. No banner, no section header.
     print()
     if not deleted:
-        print(yellow("Nothing to remove.") + " Already logged out.")
+        print(a.warn_line("Nothing to remove."))
+        print(a.dim("  Already logged out."))
     else:
-        print(green("✓ Logged out."))
+        print(a.success_line("Logged out."))
         for path in deleted:
-            print(f"  {dim('removed')} {path}")
+            print(f"  {a.dim('removed')} {a.color(path, a.INK)}")
         print()
-        print(dim("Your memory.db file is untouched — that's your data."))
-        print(dim("Run `sibyl init` to activate a fresh account."))
+        print(a.dim("  memory.db untouched. run `sibyl init` to activate a fresh account."))
     print()
     return 0
 
@@ -586,12 +761,28 @@ def cmd_health(args: argparse.Namespace) -> int:
     try:
         from sibyl_memory_hermes import SibylMemoryProvider
     except ImportError:
-        print(red("sibyl-memory-hermes not installed."))
+        print(a.err_line("sibyl-memory-hermes not installed."))
+        print(a.dim("  pip install sibyl-memory-hermes"))
         return 1
+
+    # LIGHT treatment: verdict + details. No banner, no section header.
+    # Pattern: `pg_isready` / `redis-cli ping` / `gh auth status`.
+    print()
     provider = SibylMemoryProvider(db_path=args.db)
     h = provider.health()
-    print(json.dumps(h, indent=2))
-    return 0 if h.get("ok") else 1
+    ok_state = bool(h.get("ok"))
+    if ok_state:
+        print(a.success_line("All green."))
+    else:
+        print(a.err_line("Health check reports issues."))
+    print()
+    for k, v in h.items():
+        if k == "ok":
+            continue
+        val = str(v)
+        print(a.kv(k, val, value_color="ok" if v is True else ("soft" if v else "warn")))
+    print()
+    return 0 if ok_state else 1
 
 
 # ---- Dispatch ----------------------------------------------------------
@@ -620,6 +811,17 @@ def build_parser() -> argparse.ArgumentParser:
     p_st = sub.add_parser("status", help="Show local + server tier / DB stats")
     p_st.set_defaults(func=cmd_status)
 
+    p_who = sub.add_parser("whoami", help="One-line account summary (masked by default)")
+    p_who.add_argument("--full", action="store_true", help="Show full email + wallet (no masking)")
+    p_who.set_defaults(func=cmd_whoami)
+
+    p_dev = sub.add_parser("devices", help="List devices (active bearer tokens) for the account")
+    dev_sub = p_dev.add_subparsers(dest="sub")
+    p_rev = dev_sub.add_parser("revoke", help="Revoke a device by index (run `sibyl devices` for indexes)")
+    p_rev.add_argument("index", type=int, help="Index from `sibyl devices` output")
+    p_dev.set_defaults(func=cmd_devices)
+    p_rev.set_defaults(func=cmd_devices)
+
     p_dash = sub.add_parser("dashboard", help="Open the account dashboard (delegates to status until account.sibyllabs.org ships)")
     p_dash.set_defaults(func=cmd_dashboard)
 

{sibyl_memory_cli-0.1.4 → sibyl_memory_cli-0.3.2}/src/sibyl_memory_cli.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: sibyl-memory-cli
-Version: 0.1.4
-Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats.
+Version: 0.3.2
+Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats, `sibyl whoami` gives a one-line account summary, `sibyl devices` lists active devices and supports per-device revoke.
 Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
 License: MIT
 Project-URL: Homepage, https://sibyllabs.org/plugin

{sibyl_memory_cli-0.1.4 → sibyl_memory_cli-0.3.2}/src/sibyl_memory_cli.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 src/sibyl_memory_cli/__init__.py
+src/sibyl_memory_cli/_aesthetic.py
 src/sibyl_memory_cli/_banner.py
 src/sibyl_memory_cli/cli.py
 src/sibyl_memory_cli/setup.py