memorysync-cli 1.1.0__tar.gz → 1.1.1__tar.gz

{memorysync_cli-1.1.0 → memorysync_cli-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memorysync-cli
-Version: 1.1.0
+Version: 1.1.1
 Summary: MemorySync from your terminal. Zero dependencies.
 Project-URL: Documentation, https://docs.memorysync.io/cli
 Project-URL: Homepage, https://memorysync.io/cli

memorysync_cli-1.1.1/src/memorysync_cli/_version.py

@@ -0,0 +1 @@
+__version__ = "1.1.1"

{memorysync_cli-1.1.0 → memorysync_cli-1.1.1}/src/memorysync_cli/commands/admin.py

@@ -20,8 +20,18 @@ from .. import config as config_module
 from .. import credentials
 from .._version import __version__
 from ..errors import usage_error
+from ..evaluation import is_evaluation_key
 from ..output import render_table, style
 
+#: Keys ``config set`` / ``config unset`` accept. Identical to the Node CLI's
+#: ``SETTABLE``; ``output`` was previously missing here, so `config set output table`
+#: worked under one CLI and was refused by the other.
+#:
+#: ``api_key`` is deliberately absent. Keys go to the keychain through ``init``, and
+#: accepting one here would write a credential into a file people paste into bug
+#: reports.
+_SETTABLE = frozenset({"user", "project", "base_url", "output", "timeout"})
+
 
 def _percent(used: Any, limit: Any) -> str:
     if not isinstance(used, (int, float)) or not isinstance(limit, (int, float)) or limit <= 0:
@@ -29,6 +39,38 @@ def _percent(used: Any, limit: Any) -> str:
     return f"{min(100, round(used / limit * 100))}%"
 
 
+def _evaluation_usage_summary(api: Any) -> dict:
+    """Reshape ``/evaluation/usage`` into what ``quota`` already renders.
+
+    Same keys the billing summary returns, so the renderer and ``--json`` consumers
+    do not have to care which kind of key they are looking at. Mirrors the Node
+    CLI's ``evaluationQuota``.
+    """
+    usage = api.evaluation_usage() or {}
+    add = usage.get("add_requests") or {}
+    retrieval = usage.get("retrieval_requests") or {}
+    return {
+        "plan_id": usage.get("plan"),
+        "metrics": [
+            {
+                "metric": "add_requests",
+                "label": "Memories added",
+                "used": add.get("used"),
+                "limit": add.get("limit"),
+            },
+            {
+                "metric": "retrieval_requests",
+                "label": "Retrievals",
+                "used": retrieval.get("used"),
+                "limit": retrieval.get("limit"),
+            },
+        ],
+        "claimed": usage.get("claimed") is True,
+        "expires_at": usage.get("expires_at"),
+        "claim_command": usage.get("claim_command"),
+    }
+
+
 def quota(ctx: dict) -> dict:
     """Plan usage, with headroom made explicit.
 
@@ -36,7 +78,17 @@ def quota(ctx: dict) -> dict:
     Mem0, Supermemory or Zep expose this from their CLI.
     """
     api = ctx["api"]
-    summary = api.usage_summary() or {}
+
+    if is_evaluation_key(ctx.get("api_key")):
+        # ``/org/billing/usage-summary`` needs the ``billing.view`` capability and
+        # the ``billing:read`` scope, and an evaluation key is granted neither on
+        # purpose: ``billing:read`` also opens ``GET /org/billing/profit``, which
+        # returns cost and margin from our internal pricing model. The server
+        # exposes the same counters without the priced fields, so route there.
+        summary = _evaluation_usage_summary(api)
+    else:
+        summary = api.usage_summary() or {}
+
     metrics = [m for m in (summary.get("metrics") or []) if isinstance(m, dict)]
 
     rows = [
@@ -71,6 +123,15 @@ def quota(ctx: dict) -> dict:
                 for row in rows
             ],
         )
+        # An evaluation allowance does not reset on a cycle: the key stops working
+        # at expiry, so that is the date worth printing. Matches the Node CLI.
+        expiry_note = ""
+        if summary.get("expires_at") and not summary.get("claimed"):
+            expiry_note = "\n" + style.yellow(
+                "Unclaimed evaluation key, expires "
+                f"{str(summary['expires_at'])[:10]}."
+            )
+
         exhausted = [r["metric"] for r in rows if r["remaining"] == 0]
         if exhausted:
             warning = style.yellow(
@@ -80,8 +141,8 @@ def quota(ctx: dict) -> dict:
                 "Writes and reads return empty rather than failing, so check here "
                 "before assuming memory is missing."
             )
-            return f"{table}\n\n{warning}\n{note}"
-        return table
+            return f"{table}\n\n{warning}\n{note}{expiry_note}"
+        return f"{table}{expiry_note}"
 
     return {"data": rows, "text": render}
 
@@ -323,41 +384,123 @@ def config_command(ctx: dict) -> dict:
             ),
         }
 
+    if sub == "profiles":
+        cfg = config_module.load()
+        current = cfg.get("current_profile", "default")
+        profiles = cfg.get("profiles", {})
+        rows = [
+            [
+                style.green("*") if name == current else " ",
+                name,
+                entry.get("user") or "-",
+                entry.get("project") or "-",
+                entry.get("base_url") or "(default)",
+            ]
+            for name, entry in profiles.items()
+        ]
+
+        def render_profiles() -> str:
+            if not rows:
+                return style.dim("No profiles. Run `memorysync init`.")
+            return render_table([" ", "profile", "user", "project", "base url"], rows)
+
+        return {
+            "data": {"current": current, "profiles": profiles},
+            "text": render_profiles,
+        }
+
+    if sub == "use-profile":
+        if len(positionals) < 2:
+            raise usage_error("Which profile?")
+        name = positionals[1]
+        cfg = config_module.load()
+        if name not in cfg.get("profiles", {}):
+            raise usage_error(
+                f'No profile named "{name}".',
+                "Run `memorysync config profiles` to see what exists, or "
+                f"`memorysync init --profile {name}` to create it.",
+            )
+        cfg["current_profile"] = name
+        config_module.save(cfg)
+        return {
+            "data": {"current_profile": name},
+            "text": lambda: f"{style.green('Switched to')} {name}",
+        }
+
+    if sub == "delete-profile":
+        if len(positionals) < 2:
+            raise usage_error("Which profile?")
+        name = positionals[1]
+        cfg = config_module.load()
+        if name not in cfg.get("profiles", {}):
+            raise usage_error(f'No profile named "{name}".')
+        del cfg["profiles"][name]
+        if cfg.get("current_profile") == name:
+            remaining = list(cfg.get("profiles", {}))
+            cfg["current_profile"] = remaining[0] if remaining else "default"
+        config_module.save(cfg)
+        # The stored credential goes with the profile. Leaving it behind would keep
+        # a usable key in the keychain for a profile the user just removed.
+        credentials.delete_key(name)
+        return {
+            "data": {"deleted": name},
+            "text": lambda: f"{style.green('Deleted profile')} {name}",
+        }
+
     if sub == "get":
         if len(positionals) < 2:
             raise usage_error("Which key?", "memorysync config get user")
         key = positionals[1]
-        settings = config_module.resolve(ctx["flags"])
-        value = settings.get(key)
+        # Reads the stored profile, not the resolved value. Matches the Node CLI:
+        # `config get` answers "what is written down", so an environment variable
+        # does not make it look as though something was saved.
+        cfg = config_module.load()
+        entry = cfg.get("profiles", {}).get(cfg.get("current_profile", "default"), {})
+        value = entry.get(key)
         return {"data": {key: value}, "text": lambda: "" if value is None else str(value)}
 
-    if sub == "set":
-        if len(positionals) < 3:
-            raise usage_error("What to set?", "memorysync config set user alice")
-        key, value = positionals[1], positionals[2]
+    if sub in {"set", "unset"}:
+        if len(positionals) < 2:
+            raise usage_error(
+                "Which key?", f"Settable: {', '.join(sorted(_SETTABLE))}"
+            )
+        key = positionals[1]
         if key in {"api_key", "apikey", "key"}:
             raise usage_error(
                 "Keys are not stored in the config file.",
                 "Run `memorysync init --api-key <key>`; it goes to the OS keychain.",
             )
-        allowed = {"user", "project", "base_url", "timeout"}
-        if key not in allowed:
+        if key not in _SETTABLE:
             raise usage_error(
-                f'Cannot set "{key}".',
-                f"One of: {', '.join(sorted(allowed))}.",
+                f'"{key}" is not settable.',
+                f"Settable keys: {', '.join(sorted(_SETTABLE))}. The API key is "
+                "never stored here; use `memorysync init`.",
             )
-
-        profile_name = ctx["settings"]["profile_name"]
-        data = config_module.load()
-        data.setdefault("profiles", {}).setdefault(profile_name, {})[key] = value
-        path = config_module.save(data)
+        if sub == "set" and len(positionals) < 3:
+            raise usage_error(f"config set {key} <value>")
+        value = positionals[2] if sub == "set" else None
+
+        cfg = config_module.load()
+        name = cfg.get("current_profile", "default")
+        entry = dict(cfg.get("profiles", {}).get(name, {}))
+        if sub == "set":
+            entry[key] = value
+        else:
+            entry.pop(key, None)
+        cfg.setdefault("profiles", {})[name] = entry
+        config_module.save(cfg)
         return {
-            "data": {"profile": profile_name, key: value, "path": str(path)},
-            "text": lambda: f"{style.green('Set')} {key} = {value} in profile {profile_name}",
+            "data": {"profile": name, key: value},
+            "text": lambda: (
+                f"{style.green('Set' if sub == 'set' else 'Unset')} {key} "
+                f"on profile {name}"
+            ),
         }
 
     if sub == "path":
         path = str(config_module.config_path())
         return {"data": {"path": path}, "text": lambda: path}
 
-    raise usage_error(f'Unknown subcommand "{sub}".', "Try show, get, set or path.")
+    raise usage_error(
+        f'Unknown subcommand "{sub}".', "Try `memorysync config show`."
+    )

{memorysync_cli-1.1.0 → memorysync_cli-1.1.1}/src/memorysync_cli/commands/init.py

@@ -149,9 +149,10 @@ def _init_by_claiming(ctx: dict, profile_name: str) -> dict:
 
         return {"data": payload, "text": render_complete}
 
-    api_key = credentials.read_key(profile_name) or os.environ.get(
-        "MEMORYSYNC_API_KEY"
-    )
+    # The value ``main`` already resolved from --api-key, the environment, then the
+    # stored profile. Resolving it again here would be a second precedence order
+    # for the Node CLI to disagree with.
+    api_key = ctx.get("api_key")
     if not api_key:
         raise usage_error(
             "No stored key, so there is no evaluation account to claim.",
@@ -198,6 +199,10 @@ def identify(ctx: dict) -> dict:
     entry = data.setdefault("profiles", {}).setdefault(profile_name, {})
     previous = entry.get("user")
     entry["user"] = name
+    # Also make it current, matching the Node CLI. Without this, `identify` under
+    # one CLI set a default that the other did not switch to, which is exactly the
+    # kind of near-miss the two-CLI contract exists to prevent.
+    data["current_profile"] = profile_name
     config_module.save(data)
 
     payload = {

{memorysync_cli-1.1.0 → memorysync_cli-1.1.1}/src/memorysync_cli/config.py

@@ -55,7 +55,7 @@ def config_path() -> Path:
 
 
 def _empty() -> dict[str, Any]:
-    return {"version": CONFIG_VERSION, "profiles": {}}
+    return {"version": CONFIG_VERSION, "profiles": {}, "current_profile": "default"}
 
 
 def load() -> dict[str, Any]:
@@ -78,6 +78,18 @@ def load() -> dict[str, Any]:
     return {
         "version": parsed.get("version", CONFIG_VERSION),
         "profiles": parsed.get("profiles") if isinstance(parsed.get("profiles"), dict) else {},
+        # Preserved, not dropped. This key was being discarded on read, so the
+        # Python CLI had no concept of an active profile at all: `config
+        # use-profile work` wrote it and every later command still used "default",
+        # and a profile switched under the Node CLI was ignored here. The two are
+        # documented as interchangeable and share ~/.memorysync, so that was a real
+        # divergence rather than a missing nicety.
+        "current_profile": (
+            parsed.get("current_profile")
+            if isinstance(parsed.get("current_profile"), str)
+            and parsed.get("current_profile")
+            else "default"
+        ),
     }
 
 
@@ -105,10 +117,18 @@ def resolve(flags: dict[str, Any]) -> dict[str, Any]:
     Values are read once here so every command sees the same view, rather than
     each one reaching for the environment at a different moment.
     """
+    # Same precedence as the Node CLI's ``resolveSettings``: an explicit flag, then
+    # the environment, then the profile the user selected with
+    # ``config use-profile``, then "default". The stored selection was missing here,
+    # which is why a switch made under either CLI had no effect on this one.
+    config = load()
     profile_name = (
-        flags.get("profile") or os.environ.get("MEMORYSYNC_PROFILE") or "default"
+        flags.get("profile")
+        or os.environ.get("MEMORYSYNC_PROFILE")
+        or config.get("current_profile")
+        or "default"
     )
-    stored = profile(profile_name)
+    stored = config.get("profiles", {}).get(profile_name, {})
 
     def pick(
         flag_key: str,

{memorysync_cli-1.1.0 → memorysync_cli-1.1.1}/src/memorysync_cli/http.py

@@ -64,12 +64,22 @@ class ApiClient:
 
     def headers(self, extra: dict[str, str] | None = None) -> dict[str, str]:
         headers = {
-            "X-API-Key": self.api_key,
             "Accept": "application/json",
             # From the package version, never a literal. The Node CLI shipped
             # 1.0.1 announcing itself as 1.0.0 because this was hardcoded.
             "User-Agent": f"memorysync-cli-py/{__version__}",
         }
+        # Omitted rather than sent empty when there is no key.
+        #
+        # Two endpoints are deliberately keyless: minting an evaluation key, and
+        # redeeming a claim code. Setting the header to ``None`` made urllib raise
+        # ``TypeError: expected string or bytes-like object`` inside ``putheader``,
+        # before the request was sent -- so `init --agent` and `init --email --code`
+        # could never work in this package at all. The Node CLI survived the same
+        # bug only because ``fetch`` coerces null to the string "null", which the
+        # server then ignores on an unauthenticated route.
+        if self.api_key:
+            headers["X-API-Key"] = self.api_key
         # The API rejects key-authenticated memory calls without this, because
         # memory is always scoped to (tenant, project, user) and storing
         # everything under the key owner is not allowed. Commands validate it up

memorysync_cli-1.1.0/src/memorysync_cli/_version.py

@@ -1 +0,0 @@
-__version__ = "1.1.0"