swarph-cli 0.7.9__tar.gz → 0.9.0__tar.gz

{swarph_cli-0.7.9/src/swarph_cli.egg-info → swarph_cli-0.9.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.7.9
-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.9 reverts the v0.7.8 pyreadline3 dependency + chat-REPL shim: the Windows 'Enter renders m' symptom traced to Claude Code's own native-Windows TUI (no hooks, recent build, fails at the trust prompt — Anthropic-side), NOT this REPL, so the shim addressed the wrong layer. Bare input() + a CR-strip guard remain.
+Version: 0.9.0
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider, via a ProviderMembrane), cell.yaml, session import, watchdog. v0.9.0 adds `swarph mesh` (send/inbox/register with per-peer tokens) + a provider-agnostic inbox sidecar, and `assisted_memory` (git-backed durable memory: restore-on-spawn + saver loop + current-task anchor) toggled per cell.
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.7.9 → swarph_cli-0.9.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.7.9"
-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.9 reverts the v0.7.8 pyreadline3 dependency + chat-REPL shim: the Windows 'Enter renders m' symptom traced to Claude Code's own native-Windows TUI (no hooks, recent build, fails at the trust prompt — Anthropic-side), NOT this REPL, so the shim addressed the wrong layer. Bare input() + a CR-strip guard remain."
+version = "0.9.0"
+description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider, via a ProviderMembrane), cell.yaml, session import, watchdog. v0.9.0 adds `swarph mesh` (send/inbox/register with per-peer tokens) + a provider-agnostic inbox sidecar, and `assisted_memory` (git-backed durable memory: restore-on-spawn + saver loop + current-task anchor) toggled per cell."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"

{swarph_cli-0.7.9 → swarph_cli-0.9.0}/src/swarph_cli/__init__.py

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

swarph_cli-0.9.0/src/swarph_cli/commands/memory_sync.py

@@ -0,0 +1,194 @@
+"""Assisted memory saver loop (Stage 2) + Restore helper."""
+
+import argparse
+import datetime
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+from swarph_cli.cell import Cell, load_cell, CellError
+
+
+def get_memory_repo_path(cell: Cell) -> Path:
+    # Memory repos are stored locally under ~/.local/share/swarph/memory/<role>
+    return Path.home() / ".local" / "share" / "swarph" / "memory" / cell.role
+
+
+def _get_files_to_sync(cell: Cell) -> list[tuple[str, Path]]:
+    files_to_sync = []
+
+    # Common
+    if (cell.cwd / "CURRENT_TASK.md").exists():
+        files_to_sync.append(("CURRENT_TASK.md", cell.cwd / "CURRENT_TASK.md"))
+
+    if cell.provider == "claude":
+        if (cell.cwd / "CLAUDE.md").exists():
+            files_to_sync.append(("CLAUDE.md", cell.cwd / "CLAUDE.md"))
+        mem_dir = Path.home() / ".claude"
+        if (mem_dir / "MEMORY.md").exists():
+            files_to_sync.append(("MEMORY.md", mem_dir / "MEMORY.md"))
+        for p in mem_dir.glob("memory/*.md"):
+            files_to_sync.append((f"memory/{p.name}", p))
+        if (mem_dir / "inbox-cursor").exists():
+            files_to_sync.append(("inbox-cursor", mem_dir / "inbox-cursor"))
+
+    elif cell.provider == "codex":
+        if (cell.cwd / "AGENTS.md").exists():
+            files_to_sync.append(("AGENTS.md", cell.cwd / "AGENTS.md"))
+
+    elif cell.provider in ("antigravity", "gemini"):
+        if (cell.cwd / "GEMINI.md").exists():
+            files_to_sync.append(("GEMINI.md", cell.cwd / "GEMINI.md"))
+        if (cell.cwd / "inbox-cursor.json").exists():
+            files_to_sync.append(("inbox-cursor.json", cell.cwd / "inbox-cursor.json"))
+        
+        gemini_tmp = Path.home() / ".gemini" / "tmp"
+        if gemini_tmp.is_dir():
+            for proj_dir in gemini_tmp.iterdir():
+                if proj_dir.is_dir():
+                    for p in proj_dir.glob("memory/*.md"):
+                        rel = f"tmp/{proj_dir.name}/memory/{p.name}"
+                        files_to_sync.append((rel, p))
+
+        history_proj = Path.home() / ".gemini" / "history" / ".project_root"
+        if history_proj.exists():
+            files_to_sync.append(("history/.project_root", history_proj))
+
+    return files_to_sync
+
+
+def _clone_if_missing(repo_url: str, repo_dir: Path) -> bool:
+    if not (repo_dir / ".git").is_dir():
+        repo_dir.parent.mkdir(parents=True, exist_ok=True)
+        if "://" not in repo_url and "@" not in repo_url:
+            repo_url = f"git@github.com:{repo_url}.git"
+        try:
+            subprocess.run(["git", "clone", repo_url, str(repo_dir)], check=True)
+        except subprocess.CalledProcessError as exc:
+            print(f"swarph: git clone failed: {exc}", file=sys.stderr)
+            return False
+    return True
+
+
+def perform_restore(cell: Cell) -> Optional[str]:
+    """Stage 3: Restore files from memory repo to the filesystem.
+    
+    Returns the text of CURRENT_TASK.md if it exists and was restored,
+    so the caller can surface it to the context window.
+    """
+    am = cell.assisted_memory
+    if not am or not am.get("enabled"):
+        return None
+
+    repo_url = am["repo"]
+    repo_dir = get_memory_repo_path(cell)
+
+    if not _clone_if_missing(repo_url, repo_dir):
+        return None
+
+    # pull --ff-only
+    try:
+        subprocess.run(["git", "-C", str(repo_dir), "pull", "--ff-only", "origin", "main"], check=True, capture_output=True)
+    except subprocess.CalledProcessError as exc:
+        print(f"swarph: memory pull --ff-only failed (diverged/offline?): {exc}", file=sys.stderr)
+
+    # Walk the repo dir and copy everything back, EXCEPT .git and .gitignore
+    for root, dirs, files in os.walk(repo_dir):
+        if ".git" in dirs:
+            dirs.remove(".git")
+        for f in files:
+            if f == ".gitignore":
+                continue
+            
+            src = Path(root) / f
+            rel = src.relative_to(repo_dir)
+            
+            dest = None
+            if rel.parts[0] in ("CURRENT_TASK.md", "CLAUDE.md", "AGENTS.md", "GEMINI.md", "inbox-cursor.json"):
+                dest = cell.cwd / rel
+            elif cell.provider == "claude" and rel.parts[0] == "MEMORY.md":
+                dest = Path.home() / ".claude" / "MEMORY.md"
+            elif cell.provider == "claude" and rel.parts[0] == "memory":
+                dest = Path.home() / ".claude" / rel
+            elif cell.provider == "claude" and rel.parts[0] == "inbox-cursor":
+                dest = Path.home() / ".claude" / "inbox-cursor"
+            elif cell.provider in ("antigravity", "gemini") and rel.parts[0] == "tmp":
+                dest = Path.home() / ".gemini" / rel
+            elif cell.provider in ("antigravity", "gemini") and rel.parts[0] == "history":
+                dest = Path.home() / ".gemini" / rel
+                
+            if dest:
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(src, dest)
+
+    current_task = cell.cwd / "CURRENT_TASK.md"
+    if current_task.exists():
+        return current_task.read_text(encoding="utf-8")
+    return None
+
+
+def run_memory_sync(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(prog="swarph memory-sync")
+    parser.add_argument("cell_yaml", help="Path to cell.yaml")
+    args = parser.parse_args(argv)
+
+    try:
+        cell = load_cell(Path(args.cell_yaml))
+    except CellError as exc:
+        print(f"swarph memory-sync: {exc}", file=sys.stderr)
+        return 1
+
+    am = cell.assisted_memory
+    if not am or not am.get("enabled"):
+        print("swarph memory-sync: assisted_memory not enabled for this cell. Exiting.", file=sys.stderr)
+        return 0
+
+    repo_url = am["repo"]
+    repo_dir = get_memory_repo_path(cell)
+
+    if not _clone_if_missing(repo_url, repo_dir):
+        return 1
+
+    gitignore_path = repo_dir / ".gitignore"
+    if not gitignore_path.exists():
+        gitignore_path.write_text("secrets/\n.*creds*\n*.token\n", encoding="utf-8")
+        subprocess.run(["git", "-C", str(repo_dir), "add", ".gitignore"], check=True)
+
+    try:
+        subprocess.run(["git", "-C", str(repo_dir), "pull", "--ff-only", "origin", "main"], check=True, capture_output=True)
+    except subprocess.CalledProcessError:
+        pass
+
+    # EMPTY-GUARD check
+    guard_file = None
+    if cell.provider == "claude":
+        guard_file = cell.cwd / "CLAUDE.md"
+    elif cell.provider == "codex":
+        guard_file = cell.cwd / "AGENTS.md"
+    elif cell.provider in ("antigravity", "gemini"):
+        guard_file = cell.cwd / "GEMINI.md"
+
+    if guard_file and (not guard_file.exists() or guard_file.stat().st_size == 0):
+        print(f"[auto_sync] {datetime.datetime.now(datetime.timezone.utc).strftime('%FT%TZ')} SAFETY: {guard_file} missing or empty — skipping sync", file=sys.stderr)
+        return 0
+
+    files_to_sync = _get_files_to_sync(cell)
+    for rel_path, abs_path in files_to_sync:
+        dest = repo_dir / rel_path
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(abs_path, dest)
+        subprocess.run(["git", "-C", str(repo_dir), "add", str(dest)], check=True)
+
+    diff_check = subprocess.run(["git", "-C", str(repo_dir), "diff", "--cached", "--quiet"])
+    if diff_check.returncode != 0:
+        ts = datetime.datetime.now(datetime.timezone.utc).strftime('%FT%TZ')
+        subprocess.run(["git", "-C", str(repo_dir), "commit", "-m", f"auto-snapshot {ts}"], check=True, capture_output=True)
+        try:
+            subprocess.run(["git", "-C", str(repo_dir), "push", "origin", "main"], check=True, capture_output=True)
+        except subprocess.CalledProcessError as exc:
+            print(f"swarph memory-sync: push failed: {exc}", file=sys.stderr)
+
+    return 0