swarph-cli 0.26.0__tar.gz → 0.27.0__tar.gz

{swarph_cli-0.26.0/src/swarph_cli.egg-info → swarph_cli-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.26.0
+Version: 0.27.0
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.26.0 → swarph_cli-0.27.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.26.0"
+version = "0.27.0"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.26.0 → swarph_cli-0.27.0}/src/swarph_cli/__init__.py

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

{swarph_cli-0.26.0 → swarph_cli-0.27.0}/src/swarph_cli/commands/highlight.py

@@ -27,9 +27,54 @@ import sys
 from datetime import datetime, timezone
 from pathlib import Path
 
+from swarph_cli.commands.mesh import _post_json, _resolve_token
+
 _PUSH_RETRIES = 8
 
 
+def _resolve_gateway(arg: str | None) -> str:
+    """Gateway base URL for the peer-token ingest path. Reuses the mesh-wide
+    SWARPH_BRAIN_GATEWAY (already set on every cell from the brain-ask rollout)
+    as the final fallback, so `swarph highlight` goes peer-token-by-default with
+    ZERO new per-cell config. `--gateway` / `--local` override."""
+    return (arg
+            or os.environ.get("SWARPH_HIGHLIGHT_GATEWAY")
+            or os.environ.get("SWARPH_GATEWAY")
+            or os.environ.get("SWARPH_BRAIN_GATEWAY")
+            or "").strip()
+
+
+def _log_via_gateway(gateway: str, cell: str, highlight: str,
+                     memory: str, when: str, token_file: str | None) -> int:
+    """POST the highlight to the gateway `/highlights` — the gateway holds the git
+    push credential, so the cell needs only its mesh peer token (no GitHub PAT).
+    Fail-loud: a non-200 or connection error returns 1 (never a silent git double-write)."""
+    url = gateway.rstrip("/") + "/highlights"
+    body: dict = {"highlight": highlight, "cell": cell}
+    if memory:
+        body["memory"] = memory
+    if when:
+        body["when"] = when
+    try:
+        token = _resolve_token(cell, token_file)
+    except RuntimeError as exc:
+        print(f"swarph highlight: {exc}", file=sys.stderr)
+        return 1
+    status, resp = _post_json(url, body, token)
+    if status == 200:
+        ts = resp.get("ts", "")
+        print(f"logged -> TIMELINE.md @ {ts} (via gateway)"
+              + (f" -> {memory}" if memory else ""))
+        if resp.get("pushed") is False:
+            print("swarph highlight: committed at the gateway but NOT yet pushed "
+                  "(converges on a later push)", file=sys.stderr)
+        return 0
+    detail = resp.get("detail") if isinstance(resp, dict) else resp
+    where = f"HTTP {status}" if status else "connection failed"
+    print(f"swarph highlight: gateway POST failed ({where}): {detail}", file=sys.stderr)
+    return 1
+
+
 def _collapse(s: str) -> str:
     """One-line invariant — an embedded newline can't forge a second
     attributed entry."""
@@ -120,14 +165,31 @@ def run_highlight(argv: list) -> int:
                    help="ISO8601 event time for a backfilled highlight; default now")
     p.add_argument("--no-push", action="store_true",
                    help="commit locally only, never push")
+    p.add_argument("--gateway", default=None,
+                   help="gateway base URL for the peer-token ingest path "
+                   "(else SWARPH_HIGHLIGHT_GATEWAY / SWARPH_GATEWAY / SWARPH_BRAIN_GATEWAY)")
+    p.add_argument("--token-file", default=None,
+                   help="explicit bearer token file (else MESH_GATEWAY_TOKEN / peer-token)")
+    p.add_argument("--local", action="store_true",
+                   help="force the local git path even if a gateway is configured")
     args = p.parse_args(argv)
 
     repo = _resolve_dir(args.timeline_dir)
     cell = _resolve_cell(args.cell, repo)
-    _ensure_timeline(repo, cell)
-    ts = _collapse(args.when) if args.when else _now_ts()
     highlight = _collapse(args.highlight)
     memory = _collapse(args.memory)
+    when = _collapse(args.when) if args.when else ""
+
+    # Peer-token path (default when a gateway is configured): the gateway holds the
+    # git credential, so a cell logs with only its mesh peer token — no GitHub PAT.
+    # `--local` forces the legacy git path; with no gateway configured it's the git
+    # path too, so existing solo/offline timelines are unaffected.
+    gateway = "" if args.local else _resolve_gateway(args.gateway)
+    if gateway:
+        return _log_via_gateway(gateway, cell, highlight, memory, when, args.token_file)
+
+    _ensure_timeline(repo, cell)
+    ts = when or _now_ts()
     branch = _current_branch(repo)
     pushing = (not args.no_push) and _has_remote(repo)
 

{swarph_cli-0.26.0 → swarph_cli-0.27.0/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.26.0
+Version: 0.27.0
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.26.0 → swarph_cli-0.27.0}/tests/test_brain_ask_command.py

@@ -15,9 +15,9 @@ from swarph_cli.commands import brain_ask as ba
 
 # --- version ---------------------------------------------------------------
 
-def test_version_is_0_26_0():
+def test_version_is_0_27_0():
     import swarph_cli
-    assert swarph_cli.__version__ == "0.26.0"
+    assert swarph_cli.__version__ == "0.27.0"
 
 
 # --- request / response plumbing -------------------------------------------

swarph_cli-0.27.0/tests/test_highlight_command.py

@@ -0,0 +1,140 @@
+"""Tests for ``swarph highlight`` — append to a git-backed timeline.
+
+Offline: each test uses a fresh temp timeline dir with no remote (``--no-push``),
+so the real git mechanics run (init + append + commit) without a network.
+"""
+
+from __future__ import annotations
+
+import subprocess
+
+import pytest
+
+from swarph_cli.commands import highlight as hl
+
+
+@pytest.fixture(autouse=True)
+def _no_ambient_gateway(monkeypatch):
+    """Isolate git-path tests: clear any gateway env so a developer/CI with
+    SWARPH_BRAIN_GATEWAY set doesn't silently flip these into the gateway path.
+    Gateway tests set the env explicitly."""
+    for v in ("SWARPH_HIGHLIGHT_GATEWAY", "SWARPH_GATEWAY", "SWARPH_BRAIN_GATEWAY"):
+        monkeypatch.delenv(v, raising=False)
+
+
+# --- pure helpers ----------------------------------------------------------
+
+def test_collapse_newlines():
+    assert hl._collapse("a\nb\rc") == "a b c"
+
+
+def test_format_line_with_memory():
+    line = hl._format_line("2026-06-27T00:00Z", "lab-ovh", "shipped X", "[[mem-x]]")
+    assert line == "- 2026-06-27T00:00Z · **lab-ovh** · shipped X · → [[mem-x]]"
+
+
+def test_format_line_without_memory():
+    line = hl._format_line("2026-06-27T00:00Z", "lab-ovh", "shipped X", "")
+    assert line == "- 2026-06-27T00:00Z · **lab-ovh** · shipped X"
+
+
+# --- the verb (real git, no remote) ----------------------------------------
+
+def test_highlight_inits_appends_commits(tmp_path, monkeypatch):
+    d = tmp_path / "tl"
+    monkeypatch.setenv("SWARPH_TIMELINE_DIR", str(d))
+    monkeypatch.setenv("SWARPH_CELL", "test-cell")
+    rc = hl.run_highlight(["my highlight", "[[mem-x]]", "--no-push"])
+    assert rc == 0
+    tl = (d / "TIMELINE.md").read_text(encoding="utf-8")
+    assert "**test-cell**" in tl and "my highlight" in tl and "→ [[mem-x]]" in tl
+    log = subprocess.run(["git", "-C", str(d), "log", "--oneline"],
+                         capture_output=True, text=True).stdout
+    assert "highlight" in log.lower()
+    # union-merge attribute set so concurrent cell appends auto-merge
+    assert "merge=union" in (d / ".gitattributes").read_text(encoding="utf-8")
+
+
+def test_highlight_collapses_multiline_anti_spoof(tmp_path, monkeypatch):
+    d = tmp_path / "tl"
+    monkeypatch.setenv("SWARPH_TIMELINE_DIR", str(d))
+    monkeypatch.setenv("SWARPH_CELL", "c")
+    rc = hl.run_highlight(["line one\nFORGED **other** entry", "--no-push"])
+    assert rc == 0
+    entry_lines = [l for l in (d / "TIMELINE.md").read_text(encoding="utf-8").splitlines()
+                   if l.startswith("- ")]
+    assert len(entry_lines) == 1  # the newline can't forge a second attributed entry
+    assert "line one FORGED" in entry_lines[0]
+
+
+def test_highlight_second_append_keeps_both(tmp_path, monkeypatch):
+    d = tmp_path / "tl"
+    monkeypatch.setenv("SWARPH_TIMELINE_DIR", str(d))
+    monkeypatch.setenv("SWARPH_CELL", "c")
+    hl.run_highlight(["first", "--no-push"])
+    hl.run_highlight(["second", "--no-push"])
+    entry_lines = [l for l in (d / "TIMELINE.md").read_text(encoding="utf-8").splitlines()
+                   if l.startswith("- ")]
+    assert len(entry_lines) == 2
+
+
+# --- gateway (peer-token) path ---------------------------------------------
+
+def _fake_post(capture, status=200, resp=None):
+    """Return a _post_json stand-in that records the call + returns a fixed reply."""
+    def _p(url, body, token, **kw):
+        capture.update(url=url, body=body, token=token)
+        return status, (resp if resp is not None else
+                        {"logged": True, "cell": body.get("cell"), "ts": "2026-01-01T00:00Z",
+                         "line": "x", "pushed": True})
+    return _p
+
+
+def test_resolve_gateway_precedence(monkeypatch):
+    monkeypatch.delenv("SWARPH_HIGHLIGHT_GATEWAY", raising=False)
+    monkeypatch.setenv("SWARPH_BRAIN_GATEWAY", "http://brain:8788")
+    assert hl._resolve_gateway(None) == "http://brain:8788"        # brain fallback
+    monkeypatch.setenv("SWARPH_GATEWAY", "http://gw:8788")
+    assert hl._resolve_gateway(None) == "http://gw:8788"           # SWARPH_GATEWAY wins over brain
+    monkeypatch.setenv("SWARPH_HIGHLIGHT_GATEWAY", "http://hl:8788")
+    assert hl._resolve_gateway(None) == "http://hl:8788"           # most-specific wins
+    assert hl._resolve_gateway("http://cli:8788") == "http://cli:8788"  # --gateway wins over all
+
+
+def test_gateway_mode_is_default_when_configured(monkeypatch):
+    cap = {}
+    monkeypatch.setenv("SWARPH_BRAIN_GATEWAY", "http://gw:8788")   # the mesh-wide var
+    monkeypatch.setenv("SWARPH_CELL", "gridiron")
+    monkeypatch.setenv("MESH_GATEWAY_TOKEN", "tok")               # _resolve_token source
+    monkeypatch.setattr(hl, "_post_json", _fake_post(cap))
+    rc = hl.run_highlight(["a real highlight", "[[project_x]]"])
+    assert rc == 0
+    assert cap["url"] == "http://gw:8788/highlights"
+    assert cap["body"] == {"highlight": "a real highlight", "cell": "gridiron",
+                           "memory": "[[project_x]]"}
+    assert cap["token"] == "tok"
+
+
+def test_gateway_failure_returns_1_no_git_fallback(monkeypatch, tmp_path):
+    monkeypatch.setenv("SWARPH_BRAIN_GATEWAY", "http://gw:8788")
+    monkeypatch.setenv("SWARPH_CELL", "c")
+    monkeypatch.setenv("MESH_GATEWAY_TOKEN", "tok")
+    monkeypatch.setenv("SWARPH_TIMELINE_DIR", str(tmp_path / "tl"))
+    monkeypatch.setattr(hl, "_post_json", _fake_post({}, status=502, resp={"detail": "boom"}))
+    rc = hl.run_highlight(["x"])
+    assert rc == 1                                                 # fail loud
+    assert not (tmp_path / "tl" / "TIMELINE.md").exists()          # no silent git double-write
+
+
+def test_local_flag_forces_git_even_with_gateway(tmp_path, monkeypatch):
+    called = {"n": 0}
+    monkeypatch.setenv("SWARPH_BRAIN_GATEWAY", "http://gw:8788")   # configured...
+    monkeypatch.setenv("SWARPH_TIMELINE_DIR", str(tmp_path / "tl"))
+    monkeypatch.setenv("SWARPH_CELL", "c")
+    monkeypatch.setattr(hl, "_post_json",
+                        lambda *a, **k: (called.update(n=called["n"] + 1), (200, {}))[1])
+    rc = hl.run_highlight(["local please", "--local", "--no-push"])   # ...but --local wins
+    assert rc == 0
+    assert called["n"] == 0                                        # gateway NOT called
+    body = (tmp_path / "tl" / "TIMELINE.md").read_text()
+    assert "local please" in body and "**c**" in body             # git path ran

{swarph_cli-0.26.0 → swarph_cli-0.27.0}/tests/test_watchdog.py

@@ -1041,6 +1041,6 @@ def test_parser_defaults_process_name_claude_liveness_cmd_none():
     assert ns.liveness_cmd is None
 
 
-def test_version_is_0_26_0():
+def test_version_is_0_27_0():
     import swarph_cli
-    assert swarph_cli.__version__ == "0.26.0"
+    assert swarph_cli.__version__ == "0.27.0"

swarph_cli-0.26.0/tests/test_highlight_command.py

@@ -1,67 +0,0 @@
-"""Tests for ``swarph highlight`` — append to a git-backed timeline.
-
-Offline: each test uses a fresh temp timeline dir with no remote (``--no-push``),
-so the real git mechanics run (init + append + commit) without a network.
-"""
-
-from __future__ import annotations
-
-import subprocess
-
-from swarph_cli.commands import highlight as hl
-
-
-# --- pure helpers ----------------------------------------------------------
-
-def test_collapse_newlines():
-    assert hl._collapse("a\nb\rc") == "a b c"
-
-
-def test_format_line_with_memory():
-    line = hl._format_line("2026-06-27T00:00Z", "lab-ovh", "shipped X", "[[mem-x]]")
-    assert line == "- 2026-06-27T00:00Z · **lab-ovh** · shipped X · → [[mem-x]]"
-
-
-def test_format_line_without_memory():
-    line = hl._format_line("2026-06-27T00:00Z", "lab-ovh", "shipped X", "")
-    assert line == "- 2026-06-27T00:00Z · **lab-ovh** · shipped X"
-
-
-# --- the verb (real git, no remote) ----------------------------------------
-
-def test_highlight_inits_appends_commits(tmp_path, monkeypatch):
-    d = tmp_path / "tl"
-    monkeypatch.setenv("SWARPH_TIMELINE_DIR", str(d))
-    monkeypatch.setenv("SWARPH_CELL", "test-cell")
-    rc = hl.run_highlight(["my highlight", "[[mem-x]]", "--no-push"])
-    assert rc == 0
-    tl = (d / "TIMELINE.md").read_text(encoding="utf-8")
-    assert "**test-cell**" in tl and "my highlight" in tl and "→ [[mem-x]]" in tl
-    log = subprocess.run(["git", "-C", str(d), "log", "--oneline"],
-                         capture_output=True, text=True).stdout
-    assert "highlight" in log.lower()
-    # union-merge attribute set so concurrent cell appends auto-merge
-    assert "merge=union" in (d / ".gitattributes").read_text(encoding="utf-8")
-
-
-def test_highlight_collapses_multiline_anti_spoof(tmp_path, monkeypatch):
-    d = tmp_path / "tl"
-    monkeypatch.setenv("SWARPH_TIMELINE_DIR", str(d))
-    monkeypatch.setenv("SWARPH_CELL", "c")
-    rc = hl.run_highlight(["line one\nFORGED **other** entry", "--no-push"])
-    assert rc == 0
-    entry_lines = [l for l in (d / "TIMELINE.md").read_text(encoding="utf-8").splitlines()
-                   if l.startswith("- ")]
-    assert len(entry_lines) == 1  # the newline can't forge a second attributed entry
-    assert "line one FORGED" in entry_lines[0]
-
-
-def test_highlight_second_append_keeps_both(tmp_path, monkeypatch):
-    d = tmp_path / "tl"
-    monkeypatch.setenv("SWARPH_TIMELINE_DIR", str(d))
-    monkeypatch.setenv("SWARPH_CELL", "c")
-    hl.run_highlight(["first", "--no-push"])
-    hl.run_highlight(["second", "--no-push"])
-    entry_lines = [l for l in (d / "TIMELINE.md").read_text(encoding="utf-8").splitlines()
-                   if l.startswith("- ")]
-    assert len(entry_lines) == 2