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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memorysync-cli
-Version: 1.1.4
+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.4 → memorysync_cli-1.2.0}/src/memorysync_cli/commands/memory.py

@@ -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"]

{memorysync_cli-1.1.4 → 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.4/src/memorysync_cli/_version.py

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