memorysync-cli 1.6.0__py3-none-any.whl → 1.6.1__py3-none-any.whl

memorysync_cli/__init__.py

@@ -1,13 +1,13 @@
-"""MemorySync command-line interface.
-
-A Python implementation of the same CLI as the npm package ``memorysync-cli``,
-with the same commands, flags, output formats and exit codes. The two are
-interchangeable: whichever is on PATH behaves identically, so you only need one.
-
-Both read their command surface from one generated declaration, so ``help --json``
-is byte-identical between them rather than kept aligned by review.
-"""
-
-from ._version import __version__
-
-__all__ = ["__version__"]
+"""MemorySync command-line interface.
+
+A Python implementation of the same CLI as the npm package ``memorysync-cli``,
+with the same commands, flags, output formats and exit codes. The two are
+interchangeable: whichever is on PATH behaves identically, so you only need one.
+
+Both read their command surface from one generated declaration, so ``help --json``
+is byte-identical between them rather than kept aligned by review.
+"""
+
+from ._version import __version__
+
+__all__ = ["__version__"]

memorysync_cli/__main__.py

@@ -1,9 +1,9 @@
-"""Allow ``python -m memorysync_cli`` alongside the installed console scripts.
-
-Useful during development and in environments where a wheel's scripts directory is
-not on PATH, which is common inside CI containers.
-"""
-
-from .main import run
-
-run()
+"""Allow ``python -m memorysync_cli`` alongside the installed console scripts.
+
+Useful during development and in environments where a wheel's scripts directory is
+not on PATH, which is common inside CI containers.
+"""
+
+from .main import run
+
+run()

memorysync_cli/_version.py

@@ -1 +1 @@
-__version__ = "1.6.0"
+__version__ = "1.6.1"

memorysync_cli/args.py

@@ -1,231 +1,231 @@
-"""Argument parsing.
-
-Hand-rolled rather than using argparse, and deliberately so.
-
-The grammar is small, but it has to match the Node CLI token for token, because
-the two CLIs are interchangeable and a script must not behave differently
-depending on which one is on PATH. argparse has its own opinions - about prefix
-matching, about how it reports errors, about exiting with code 2 on its own terms
-- and bending it into agreement would be more work than owning ninety lines.
-
-Owning it also means `--help`, `help --json` and the completion scripts all come
-from the shared registry rather than from a library's internal state, which is how
-they stay consistent with what the parser actually accepts.
-
-The grammar, matching ``sdk/cli/src/args.mjs``:
-
-    --flag value   --flag=value   -f value   -f=value   --no-flag
-    Bundled booleans: -qv. A valued short flag may only come last, as in getopt.
-    Everything after ``--`` is positional, so text containing dashes survives.
-    Unknown flags are refused, never ignored.
-
-That last rule earns its keep: silently dropping a misspelled ``--user`` would
-scope memory to the wrong person, and the caller would not find out.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from . import registry
-from .errors import usage_error
-
-
-def _collect_valued() -> set[str]:
-    """Flags that take a value. Everything else is boolean.
-
-    Derived from the shared registry rather than hand-listed, matching
-    ``sdk/cli/src/args.mjs``. The registry already marks a value-taking flag with
-    ``value``, and keeping a second copy of that fact here meant the two could
-    disagree - which they did: ``--email``, ``--code``, ``--password`` and
-    ``--agent-caller`` were declared with a ``value`` but missing from the set, so
-    ``--email you@example.com`` parsed as ``{"email": True}`` and sent the string
-    "true" to the API. ``--password`` was worse: the account password became
-    "true" and the real one was left in shell history as a positional.
-
-    A flag is valued if any declaration of it says so, including on a subcommand.
-    """
-    valued: set[str] = set()
-
-    def visit(flags: list[dict[str, Any]] | None) -> None:
-        for flag in flags or []:
-            if flag.get("value"):
-                valued.add(flag["name"].lstrip("-"))
-
-    visit(registry.global_flags())
-    for spec in registry.commands().values():
-        visit(spec.get("flags"))
-        for sub in spec.get("subcommands", []):
-            visit(sub.get("flags"))
-    return valued
-
-
-VALUED = _collect_valued()
-
-SHORT = {
-    "p": "profile",
-    "u": "user",
-    "o": "output",
-    "y": "yes",
-    "q": "quiet",
-    "v": "verbose",
-    "h": "help",
-    "m": "metadata",
-    "f": "file",
-    "k": "limit",
-}
-
-
-def _key(name: str) -> str:
-    """Flag name to dict key.
-
-    ``--dry-run`` becomes ``dry_run``. The Node CLI uses ``dryRun``; the surface
-    both expose is the flag itself, so each side reads naturally in its own
-    language. Only the command-line spelling has to agree.
-    """
-    return name.replace("-", "_")
-
-
-def parse_args(argv: list[str]) -> tuple[list[str], dict[str, Any]]:
-    """Split argv into positionals and flags.
-
-    Returns them separately rather than as one namespace so the dispatcher can
-    tell ``memorysync add --user x`` from ``memorysync --user x add`` without
-    re-parsing.
-    """
-    positionals: list[str] = []
-    flags: dict[str, Any] = {}
-    passthrough = False
-
-    index = 0
-    while index < len(argv):
-        token = argv[index]
-
-        if passthrough:
-            positionals.append(token)
-            index += 1
-            continue
-
-        if token == "--":
-            passthrough = True
-            index += 1
-            continue
-
-        if token.startswith("--"):
-            name = token[2:]
-            value: str | None = None
-
-            if "=" in name:
-                name, _, value = name.partition("=")
-
-            if name.startswith("no-") and value is None:
-                positive = name[3:]
-                if positive in VALUED:
-                    raise usage_error(
-                        f"--{name} is not a flag. --{positive} takes a value."
-                    )
-                flags[_key(positive)] = False
-                index += 1
-                continue
-
-            if name in VALUED:
-                if value is None:
-                    following = argv[index + 1] if index + 1 < len(argv) else None
-                    if following is None or following.startswith("-"):
-                        raise usage_error(f"--{name} needs a value.")
-                    value = following
-                    index += 1
-                flags[_key(name)] = value
-                index += 1
-                continue
-
-            if value is not None:
-                # `--verbose=true` is accepted so a script generating flags
-                # programmatically does not have to special-case booleans.
-                flags[_key(name)] = value not in {"false", "0"}
-                index += 1
-                continue
-
-            flags[_key(name)] = True
-            index += 1
-            continue
-
-        if len(token) > 1 and token.startswith("-"):
-            body = token[1:]
-            letters, _, inline = body.partition("=")
-            has_inline = "=" in body
-
-            for position, letter in enumerate(letters):
-                long = SHORT.get(letter)
-                if long is None:
-                    raise usage_error(f"Unknown flag -{letter}.")
-
-                is_last = position == len(letters) - 1
-
-                if long in VALUED:
-                    if not is_last:
-                        raise usage_error(
-                            f"-{letter} takes a value, so it must come last in -{letters}."
-                        )
-                    if has_inline:
-                        value = inline
-                    else:
-                        following = argv[index + 1] if index + 1 < len(argv) else None
-                        if following is None or following.startswith("-"):
-                            raise usage_error(f"-{letter} needs a value.")
-                        value = following
-                        index += 1
-                    if value == "":
-                        raise usage_error(f"-{letter} needs a value.")
-                    flags[_key(long)] = value
-                else:
-                    flags[_key(long)] = True
-
-            index += 1
-            continue
-
-        positionals.append(token)
-        index += 1
-
-    return positionals, flags
-
-
-def levenshtein(left: str, right: str) -> int:
-    """Edit distance, for "did you mean". Inputs are command names, so the naive
-    row-by-row version is more than fast enough."""
-    if left == right:
-        return 0
-    if not left:
-        return len(right)
-    if not right:
-        return len(left)
-
-    previous = list(range(len(right) + 1))
-    for i, lc in enumerate(left, start=1):
-        current = [i]
-        for j, rc in enumerate(right, start=1):
-            current.append(
-                min(
-                    previous[j] + 1,
-                    current[j - 1] + 1,
-                    previous[j - 1] + (0 if lc == rc else 1),
-                )
-            )
-        previous = current
-    return previous[-1]
-
-
-def suggest(unknown: str, candidates: list[str]) -> str | None:
-    """Closest candidate, when one is close enough to be worth offering.
-
-    A third of the length is the threshold: close enough to catch a typo, far
-    enough that ``memorysync foo`` is not answered with a confident wrong guess.
-    """
-    best, best_distance = None, None
-    for candidate in candidates:
-        distance = levenshtein(unknown, candidate)
-        if best_distance is None or distance < best_distance:
-            best, best_distance = candidate, distance
-    if best is None or best_distance is None:
-        return None
-    return best if best_distance <= max(1, len(unknown) // 3) else None
+"""Argument parsing.
+
+Hand-rolled rather than using argparse, and deliberately so.
+
+The grammar is small, but it has to match the Node CLI token for token, because
+the two CLIs are interchangeable and a script must not behave differently
+depending on which one is on PATH. argparse has its own opinions - about prefix
+matching, about how it reports errors, about exiting with code 2 on its own terms
+- and bending it into agreement would be more work than owning ninety lines.
+
+Owning it also means `--help`, `help --json` and the completion scripts all come
+from the shared registry rather than from a library's internal state, which is how
+they stay consistent with what the parser actually accepts.
+
+The grammar, matching ``sdk/cli/src/args.mjs``:
+
+    --flag value   --flag=value   -f value   -f=value   --no-flag
+    Bundled booleans: -qv. A valued short flag may only come last, as in getopt.
+    Everything after ``--`` is positional, so text containing dashes survives.
+    Unknown flags are refused, never ignored.
+
+That last rule earns its keep: silently dropping a misspelled ``--user`` would
+scope memory to the wrong person, and the caller would not find out.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from . import registry
+from .errors import usage_error
+
+
+def _collect_valued() -> set[str]:
+    """Flags that take a value. Everything else is boolean.
+
+    Derived from the shared registry rather than hand-listed, matching
+    ``sdk/cli/src/args.mjs``. The registry already marks a value-taking flag with
+    ``value``, and keeping a second copy of that fact here meant the two could
+    disagree - which they did: ``--email``, ``--code``, ``--password`` and
+    ``--agent-caller`` were declared with a ``value`` but missing from the set, so
+    ``--email you@example.com`` parsed as ``{"email": True}`` and sent the string
+    "true" to the API. ``--password`` was worse: the account password became
+    "true" and the real one was left in shell history as a positional.
+
+    A flag is valued if any declaration of it says so, including on a subcommand.
+    """
+    valued: set[str] = set()
+
+    def visit(flags: list[dict[str, Any]] | None) -> None:
+        for flag in flags or []:
+            if flag.get("value"):
+                valued.add(flag["name"].lstrip("-"))
+
+    visit(registry.global_flags())
+    for spec in registry.commands().values():
+        visit(spec.get("flags"))
+        for sub in spec.get("subcommands", []):
+            visit(sub.get("flags"))
+    return valued
+
+
+VALUED = _collect_valued()
+
+SHORT = {
+    "p": "profile",
+    "u": "user",
+    "o": "output",
+    "y": "yes",
+    "q": "quiet",
+    "v": "verbose",
+    "h": "help",
+    "m": "metadata",
+    "f": "file",
+    "k": "limit",
+}
+
+
+def _key(name: str) -> str:
+    """Flag name to dict key.
+
+    ``--dry-run`` becomes ``dry_run``. The Node CLI uses ``dryRun``; the surface
+    both expose is the flag itself, so each side reads naturally in its own
+    language. Only the command-line spelling has to agree.
+    """
+    return name.replace("-", "_")
+
+
+def parse_args(argv: list[str]) -> tuple[list[str], dict[str, Any]]:
+    """Split argv into positionals and flags.
+
+    Returns them separately rather than as one namespace so the dispatcher can
+    tell ``memorysync add --user x`` from ``memorysync --user x add`` without
+    re-parsing.
+    """
+    positionals: list[str] = []
+    flags: dict[str, Any] = {}
+    passthrough = False
+
+    index = 0
+    while index < len(argv):
+        token = argv[index]
+
+        if passthrough:
+            positionals.append(token)
+            index += 1
+            continue
+
+        if token == "--":
+            passthrough = True
+            index += 1
+            continue
+
+        if token.startswith("--"):
+            name = token[2:]
+            value: str | None = None
+
+            if "=" in name:
+                name, _, value = name.partition("=")
+
+            if name.startswith("no-") and value is None:
+                positive = name[3:]
+                if positive in VALUED:
+                    raise usage_error(
+                        f"--{name} is not a flag. --{positive} takes a value."
+                    )
+                flags[_key(positive)] = False
+                index += 1
+                continue
+
+            if name in VALUED:
+                if value is None:
+                    following = argv[index + 1] if index + 1 < len(argv) else None
+                    if following is None or following.startswith("-"):
+                        raise usage_error(f"--{name} needs a value.")
+                    value = following
+                    index += 1
+                flags[_key(name)] = value
+                index += 1
+                continue
+
+            if value is not None:
+                # `--verbose=true` is accepted so a script generating flags
+                # programmatically does not have to special-case booleans.
+                flags[_key(name)] = value not in {"false", "0"}
+                index += 1
+                continue
+
+            flags[_key(name)] = True
+            index += 1
+            continue
+
+        if len(token) > 1 and token.startswith("-"):
+            body = token[1:]
+            letters, _, inline = body.partition("=")
+            has_inline = "=" in body
+
+            for position, letter in enumerate(letters):
+                long = SHORT.get(letter)
+                if long is None:
+                    raise usage_error(f"Unknown flag -{letter}.")
+
+                is_last = position == len(letters) - 1
+
+                if long in VALUED:
+                    if not is_last:
+                        raise usage_error(
+                            f"-{letter} takes a value, so it must come last in -{letters}."
+                        )
+                    if has_inline:
+                        value = inline
+                    else:
+                        following = argv[index + 1] if index + 1 < len(argv) else None
+                        if following is None or following.startswith("-"):
+                            raise usage_error(f"-{letter} needs a value.")
+                        value = following
+                        index += 1
+                    if value == "":
+                        raise usage_error(f"-{letter} needs a value.")
+                    flags[_key(long)] = value
+                else:
+                    flags[_key(long)] = True
+
+            index += 1
+            continue
+
+        positionals.append(token)
+        index += 1
+
+    return positionals, flags
+
+
+def levenshtein(left: str, right: str) -> int:
+    """Edit distance, for "did you mean". Inputs are command names, so the naive
+    row-by-row version is more than fast enough."""
+    if left == right:
+        return 0
+    if not left:
+        return len(right)
+    if not right:
+        return len(left)
+
+    previous = list(range(len(right) + 1))
+    for i, lc in enumerate(left, start=1):
+        current = [i]
+        for j, rc in enumerate(right, start=1):
+            current.append(
+                min(
+                    previous[j] + 1,
+                    current[j - 1] + 1,
+                    previous[j - 1] + (0 if lc == rc else 1),
+                )
+            )
+        previous = current
+    return previous[-1]
+
+
+def suggest(unknown: str, candidates: list[str]) -> str | None:
+    """Closest candidate, when one is close enough to be worth offering.
+
+    A third of the length is the threshold: close enough to catch a typo, far
+    enough that ``memorysync foo`` is not answered with a confident wrong guess.
+    """
+    best, best_distance = None, None
+    for candidate in candidates:
+        distance = levenshtein(unknown, candidate)
+        if best_distance is None or distance < best_distance:
+            best, best_distance = candidate, distance
+    if best is None or best_distance is None:
+        return None
+    return best if best_distance <= max(1, len(unknown) // 3) else None

memorysync_cli/commands/__init__.py

@@ -1,6 +1,6 @@
-"""Command implementations, grouped the same way the Node CLI groups them.
-
-The split mirrors ``sdk/cli/src/commands/`` file for file - memory, admin, init,
-source, tooling - so that a change on one side has an obvious counterpart on the
-other. Parity is easier to keep when the two trees look alike in review.
-"""
+"""Command implementations, grouped the same way the Node CLI groups them.
+
+The split mirrors ``sdk/cli/src/commands/`` file for file - memory, admin, init,
+source, tooling - so that a change on one side has an obvious counterpart on the
+other. Parity is easier to keep when the two trees look alike in review.
+"""