memorysync-cli 1.1.3__tar.gz → 1.1.4__tar.gz

{memorysync_cli-1.1.3 → memorysync_cli-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memorysync-cli
-Version: 1.1.3
+Version: 1.1.4
 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.4/src/memorysync_cli/_version.py

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

{memorysync_cli-1.1.3 → memorysync_cli-1.1.4}/src/memorysync_cli/commands/admin.py

@@ -24,7 +24,7 @@ from .. import credentials
 from .._version import __version__
 from ..errors import usage_error
 from ..evaluation import is_evaluation_key
-from ..output import render_table, style
+from ..output import dumps, 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`
@@ -457,7 +457,7 @@ def config_command(ctx: dict) -> dict:
                     f"{style.dim('active profile ')} {data.get('current_profile')}",
                     f"{style.dim('key storage    ')} {credentials.describe_storage()}",
                     "",
-                    json.dumps(data.get("profiles", {}), indent=2),
+                    dumps(data.get("profiles", {})),
                 ]
             ),
         }

{memorysync_cli-1.1.3 → memorysync_cli-1.1.4}/src/memorysync_cli/commands/init.py

@@ -147,10 +147,27 @@ def _init_by_claiming(ctx: dict, profile_name: str) -> dict:
                         "Your existing key keeps working and no longer expires. "
                         "Everything stored during the evaluation is still there."
                     ),
+                    "",
+                    # Owning the account and being able to open the dashboard are
+                    # two different things, and this used to stop before saying
+                    # so. Without ``--password`` there is no credential yet, and
+                    # the only way in is a link labelled "Forgot password" —
+                    # which nobody should have to guess at for a password they
+                    # never had. The server says which case this is; print its
+                    # sentence rather than deciding here, so the two CLIs and the
+                    # API cannot drift on the instruction.
+                    style.yellow(claimed["next_step"])
+                    if claimed.get("next_step")
+                    else style.dim(
+                        "Sign in at https://app.memorysync.io/login with this address."
+                    ),
                 ]
             )
 
-        return {"data": payload, "text": render_complete}
+        # The profile now records that the account is owned, so the reminder must
+        # be re-evaluated from disk rather than from the settings resolved before
+        # this ran.
+        return {"data": payload, "text": render_complete, "rescope": True}
 
     # The value ``main`` already resolved from --api-key, the environment, then the
     # stored profile. Resolving it again here would be a second precedence order

{memorysync_cli-1.1.3 → memorysync_cli-1.1.4}/src/memorysync_cli/commands/memory.py

@@ -22,7 +22,7 @@ from typing import Any
 
 from ..errors import quota_error, usage_error
 from ..http import ApiClient
-from ..output import render_table, style
+from ..output import dumps, render_table, style
 
 
 def _require_user(ctx: dict) -> str:
@@ -608,12 +608,15 @@ def export_memories(ctx: dict) -> dict:
 
 
 def _serialize_export(memories: list[dict], fmt: str) -> str:
+    # Through the shared helper: an export is a file a customer keeps, and
+    # escaping every accent to ``\\uXXXX`` made this CLI's export a different
+    # document from the Node CLI's for the same memories.
     if fmt == "json":
-        return json.dumps(memories, indent=2) + "\n"
+        return dumps(memories) + "\n"
     if fmt == "jsonl":
         if not memories:
             return ""
-        return "\n".join(json.dumps(item) for item in memories) + "\n"
+        return "\n".join(dumps(item, indent=None) for item in memories) + "\n"
 
     # CSV, quoted by hand rather than through the csv module so the output is
     # identical to the Node CLI's, which also writes it directly.

{memorysync_cli-1.1.3 → memorysync_cli-1.1.4}/src/memorysync_cli/main.py

@@ -24,6 +24,7 @@ from .errors import CliError, Exit, auth_error, usage_error
 from .evaluation import claim_reminder
 from .http import ApiClient
 from .output import (
+    dumps,
     emit,
     error_envelope,
     set_colour_enabled,
@@ -163,7 +164,7 @@ def _fail(*, command: str, error: CliError, agent_mode: bool, started: float, se
     duration_ms = int((time.monotonic() - started) * 1000)
     if agent_mode:
         write(
-            json.dumps(
+            dumps(
                 error_envelope(
                     command=command,
                     error=error,
@@ -277,37 +278,39 @@ def dispatch(argv: list[str]) -> int:
         result = handler(ctx)
         duration_ms = int((time.monotonic() - started) * 1000)
 
+        # A command that rewrote the profile has invalidated the settings resolved
+        # before it ran, so re-read them once and use them for everything below.
+        #
+        # Two things depend on this. `init --agent` stores a new default end-user
+        # id, and reporting the previous one in `scope` told an agent to keep
+        # writing under the identity it had just replaced. And
+        # `init --email ... --code` records that the account is now owned, without
+        # which the CLI printed "This is an unclaimed evaluation key and expires"
+        # immediately after a successful claim — nagging about the exact thing the
+        # user had just done.
+        effective = _resolve_settings(flags) if result.get("rescope") else settings
+
         # `help` is a discovery contract, not a data result, so its JSON is the
         # tree itself rather than an envelope around it. An agent bootstrapping
         # from `help --json` should not have to reach into `.data[0]` for the
         # command list.
         if command_name == "help" and (agent_mode or fmt == "json"):
-            write(json.dumps(result["data"], indent=2))
-            _note_unclaimed_key(api_key, settings)
+            write(dumps(result["data"]))
+            _note_unclaimed_key(api_key, effective)
             return Exit.OK
 
         if agent_mode:
             write(
-                json.dumps(
+                dumps(
                     success_envelope(
                         command=command_name,
                         data=result["data"],
                         duration_ms=duration_ms,
-                        # A command that rewrote the profile has just invalidated
-                        # the settings resolved before it ran. `init --agent` is the
-                        # case that matters: it mints an account and stores a new
-                        # default end-user id, and reporting the previous one told
-                        # an agent to keep writing under the identity it just
-                        # replaced. Memories then split across two ids, which is the
-                        # one failure this whole flow exists to avoid.
-                        scope=_scope_of(
-                            _resolve_settings(flags) if result.get("rescope") else settings
-                        ),
-                    ),
-                    indent=2,
+                        scope=_scope_of(effective),
+                    )
                 )
             )
-            _note_unclaimed_key(api_key, settings)
+            _note_unclaimed_key(api_key, effective)
             return result.get("exit_code", Exit.OK)
 
         # `completion` and `mcp` emit text that must not be decorated or reshaped.
@@ -321,7 +324,7 @@ def dispatch(argv: list[str]) -> int:
             return result.get("exit_code", Exit.OK)
 
         emit(fmt=fmt, data=result["data"], text=result["text"])
-        _note_unclaimed_key(api_key, settings)
+        _note_unclaimed_key(api_key, effective)
         return result.get("exit_code", Exit.OK)
 
     except CliError as error:

{memorysync_cli-1.1.3 → memorysync_cli-1.1.4}/src/memorysync_cli/output.py

@@ -204,7 +204,9 @@ def _yaml_scalar(value: Any) -> str:
         # Sexagesimal: `12:30` is a number to a 1.1 parser.
         or _SEXAGESIMAL.match(text) is not None
     )
-    return json.dumps(text) if ambiguous else text
+    # Quoted through the shared helper so a value needing quotes in YAML is not
+    # also ASCII-escaped, which the Node CLI does not do.
+    return dumps(text, indent=None) if ambiguous else text
 
 
 def to_yaml(value: Any, indent: int = 0) -> str:
@@ -316,13 +318,36 @@ def write(text: str) -> None:
     sys.stdout.write(f"{text}\n")
 
 
+def dumps(data: Any, *, indent: int | None = 2) -> str:
+    """JSON exactly as the Node CLI's ``JSON.stringify`` writes it.
+
+    ``ensure_ascii=False`` is the whole point. Python escapes non-ASCII by
+    default, so an em-dash came out as ``\\u2014`` here and as the character
+    itself there — the same document in different bytes, from two CLIs published
+    as interchangeable. It showed up on a claim response whose sentence contains
+    one, and it would have applied to every ``--json`` payload carrying any
+    non-ASCII text, which for a memory store is most of them: any customer
+    memory containing an accent, a dash or an emoji.
+
+    Separators are pinned too, because Python's defaults leave a trailing space
+    after ``,`` when no indent is given and JavaScript does not.
+
+    Every user-facing JSON write goes through here so the two cannot drift again.
+    Request bodies deliberately do not: those are read by our own API, which
+    decodes both spellings to the same string, and no user ever sees them.
+    """
+    if indent is None:
+        return json.dumps(data, ensure_ascii=False, separators=(",", ":"))
+    return json.dumps(data, indent=indent, ensure_ascii=False)
+
+
 def emit(*, fmt: str, data: Any, text: Callable[[], str]) -> None:
     """Render one result.
 
     ``text`` stays lazy so a JSON caller never pays to build a table it discards.
     """
     if fmt == "json":
-        write(json.dumps(data, indent=2))
+        write(dumps(data))
         return
     if fmt == "yaml":
         write(to_yaml(data))

memorysync_cli-1.1.3/src/memorysync_cli/_version.py

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