swarph-cli 0.7.6__tar.gz → 0.7.8__tar.gz

{swarph_cli-0.7.6/src/swarph_cli.egg-info → swarph_cli-0.7.8}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.7.6
-Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration. v0.7.0 ships Phase 7 substrate-doc R7 §11.1.7 operator-tooling layer in 5 increments: PR-A `--new-instance` flag (sibling-spawn case) + PR-B auto-suffix on collision (sibling-slot persistence) + PR-C SessionStart hook (closes bare-claude operator-paste gap) + watchdog (stranded-session recovery) + PR-D swarph-shared cell.yaml relocation (cell-yaml schema graduates to swarph-shared 0.3.0 kernel-tier; substrate-doc R7 §11.1.5 (O5) RESOLVED).
+Version: 0.7.8
+Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration: one-shot + chat REPL, multi-provider routing (gemini/claude/deepseek/openai/grok), cell.yaml spawn, session import, and watchdog. v0.7.8 fixes Windows chat-REPL portability: stdlib `readline` is POSIX-only, so native Windows fell back to bare input() and echoed Enter as ^M (CR=Ctrl-M) while breaking line editing — adds a `pyreadline3` fallback (win32-only dependency) plus a CR-strip guard on parsed input.
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli
@@ -27,6 +27,7 @@ License-File: LICENSE
 Requires-Dist: swarph-mesh>=0.5.0
 Requires-Dist: swarph-shared>=0.3.0
 Requires-Dist: PyYAML>=6.0
+Requires-Dist: pyreadline3>=3.4; sys_platform == "win32"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Dynamic: license-file

{swarph_cli-0.7.6 → swarph_cli-0.7.8}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.7.6"
-description = "The `swarph` binary — multi-LLM CLI with mesh-gateway integration. v0.7.0 ships Phase 7 substrate-doc R7 §11.1.7 operator-tooling layer in 5 increments: PR-A `--new-instance` flag (sibling-spawn case) + PR-B auto-suffix on collision (sibling-slot persistence) + PR-C SessionStart hook (closes bare-claude operator-paste gap) + watchdog (stranded-session recovery) + PR-D swarph-shared cell.yaml relocation (cell-yaml schema graduates to swarph-shared 0.3.0 kernel-tier; substrate-doc R7 §11.1.5 (O5) RESOLVED)."
+version = "0.7.8"
+description = "The `swarph` binary — multi-LLM CLI with mesh-gateway integration: one-shot + chat REPL, multi-provider routing (gemini/claude/deepseek/openai/grok), cell.yaml spawn, session import, and watchdog. v0.7.8 fixes Windows chat-REPL portability: stdlib `readline` is POSIX-only, so native Windows fell back to bare input() and echoed Enter as ^M (CR=Ctrl-M) while breaking line editing — adds a `pyreadline3` fallback (win32-only dependency) plus a CR-strip guard on parsed input."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"
@@ -42,6 +42,11 @@ dependencies = [
     # Stays a swarph-cli dep since file I/O is operator-tooling-layer
     # concern; swarph-shared cell module is pure-stdlib.
     "PyYAML>=6.0",
+    # Windows portability: stdlib `readline` is POSIX-only, so the chat
+    # REPL falls back to bare input() on native Windows — which echoes
+    # Enter as ^M (CR=Ctrl-M) + breaks line editing in mintty/Git-Bash.
+    # pyreadline3 supplies the readline interface on Windows only.
+    "pyreadline3>=3.4; sys_platform == 'win32'",
 ]
 
 [project.urls]

{swarph_cli-0.7.6 → swarph_cli-0.7.8}/src/swarph_cli/__init__.py

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

{swarph_cli-0.7.6 → swarph_cli-0.7.8}/src/swarph_cli/commands/chat.py

@@ -141,12 +141,25 @@ def _print(msg: str = "", *, file=None) -> None:
 def _read_line(prompt: str) -> str:
     """Single-line input. Tests monkeypatch this to inject scripted
     input. Production uses stdlib ``input()`` — readline is auto-loaded
-    by import-time on POSIX, giving line editing + history for free."""
+    at import-time on POSIX, giving line editing + history for free.
+
+    Windows portability: stdlib ``readline`` is POSIX-only, so on native
+    Windows it's absent and ``input()`` runs raw. In mintty/Git-Bash and
+    some non-conhost consoles that makes the Enter keypress echo a raw
+    carriage return as ``^M`` (CR = 0x0D = Ctrl-M) and breaks line editing.
+    ``pyreadline3`` provides the readline interface on Windows; we fall back
+    to it so native consoles get proper line discipline. The ``rstrip``
+    below also strips any stray ``\\r`` from the parsed value as a guard,
+    independent of the echo fix. (Cleanest of all: run swarph inside WSL,
+    which is POSIX and loads stdlib readline directly.)"""
     try:
         import readline  # noqa: F401 — side-effect-only on POSIX
     except ImportError:
-        pass  # Windows / minimal builds; raw input still works
-    return input(prompt)
+        try:
+            import pyreadline3  # noqa: F401 — Windows readline shim
+        except ImportError:
+            pass  # minimal build; raw input still works (rstrip guards CR)
+    return input(prompt).rstrip("\r\n")
 
 
 def _format_attribution(

{swarph_cli-0.7.6 → swarph_cli-0.7.8}/src/swarph_cli/commands/install_hook.py

@@ -22,6 +22,13 @@ Idempotent: rerun safe. Detects existing hook entries pointing at
 Skip when SWARPH_SPAWN=1 env (set by ``swarph spawn``) — avoids
 double-injection when the spawn path already passed the prompt via
 ``--append-system-prompt``.
+
+NOTE (2026-05-17): IF this file grows to manage 3+ DISTINCT hook events
+(beyond SessionStart), revisit adopting a hook framework
+(claude-hooks / cchooks / similar). Solo eval 2026-05-17 deferred
+framework adoption because 1-hook surface didn't justify the
+750-LOC dependency. See lab memory ``project_deferred_decisions.md``
+for the full threshold conditions + revisit checklist.
 """
 
 from __future__ import annotations

{swarph_cli-0.7.6 → swarph_cli-0.7.8}/src/swarph_cli/commands/spawn.py

@@ -201,6 +201,61 @@ def _resolve_cell(args: argparse.Namespace) -> tuple[Cell, Optional[str]]:
     return load_cell(path), requested_role
 
 
+def _validate_routing(cell: Cell) -> None:
+    """Phase 1B v0 (2026-05-19) — read + validate ``cell.extra.routing``.
+
+    Phase 1B-primary architecture commits the cell-membrane framing:
+    Claude CLI is the membrane for Anthropic-side spawns; non-Anthropic
+    cells get a different membrane (currently NOT implemented).
+
+    cell.yaml ``routing`` field shape (v0):
+    ::
+        routing:
+          native: anthropic         # only valid value in v0
+
+    v0 accepts ``routing`` absent (= default anthropic) OR
+    ``routing.native: anthropic``. Any other value raises CellError
+    pointing at Phase 1B v1+ direction.
+
+    Forward-compat: reads via ``Cell.extra`` (same pattern as
+    cursor_path / tmux_session shipped in v0.7.2 before graduating to
+    typed fields in swarph-shared 0.4.x). When swarph-shared graduates
+    ``routing`` to a typed Cell field, this helper swaps to typed
+    access with no API surface change for cell.yaml authors.
+
+    See research/swarph_cli/CELL_MEMBRANE_PHASE_0_RFC.md §5 (Phase 1B)
+    for the architectural context. See lab memory
+    ``project_next_up.md`` for the commander 2026-05-19 decision that
+    Phase 1B is primary + path (c) Anthropic-only v0.
+    """
+    extra = cell.extra or {}
+    routing = extra.get("routing")
+    if routing is None:
+        return  # No routing field → default Anthropic, allow
+    if not isinstance(routing, dict):
+        raise CellError(
+            f"swarph spawn: cell.yaml `routing` must be a mapping, "
+            f"got {type(routing).__name__}. See "
+            f"research/swarph_cli/CELL_MEMBRANE_PHASE_0_RFC.md for the "
+            f"valid v0 schema."
+        )
+    native = routing.get("native", "anthropic")
+    if native == "anthropic":
+        return  # Explicit Anthropic OR default → allow
+    # Any other native value is a Phase 1B v1+ feature not yet built
+    raise CellError(
+        f"swarph spawn: cell.yaml `routing.native: {native!r}` is not "
+        f"supported in v0 of Phase 1B (Anthropic-only). Non-Anthropic "
+        f"routing (e.g. routing.native: openrouter) is Phase 1B v1+ "
+        f"scope, deferred per commander 2026-05-19 until a concrete "
+        f"non-Anthropic-cell use case emerges. For now, remove the "
+        f"`routing.native` field OR set it to 'anthropic' to use the "
+        f"existing Claude CLI spawn path. See "
+        f"research/swarph_cli/CELL_MEMBRANE_PHASE_0_RFC.md §5 for the "
+        f"architectural direction."
+    )
+
+
 def _session_state_exists(session_id: str) -> bool:
     """True if Claude Code already has on-disk session state for this UUID.
 
@@ -346,6 +401,15 @@ def run_spawn(argv: Optional[list[str]] = None) -> int:
         print(f"swarph spawn: {exc}", file=sys.stderr)
         return 1
 
+    # Phase 1B v0 (2026-05-19): validate cell.yaml routing field.
+    # In v0 only `routing.native: anthropic` (or absent) is accepted.
+    # Future non-Anthropic dispatch is Phase 1B v1+ scope.
+    try:
+        _validate_routing(cell)
+    except CellError as exc:
+        print(f"swarph spawn: {exc}", file=sys.stderr)
+        return 1
+
     # When user typed a slot-role (e.g. `swarph spawn drop-on-meta-edge-2`)
     # the cell.yaml resolved to the BASE file (drop-on-meta-edge.yaml) so
     # cell.role = "drop-on-meta-edge". But the operator wants slot 2's
@@ -418,6 +482,32 @@ def run_spawn(argv: Optional[list[str]] = None) -> int:
         )
         return 127
 
+    # Windows-platform known-issues banner. Claude Code's TUI (Ink-based)
+    # has documented input/rendering bugs on Windows native consoles
+    # (conhost.exe in particular). Specific symptom commander hit
+    # 2026-05-17 on workstation-lc: pressing Enter inserts literal 'm'
+    # character instead of submitting. See docs/WINDOWS_KNOWN_ISSUES.md
+    # for the full hypothesis chain + workarounds (Windows Terminal vs
+    # conhost, WSL2 fallback, TERM env injection).
+    #
+    # Banner is suppressed by --no-banner OR when the operator has
+    # already acknowledged via SWARPH_WIN_ACK=1 in env (set once after
+    # reading the doc).
+    if (
+        sys.platform == "win32"
+        and not args.no_banner
+        and not os.environ.get("SWARPH_WIN_ACK")
+    ):
+        print(
+            "swarph spawn: WARNING — Windows shell detected. Claude Code's "
+            "TUI has documented input/rendering issues on Windows native "
+            "consoles (conhost.exe). Known symptom: Enter inserts literal "
+            "'m' character. See docs/WINDOWS_KNOWN_ISSUES.md for "
+            "workarounds (use Windows Terminal not conhost, or WSL2). "
+            "Set SWARPH_WIN_ACK=1 in env to suppress this warning.",
+            file=sys.stderr,
+        )
+
     try:
         os.chdir(cell.cwd)
     except OSError as exc:

{swarph_cli-0.7.6 → swarph_cli-0.7.8/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.7.6
-Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration. v0.7.0 ships Phase 7 substrate-doc R7 §11.1.7 operator-tooling layer in 5 increments: PR-A `--new-instance` flag (sibling-spawn case) + PR-B auto-suffix on collision (sibling-slot persistence) + PR-C SessionStart hook (closes bare-claude operator-paste gap) + watchdog (stranded-session recovery) + PR-D swarph-shared cell.yaml relocation (cell-yaml schema graduates to swarph-shared 0.3.0 kernel-tier; substrate-doc R7 §11.1.5 (O5) RESOLVED).
+Version: 0.7.8
+Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration: one-shot + chat REPL, multi-provider routing (gemini/claude/deepseek/openai/grok), cell.yaml spawn, session import, and watchdog. v0.7.8 fixes Windows chat-REPL portability: stdlib `readline` is POSIX-only, so native Windows fell back to bare input() and echoed Enter as ^M (CR=Ctrl-M) while breaking line editing — adds a `pyreadline3` fallback (win32-only dependency) plus a CR-strip guard on parsed input.
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli
@@ -27,6 +27,7 @@ License-File: LICENSE
 Requires-Dist: swarph-mesh>=0.5.0
 Requires-Dist: swarph-shared>=0.3.0
 Requires-Dist: PyYAML>=6.0
+Requires-Dist: pyreadline3>=3.4; sys_platform == "win32"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Dynamic: license-file

{swarph_cli-0.7.6 → swarph_cli-0.7.8}/src/swarph_cli.egg-info/requires.txt

@@ -2,5 +2,8 @@ swarph-mesh>=0.5.0
 swarph-shared>=0.3.0
 PyYAML>=6.0
 
+[:sys_platform == "win32"]
+pyreadline3>=3.4
+
 [dev]
 pytest>=7.0

{swarph_cli-0.7.6 → swarph_cli-0.7.8}/tests/test_spawn_command.py

@@ -428,3 +428,108 @@ def test_build_claude_argv_uses_resume_when_state_exists(fake_cell_yaml, tmp_pat
     assert "--session-id" not in argv
     # UUID still passed (just as --resume's value not --session-id's)
     assert uuid in argv
+
+
+# ---------------------------------------------------------------------------
+# Phase 1B v0 — cell.yaml routing field (2026-05-19)
+# ---------------------------------------------------------------------------
+
+
+def test_validate_routing_absent_allows(fake_cell_yaml):
+    """No `routing` field → default Anthropic, _validate_routing returns silently."""
+    from swarph_cli.commands.spawn import _validate_routing
+    cell = load_cell(fake_cell_yaml)
+    # fake_cell_yaml has no routing field → should pass
+    _validate_routing(cell)  # no exception = pass
+
+
+def test_validate_routing_explicit_anthropic_allows(tmp_path):
+    """`routing.native: anthropic` → allowed (explicit form)."""
+    from swarph_cli.commands.spawn import _validate_routing
+    payload = {
+        "schema_version": SCHEMA_VERSION_V1,
+        "name": "lab-ovh",
+        "role": "lab-test",
+        "cwd": str(tmp_path),
+        "provider": "claude",
+        "routing": {"native": "anthropic"},
+    }
+    p = tmp_path / "cell.yaml"
+    p.write_text(yaml.safe_dump(payload), encoding="utf-8")
+    cell = load_cell(p)
+    _validate_routing(cell)  # no exception = pass
+
+
+def test_validate_routing_non_anthropic_rejects(tmp_path):
+    """`routing.native: openrouter` → rejected with v0 + v1 direction message."""
+    from swarph_cli.commands.spawn import _validate_routing
+    from swarph_cli.cell import CellError
+    payload = {
+        "schema_version": SCHEMA_VERSION_V1,
+        "name": "lab-ovh",
+        "role": "lab-test",
+        "cwd": str(tmp_path),
+        "provider": "claude",
+        "routing": {"native": "openrouter"},
+    }
+    p = tmp_path / "cell.yaml"
+    p.write_text(yaml.safe_dump(payload), encoding="utf-8")
+    cell = load_cell(p)
+    with pytest.raises(CellError) as exc_info:
+        _validate_routing(cell)
+    err = str(exc_info.value)
+    assert "openrouter" in err
+    assert "v0" in err
+    assert "Phase 1B" in err
+    assert "anthropic" in err  # should point at the only valid value
+
+
+def test_validate_routing_non_dict_rejects(tmp_path):
+    """`routing: "anthropic"` (string instead of dict) → schema error."""
+    from swarph_cli.commands.spawn import _validate_routing
+    from swarph_cli.cell import CellError
+    payload = {
+        "schema_version": SCHEMA_VERSION_V1,
+        "name": "lab-ovh",
+        "role": "lab-test",
+        "cwd": str(tmp_path),
+        "provider": "claude",
+        "routing": "anthropic",  # WRONG — should be dict
+    }
+    p = tmp_path / "cell.yaml"
+    p.write_text(yaml.safe_dump(payload), encoding="utf-8")
+    cell = load_cell(p)
+    with pytest.raises(CellError) as exc_info:
+        _validate_routing(cell)
+    assert "mapping" in str(exc_info.value)
+
+
+def test_validate_routing_omitted_native_allows(tmp_path):
+    """`routing: {}` (empty dict, no native key) → defaults to anthropic, allows."""
+    from swarph_cli.commands.spawn import _validate_routing
+    payload = {
+        "schema_version": SCHEMA_VERSION_V1,
+        "name": "lab-ovh",
+        "role": "lab-test",
+        "cwd": str(tmp_path),
+        "provider": "claude",
+        "routing": {},
+    }
+    p = tmp_path / "cell.yaml"
+    p.write_text(yaml.safe_dump(payload), encoding="utf-8")
+    cell = load_cell(p)
+    _validate_routing(cell)  # default anthropic = allowed
+
+
+def test_run_spawn_rejects_non_anthropic_routing_in_dry_run(
+    fake_cell_yaml, isolated_xdg, capsys
+):
+    """End-to-end: `swarph spawn --dry-run` with non-anthropic routing → exit 1 + error message."""
+    payload = yaml.safe_load(fake_cell_yaml.read_text())
+    payload["routing"] = {"native": "gemini"}
+    fake_cell_yaml.write_text(yaml.safe_dump(payload))
+    rc = run_spawn(["--dry-run", str(fake_cell_yaml)])
+    assert rc == 1
+    captured = capsys.readouterr()
+    assert "gemini" in captured.err
+    assert "Phase 1B" in captured.err