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

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

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

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

{memorysync_cli-1.1.3 → memorysync_cli-1.2.0}/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.2.0}/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.2.0}/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:
@@ -510,6 +510,27 @@ def import_memories(ctx: dict) -> dict:
     records: list[dict] = []
     errors: list[str] = []
 
+    def _validate(number: int, entry: Any) -> None:
+        """Record one candidate as either usable or an error, in line order."""
+        if not isinstance(entry, dict):
+            errors.append(f"line {number}: expected an object")
+            return
+        text = entry.get("text") or entry.get("memory") or entry.get("content")
+        # Has to be a non-blank string, not merely truthy. ``{"text": 123}``
+        # would otherwise be stringified into a memory here and refused by the
+        # Node CLI, and the two must agree on what the file means.
+        if not isinstance(text, str) or not text.strip():
+            errors.append(f"line {number}: no text, memory or content field")
+            return
+        record: dict[str, Any] = {
+            "text": text.strip(),
+            "source": entry.get("source") or "cli-import",
+            "line": number,
+        }
+        if isinstance(entry.get("metadata"), dict):
+            record["metadata"] = entry["metadata"]
+        records.append(record)
+
     stripped = raw.strip()
     if stripped.startswith("["):
         try:
@@ -518,66 +539,183 @@ def import_memories(ctx: dict) -> dict:
             raise usage_error(f"{source_path} is not valid JSON: {error}") from None
         if not isinstance(parsed, list):
             raise usage_error(f"{source_path} must contain a JSON array.")
-        candidates = list(enumerate(parsed, start=1))
+        for number, entry in enumerate(parsed, start=1):
+            _validate(number, entry)
     else:
-        candidates = []
+        # One ordered pass. Collecting parse failures first and field failures
+        # afterwards reported a bad line 3 ahead of a bad line 2, which the Node
+        # CLI does not do and which reads as though the file were shuffled.
         for number, line in enumerate(stripped.splitlines(), start=1):
             if not line.strip():
                 continue
             try:
-                candidates.append((number, json.loads(line)))
+                entry = json.loads(line)
             except ValueError as error:
                 errors.append(f"line {number}: {error}")
+                continue
+            _validate(number, entry)
 
-    for number, entry in candidates:
-        if not isinstance(entry, dict):
-            errors.append(f"line {number}: expected an object")
-            continue
-        text = entry.get("text") or entry.get("memory") or entry.get("content")
-        if not text:
-            errors.append(f"line {number}: no text, memory or content field")
-            continue
-        record: dict[str, Any] = {"text": str(text), "source": entry.get("source") or "import"}
-        if isinstance(entry.get("metadata"), dict):
-            record["metadata"] = entry["metadata"]
-        records.append(record)
+    # The dry run reports problems; it does not refuse because of them. Checking
+    # this before the error gate is the whole point of the flag: someone running
+    # --dry-run on a file they suspect is malformed wants the list of what is
+    # wrong, not a single error telling them to fix it first.
+    if flags.get("dry_run"):
+        preview = list(errors[:10])
+        trailer = len(errors) - len(preview)
+        return {
+            "data": {
+                "file": source_path,
+                "valid": len(records),
+                "invalid": len(errors),
+                "errors": errors,
+            },
+            "text": lambda: "\n".join(
+                line
+                for line in [
+                    style.yellow("Dry run. Nothing was sent."),
+                    f"{style.dim('valid   ')} {len(records)}",
+                    f"{style.dim('invalid ')} {len(errors)}",
+                    *[style.dim(f"  {message}") for message in preview],
+                    style.dim(f"  ... and {trailer} more") if trailer > 0 else "",
+                    style.yellow(
+                        "A real run would refuse this file. Pass --continue-on-error "
+                        "to skip bad rows."
+                    )
+                    if errors and not flags.get("continue_on_error")
+                    else "",
+                ]
+                if line
+            ),
+        }
 
-    if errors:
+    if errors and not flags.get("continue_on_error"):
         raise usage_error(
-            f"{source_path} has {len(errors)} invalid row(s); nothing was imported.",
-            "; ".join(errors[:5]) + ("; ..." if len(errors) > 5 else ""),
+            f"{len(errors)} record(s) in {source_path} are not usable.",
+            f"First problem: {errors[0]}. Run again with --dry-run to see them all, "
+            "or --continue-on-error to skip bad rows.",
         )
     if not records:
         raise usage_error(f"{source_path} contained no records.")
 
-    if flags.get("dry_run"):
-        return {
-            "data": {"would_import": len(records), "user": user},
-            "text": lambda: style.yellow(
-                f"Dry run. {len(records)} record(s) validated. Nothing was imported."
-            ),
-        }
+    batch_size = _resolve_batch_size(flags)
+    batches = [records[i : i + batch_size] for i in range(0, len(records), batch_size)]
+    totals = {
+        "total": len(records),
+        "imported": 0,
+        "memory_ids": [],
+        "skipped": 0,
+        "failed": 0,
+        "unreported": 0,
+        "failures": [],
+        "batches": len(batches),
+        "batch_size": batch_size,
+    }
+
+    for batch in batches:
+        before = totals["failed"]
+        items = [
+            {
+                key: value
+                for key, value in record.items()
+                if key in {"text", "source", "metadata"}
+            }
+            for record in batch
+        ]
+        try:
+            response = api.bulk_add_memories({"items": items}) or {}
+        except Exception as error:  # noqa: BLE001 — reported, not raised
+            # The whole batch never reached the server, so every record in it is
+            # unaccounted for. Reported as a line range because that is what the
+            # operator needs to retry.
+            totals["failed"] += len(batch)
+            totals["failures"].append(
+                f"lines {batch[0]['line']}-{batch[-1]['line']}: {error}"
+            )
+            if not flags.get("continue_on_error"):
+                break
+            continue
 
-    stored, skipped = [], 0
-    for record in records:
-        created = api.add_memory(record)
-        memory = _normalize_memory(created)
-        if memory["id"]:
-            stored.append(memory["id"])
-        else:
-            skipped += 1
+        per_item = response.get("results") if isinstance(response, dict) else None
+        if not isinstance(per_item, list):
+            # The server accepted the batch without per-item detail. Counted as
+            # unreported rather than imported: claiming these were stored would
+            # be a guess, and a wrong one whenever the batch was not written.
+            totals["unreported"] += len(batch)
+            continue
+
+        for item in per_item:
+            index = item.get("index")
+            record = batch[index] if isinstance(index, int) and 0 <= index < len(batch) else None
+            where = f"line {record['line']}" if record else f"item {index}"
+            status = item.get("status")
+            if status == "created":
+                totals["imported"] += 1
+                totals["memory_ids"].extend(item.get("memory_ids") or [])
+            elif status == "skipped":
+                totals["skipped"] += 1
+            else:
+                totals["failed"] += 1
+                totals["failures"].append(f"{where}: {item.get('reason') or 'rejected'}")
+
+        if totals["failed"] > before and not flags.get("continue_on_error"):
+            break
 
     return {
-        "data": {"imported": stored, "count": len(stored), "skipped": skipped, "user": user},
+        "data": {"file": source_path, "user": user, **totals},
         "text": lambda: "\n".join(
-            [
-                f"{style.green('Imported')} {len(stored)} of {len(records)}",
-                style.dim(f"  {skipped} skipped as duplicate or low value") if skipped else "",
+            line
+            for line in [
+                f"{style.green('Imported')} {totals['imported']} of {totals['total']}",
+                style.dim(f"  {totals['skipped']} skipped as duplicate or low value")
+                if totals["skipped"]
+                else "",
+                style.dim(
+                    f"  {totals['unreported']} accepted without a per-record result"
+                )
+                if totals["unreported"]
+                else "",
+                style.red(f"  {totals['failed']} failed") if totals["failed"] else "",
+                *[style.dim(f"    {f}") for f in totals["failures"][:5]],
+                style.dim(f"    ... and {len(totals['failures']) - 5} more")
+                if len(totals["failures"]) > 5
+                else "",
             ]
-        ).strip(),
+            if line
+        ),
     }
 
 
+# Records the server accepts in one ``/memory/bulk-add`` request. The route
+# rejects a larger payload outright, so this is a ceiling and not a preference: a
+# higher ``--batch-size`` is clamped rather than sent and refused.
+SERVER_BULK_MAX = 50
+
+
+def _resolve_batch_size(flags: dict) -> int:
+    """Effective batch size for this run.
+
+    Defaults to the server maximum, which is what the flag documents. A value
+    above the maximum is clamped instead of rejected — batch size is a transport
+    detail, and failing a 10,000-row import because someone asked for 500 per
+    request would be pedantry. The effective value is reported back in the result
+    so the clamp is visible rather than silent.
+    """
+    requested = flags.get("batch_size")
+    if requested is None:
+        return SERVER_BULK_MAX
+    try:
+        value = int(str(requested).strip())
+    except (TypeError, ValueError):
+        value = 0
+    if value < 1:
+        raise usage_error(
+            "--batch-size must be a whole number of at least 1.",
+            f"Got {requested!r}. The server accepts at most "
+            f"{SERVER_BULK_MAX} records per request.",
+        )
+    return min(value, SERVER_BULK_MAX)
+
+
 def export_memories(ctx: dict) -> dict:
     user = _require_user(ctx)
     flags, api = ctx["flags"], ctx["api"]
@@ -608,12 +746,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.2.0}/src/memorysync_cli/http.py

@@ -368,6 +368,15 @@ class ApiClient:
         """
         return self.request("GET", "/evaluation/usage")
 
+    def bulk_add_memories(self, body: dict) -> Any:
+        """Ingest many records in one request.
+
+        Answers ``207`` with a per-item outcome for each record, so a batch is
+        routinely part success. The caller has to read ``results`` rather than
+        the status code to know what happened to any given record.
+        """
+        return self.request("POST", "/memory/bulk-add", body=body)
+
     def add_memory(self, body: dict) -> Any:
         return self.request("POST", "/memory/add", body=body)
 

{memorysync_cli-1.1.3 → memorysync_cli-1.2.0}/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.2.0}/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"