swarph-cli 0.13.2__tar.gz → 0.13.4__tar.gz

{swarph_cli-0.13.2/src/swarph_cli.egg-info → swarph_cli-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.13.2
+Version: 0.13.4
 Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.5: foolproof Windows auto-relaunch (genuine-WT detection via process ancestry, not WT_SESSION).
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.13.2 → swarph_cli-0.13.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.13.2"
+version = "0.13.4"
 description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.5: foolproof Windows auto-relaunch (genuine-WT detection via process ancestry, not WT_SESSION)."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.13.2 → swarph_cli-0.13.4}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.13.2"
+__version__ = "0.13.4"
 
 __all__ = ["__version__"]

{swarph_cli-0.13.2 → swarph_cli-0.13.4}/src/swarph_cli/commands/chat.py

@@ -35,7 +35,7 @@ import sys
 from dataclasses import dataclass, field
 from typing import Optional
 
-from swarph_cli.caller import default_caller
+from swarph_cli.caller import _sanitize_username, default_caller
 
 
 _BANNER = """\
@@ -123,13 +123,17 @@ def _default_repl_caller() -> str:
     """``cli.repl.<user>`` — distinct from ``cli.oneshot.<user>`` so
     attribution rows distinguish REPL turns from one-shot calls.
 
-    Falls back to the caller-convention default if env-derived user
-    extraction fails."""
+    Reuses ``caller._sanitize_username`` (the SAME sanitizer ``default_caller``
+    uses) so the slug is guaranteed convention-valid: leading letter (``u_``
+    prefix if not), collapsed underscores, ``unknown`` on empty. The previous
+    inline slug omitted those guards, so a leading-digit username produced a
+    non-conforming ``cli.repl.3bob`` that crashed SwarphCall at runtime (#83).
+    Falls back to the caller-convention default if env-derived user extraction
+    fails."""
     user = os.environ.get("USER") or os.environ.get("LOGNAME")
     if not user:
         return default_caller()
-    user_slug = "".join(c if c.isalnum() else "_" for c in user.lower())
-    return f"cli.repl.{user_slug}"
+    return f"cli.repl.{_sanitize_username(user)}"
 
 
 def _print(msg: str = "", *, file=None) -> None:

{swarph_cli-0.13.2 → swarph_cli-0.13.4}/src/swarph_cli/compress/levers.py

@@ -4,6 +4,12 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass
 
+# Caller tag for the shorthand model call. MUST satisfy swarph_shared's
+# caller convention (^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$ — dotted, not
+# hyphenated), or SwarphCall(...) raises ValueError at runtime. See
+# tests/test_compress_caller_convention.py.
+SHORTHAND_CALLER = "swarph.compress"
+
 
 @dataclass
 class ArchivalResult:
@@ -41,7 +47,7 @@ async def shorthand(source: str, *, system_prompt: str = SHORTHAND_SYSTEM, chat=
     (messages, system_prompt, **kw)->resp with .text; defaults to swarph_mesh."""
     if chat is None:
         from swarph_mesh import ChatMessage, SwarphCall
-        sc = SwarphCall(provider="claude", caller="swarph-compress")
+        sc = SwarphCall(provider="claude", caller=SHORTHAND_CALLER)
         async def chat(messages, system_prompt=None, **kw):
             return await sc.chat(messages=messages, system_prompt=system_prompt, **kw)
         msgs = [ChatMessage(role="user", content=source)]

{swarph_cli-0.13.2 → swarph_cli-0.13.4}/src/swarph_cli/compress/verify.py

@@ -4,6 +4,11 @@ from __future__ import annotations
 import gzip, re
 from pathlib import Path
 
+# Caller tag for the adversarial verify-expand model call. MUST satisfy
+# swarph_shared's dotted caller convention or SwarphCall raises at runtime.
+# See tests/test_compress_caller_convention.py.
+VERIFY_EXPAND_CALLER = "swarph.compress.verify"
+
 _LINK_RE = re.compile(r"\]\(([^)]+)\)")
 
 
@@ -67,7 +72,7 @@ async def verify_expand(source: str, compressed: str, *, chat=None) -> bool:
     fact in source not recoverable from compressed. One dropped fact -> False."""
     if chat is None:
         from swarph_mesh import ChatMessage, SwarphCall
-        sc = SwarphCall(provider="claude", caller="swarph-compress-verify")
+        sc = SwarphCall(provider="claude", caller=VERIFY_EXPAND_CALLER)
         async def chat(messages, system_prompt=None, **kw):
             return await sc.chat(messages=messages, system_prompt=system_prompt, **kw)
         msgs = [ChatMessage(role="user", content=f"ORIGINAL:\n{source}\n\nCOMPRESSED:\n{compressed}")]

{swarph_cli-0.13.2 → swarph_cli-0.13.4/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.13.2
+Version: 0.13.4
 Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.5: foolproof Windows auto-relaunch (genuine-WT detection via process ancestry, not WT_SESSION).
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.13.2 → swarph_cli-0.13.4}/src/swarph_cli.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ tests/test_artifact_mcp.py
 tests/test_artifact_skill.py
 tests/test_artifact_tool.py
 tests/test_artifact_uri.py
+tests/test_caller_meta_guard.py
 tests/test_capture_lineage.py
 tests/test_capture_liveness.py
 tests/test_capture_manifest.py
@@ -67,6 +68,7 @@ tests/test_cell_verify.py
 tests/test_chat_command.py
 tests/test_claude_parser.py
 tests/test_claude_tmux_template.py
+tests/test_compress_caller_convention.py
 tests/test_compress_command.py
 tests/test_compress_levers.py
 tests/test_compress_marker.py
@@ -90,6 +92,7 @@ tests/test_mesh_sidecar.py
 tests/test_onboard_command.py
 tests/test_protocol_handler.py
 tests/test_ratify_command.py
+tests/test_repl_caller_convention.py
 tests/test_security.py
 tests/test_session_path_role_gate.py
 tests/test_smoke_chat.py
@@ -100,6 +103,7 @@ tests/test_spawn_live_pin.py
 tests/test_spawn_mitosis_lineage.py
 tests/test_spawn_tmux_session.py
 tests/test_spawn_windows_relaunch.py
+tests/test_version_consistency.py
 tests/test_watchdog.py
 tests/test_watchdog_dm_wake.py
 tests/test_watchdog_dm_wake_cooldown.py

swarph_cli-0.13.4/tests/test_caller_meta_guard.py

@@ -0,0 +1,117 @@
+"""Repo-wide caller-convention meta-guard (issue #81).
+
+The #80 bug: a hyphenated caller tag (`swarph-compress`) was silently dead at
+runtime because it fails swarph_shared's dotted `role.subrole` convention — and it
+was masked because the levers/verify tests injected a fake chat and never built a
+real SwarphCall. That fix added a per-caller regression test for the two compress
+callers. THIS guard generalizes it: it discovers EVERY static caller tag across the
+whole `swarph_cli` package by import-introspection and validates each, so the bug
+class can't be re-introduced in ANY module without someone remembering to add a
+per-caller test.
+
+Design (converged lab+droplet, #81): import-introspection, not AST literal-walking.
+The callers live in named `*_CALLER` constants — `caller=SHORTHAND_CALLER` is an
+ast.Name, not a literal, so a naive literal-walk would miss exactly the callers #80
+hardened. Introspection resolves the value for free and nudges the light convention
+that caller tags live in discoverable `*_CALLER` constants.
+
+NOT covered here (separate follow-up, flagged in the PR): the DYNAMIC default-caller
+producers (`default_caller` / `_default_repl_caller`) do not guarantee an
+[a-z]-leading slug, so a leading-digit/empty OS username yields a non-conforming
+`cli.repl.<digit...>` tag — a real robustness bug in the sanitizers, out of scope
+for this static meta-guard.
+"""
+import importlib
+import pkgutil
+
+import swarph_cli
+from swarph_shared.caller_convention import validate_caller
+
+
+def _iter_caller_constants():
+    """Yield (module, attr, value) for every module-level ``*_CALLER`` str constant
+    across the swarph_cli package. Walks the package so a NEW module's caller
+    constant is covered automatically. A submodule that can't be imported in this
+    env (e.g. an optional dep) is skipped — importability is other tests' concern,
+    not this guard's."""
+    for mod in pkgutil.walk_packages(swarph_cli.__path__, swarph_cli.__name__ + "."):
+        try:
+            m = importlib.import_module(mod.name)
+        except Exception:
+            continue
+        for attr in dir(m):
+            if attr.endswith("_CALLER"):
+                val = getattr(m, attr, None)
+                if isinstance(val, str):
+                    yield mod.name, attr, val
+
+
+def test_all_caller_constants_conform():
+    """Every ``*_CALLER`` constant in the package satisfies the dotted convention."""
+    found = list(_iter_caller_constants())
+    # Sanity: the compress callers from #80 must be discovered, else the walk is broken
+    # (e.g. swarph_cli resolving to a stale install rather than this tree).
+    names = {f"{m.rsplit('.', 1)[-1]}.{a}" for m, a, _ in found}
+    assert "levers.SHORTHAND_CALLER" in names and "verify.VERIFY_EXPAND_CALLER" in names, (
+        f"meta-guard didn't discover the known compress callers; found: {sorted(names)}")
+    for modname, attr, val in found:
+        try:
+            validate_caller(val)
+        except ValueError as e:
+            raise AssertionError(
+                f"caller constant {modname}.{attr} = {val!r} violates the convention "
+                f"(dotted role.subrole) — would crash SwarphCall at runtime: {e}")
+
+
+def test_default_caller_producers_conform_happy_path(monkeypatch):
+    """The default-caller producers emit a conforming tag for a normal username.
+    Username is injected so this is deterministic regardless of the CI runner's
+    real user (the adversarial leading-digit case is a flagged follow-up, not here)."""
+    monkeypatch.setenv("USER", "alice")
+    monkeypatch.setenv("LOGNAME", "alice")
+    from swarph_cli.main import default_caller
+    from swarph_cli.commands.chat import _default_repl_caller
+    for fn in (default_caller, _default_repl_caller):
+        val = fn()
+        try:
+            validate_caller(val)
+        except ValueError as e:
+            raise AssertionError(
+                f"{fn.__module__}.{fn.__name__}() -> {val!r} violates the convention: {e}")
+
+
+def test_guard_catches_a_planted_bad_caller(monkeypatch):
+    """PIN the catch-property — a guard's catch must be COMMITTED, not remembered
+    (the very #80 lesson this PR generalizes; droplet review). Plant a hyphenated
+    `*_CALLER` on a real, discovered module and assert the guard both DISCOVERS it
+    and REJECTS it. monkeypatch auto-removes the plant so the real guard test stays
+    clean regardless of order."""
+    import pytest
+
+    import swarph_cli.compress.levers as lev
+    monkeypatch.setattr(lev, "PLANTED_BAD_CALLER", "swarph-bad-hyphen", raising=False)
+
+    # 1) introspection DISCOVERS the planted constant
+    found = {f"{m}.{a}": v for m, a, v in _iter_caller_constants()}
+    assert found.get("swarph_cli.compress.levers.PLANTED_BAD_CALLER") == "swarph-bad-hyphen", (
+        "the walk failed to discover a planted *_CALLER — discovery is broken")
+
+    # 2) the guard CATCHES it (fails loud, names the offending constant)
+    with pytest.raises(AssertionError, match="violates the convention"):
+        test_all_caller_constants_conform()
+
+
+def test_no_modules_skipped_by_the_walk():
+    """The guard resiliently SKIPS an unimportable submodule (so an unrelated optional-
+    dep import error can't break it) — but a silent skip could hide a bad caller in a
+    module that's importable in prod yet not in this env. Assert NONE are skipped here,
+    so the walk is exhaustive; if this ever fails in CI, run with full extras."""
+    skipped = []
+    for mod in pkgutil.walk_packages(swarph_cli.__path__, swarph_cli.__name__ + "."):
+        try:
+            importlib.import_module(mod.name)
+        except Exception as e:  # noqa: BLE001 — we want to surface ANY import failure
+            skipped.append((mod.name, repr(e)))
+    assert not skipped, (
+        f"caller meta-guard walk skipped modules (a bad caller in one could ship "
+        f"uncaught): {skipped}")

swarph_cli-0.13.4/tests/test_compress_caller_convention.py

@@ -0,0 +1,21 @@
+"""Regression: the compress model-call caller tags MUST satisfy swarph_shared's
+caller convention (dotted `role.subrole`, not hyphenated). The existing
+levers/verify tests inject a fake `chat` and never construct a real SwarphCall,
+so they passed while the production path crashed at SwarphCall(...) on a
+hyphenated caller ('swarph-compress'). This test checks the tags directly so
+the break can't silently regress again."""
+from swarph_shared.caller_convention import validate_caller
+
+from swarph_cli.compress.levers import SHORTHAND_CALLER
+from swarph_cli.compress.verify import VERIFY_EXPAND_CALLER
+
+
+def test_shorthand_caller_matches_convention():
+    # raises ValueError if it doesn't match ^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$
+    validate_caller(SHORTHAND_CALLER)
+    assert SHORTHAND_CALLER == "swarph.compress"
+
+
+def test_verify_expand_caller_matches_convention():
+    validate_caller(VERIFY_EXPAND_CALLER)
+    assert VERIFY_EXPAND_CALLER == "swarph.compress.verify"

swarph_cli-0.13.4/tests/test_repl_caller_convention.py

@@ -0,0 +1,43 @@
+"""Regression (#83): `_default_repl_caller` must emit a convention-valid caller for
+ANY OS username — including the adversarial cases the old inline slug logic broke on.
+
+#80 fixed a hyphenated STATIC caller constant. This is the same crash-class on the
+DYNAMIC repl-default path: `_default_repl_caller` rolled its own slug
+(`"".join(c if c.isalnum() else "_" ...)`) that — unlike `caller._sanitize_username`
+which `default_caller` uses — did NOT guarantee a leading letter, collapse underscores,
+or fall back on empty. So a leading-digit username produced `cli.repl.3bob`, which
+fails `^[a-z][a-z0-9_]*(\\.[a-z][a-z0-9_]*)+$` and would crash SwarphCall at runtime.
+Fix: reuse `_sanitize_username` (single sanitizer, no divergence).
+"""
+import pytest
+
+from swarph_shared.caller_convention import validate_caller
+
+from swarph_cli.commands.chat import _default_repl_caller
+
+
+@pytest.mark.parametrize("username", [
+    "3bob",      # leading digit — the reported crash
+    "9",         # all-digit
+    "!!!",       # all-special -> empty slug -> must fall back, not emit `cli.repl.`
+    "ALICE",     # uppercase
+    "bob.smith", # dot (would otherwise split the segment)
+    "a-b-c",     # hyphens (the #80 char)
+    "_",         # underscore-only -> empty after strip
+    "  ",        # whitespace-only
+])
+def test_repl_caller_conforms_for_adversarial_usernames(monkeypatch, username):
+    """The repl default caller validates clean for every adversarial username."""
+    monkeypatch.setenv("USER", username)
+    monkeypatch.delenv("LOGNAME", raising=False)
+    # raises ValueError if the produced tag violates the convention
+    validate_caller(_default_repl_caller())
+
+
+def test_repl_caller_stays_distinct_from_oneshot(monkeypatch):
+    """Still `cli.repl.*` (not `cli.oneshot.*`) — the separate producer exists so
+    attribution distinguishes REPL turns from one-shot calls; the fix must not
+    collapse them."""
+    monkeypatch.setenv("USER", "alice")
+    monkeypatch.delenv("LOGNAME", raising=False)
+    assert _default_repl_caller().startswith("cli.repl.")

swarph_cli-0.13.4/tests/test_version_consistency.py

@@ -0,0 +1,26 @@
+"""Guard against the 0.13.3 bug class: the __version__ constant in
+src/swarph_cli/__init__.py drifting from the pyproject version (0.13.3 shipped
+with the constant left at 0.13.2, so `swarph --version` misreported). Reads both
+straight from the source tree so it validates what will be built, independent of
+whatever is pip-installed in the test env."""
+import pathlib
+import re
+
+
+def _read_version(text: str, pattern: str) -> str:
+    m = re.search(pattern, text, re.MULTILINE)
+    assert m, f"version not found via {pattern!r}"
+    return m.group(1)
+
+
+def test_version_constant_matches_pyproject():
+    root = pathlib.Path(__file__).resolve().parent.parent
+    pyproject_version = _read_version(
+        (root / "pyproject.toml").read_text(), r'^version\s*=\s*"([^"]+)"')
+    init_version = _read_version(
+        (root / "src" / "swarph_cli" / "__init__.py").read_text(),
+        r'^__version__\s*=\s*"([^"]+)"')
+    assert init_version == pyproject_version, (
+        f"src/swarph_cli/__init__.py __version__={init_version!r} but pyproject "
+        f"version={pyproject_version!r}. Bump BOTH on every release."
+    )