meshcode 2.11.20__tar.gz → 2.11.21__tar.gz

{meshcode-2.11.20 → meshcode-2.11.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.20
+Version: 2.11.21
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.20 → meshcode-2.11.21}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.20"
+__version__ = "2.11.21"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

meshcode-2.11.21/meshcode/atomic_push.py

@@ -0,0 +1,257 @@
+"""Atomic multi-remote git push via GitHub REST API.
+
+Implements MESH-IMPROVE-3 (feedback session 5651f137 — 4/4 cycle convergence).
+
+MVP scope:
+  - strategy='same_tree_sha' only (defer cherry_pick_if_diverged + rest_api_blob_tree to v2)
+  - remotes hardcoded to {origin, lovable2} (param accepted but only those valid)
+  - idempotency_key: when same key seen twice within 1h, returns cached result
+    (avoids double-commit on retry — handles dulwich-shutdown-traceback pattern
+    front-2 reported in feedback cycle 2)
+  - auth_source: 'git_config' (parse PATs from .git/config) — most agents
+    have PATs there per the pattern established 2026-05-20
+
+Used by meshcode_atomic_push MCP tool + callable from scripts.
+"""
+from __future__ import annotations
+
+import base64
+import json
+import os
+import re
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+ALLOWED_REMOTES = ("origin", "lovable2")
+_CACHE_TTL_S = 3600
+_DEFAULT_REPO_ROOT = Path("/Users/anfexi/Desktop/meshcode")
+
+
+def _cache_path() -> Path:
+    base = Path(os.path.expanduser("~/.meshcode"))
+    base.mkdir(parents=True, exist_ok=True)
+    return base / "atomic_push_cache.json"
+
+
+def _load_cache() -> Dict[str, Any]:
+    p = _cache_path()
+    if not p.exists():
+        return {}
+    try:
+        with open(p) as f:
+            return json.load(f) or {}
+    except Exception:
+        return {}
+
+
+def _save_cache(cache: Dict[str, Any]) -> None:
+    try:
+        with open(_cache_path(), "w") as f:
+            json.dump(cache, f)
+    except Exception:
+        pass
+
+
+def _check_idempotency(key: Optional[str]) -> Optional[Dict[str, Any]]:
+    if not key:
+        return None
+    cache = _load_cache()
+    entry = cache.get(key)
+    if not entry:
+        return None
+    if (time.time() - entry.get("ts", 0)) > _CACHE_TTL_S:
+        return None
+    return entry.get("result")
+
+
+def _store_idempotency(key: Optional[str], result: Dict[str, Any]) -> None:
+    if not key:
+        return
+    cache = _load_cache()
+    cache[key] = {"ts": time.time(), "result": result}
+    # Prune entries older than TTL
+    cutoff = time.time() - _CACHE_TTL_S
+    cache = {k: v for k, v in cache.items() if v.get("ts", 0) > cutoff}
+    _save_cache(cache)
+
+
+def parse_git_config(repo_root: Path = _DEFAULT_REPO_ROOT) -> Dict[str, Tuple[str, str, str]]:
+    """Return {remote_alias: (owner, repo, pat)}."""
+    cfg_path = repo_root / ".git" / "config"
+    if not cfg_path.exists():
+        return {}
+    cfg = cfg_path.read_text()
+    remotes: Dict[str, Tuple[str, str, str]] = {}
+    for block in re.split(r"\n(?=\[)", cfg):
+        m = re.match(r'\[remote "([^"]+)"\]', block)
+        if not m:
+            continue
+        alias = m.group(1)
+        url_m = re.search(r"url\s*=\s*(\S+)", block)
+        if not url_m:
+            continue
+        url = url_m.group(1)
+        creds_m = re.match(
+            r"https://([^:]+):([^@]+)@github\.com/([^/]+)/([^/]+?)(?:\.git)?$",
+            url,
+        )
+        if not creds_m:
+            continue
+        _, pat, owner, repo = creds_m.groups()
+        remotes[alias] = (owner, repo, pat)
+    return remotes
+
+
+def _api(method: str, url: str, pat: str, data: Any = None) -> Dict[str, Any]:
+    req = urllib.request.Request(url, method=method)
+    req.add_header("Authorization", f"Bearer {pat}")
+    req.add_header("Accept", "application/vnd.github+json")
+    req.add_header("X-GitHub-Api-Version", "2022-11-28")
+    body = None
+    if data is not None:
+        body = json.dumps(data).encode()
+        req.add_header("Content-Type", "application/json")
+    try:
+        with urllib.request.urlopen(req, data=body, timeout=30) as r:
+            return json.loads(r.read().decode())
+    except urllib.error.HTTPError as e:
+        msg = e.read().decode()[:300]
+        raise RuntimeError(f"{method} {url} -> {e.code}: {msg}") from e
+
+
+def _push_one_remote(
+    owner: str,
+    repo: str,
+    pat: str,
+    branch: str,
+    commit_message: str,
+    files: List[str],
+    repo_root: Path,
+) -> Tuple[str, Dict[str, Any]]:
+    base = f"https://api.github.com/repos/{owner}/{repo}"
+    ref = _api("GET", f"{base}/git/ref/heads/{branch}", pat)
+    head_sha = ref["object"]["sha"]
+    base_commit = _api("GET", f"{base}/git/commits/{head_sha}", pat)
+    base_tree_sha = base_commit["tree"]["sha"]
+    tree_entries = []
+    for rel in files:
+        p = repo_root / rel
+        if not p.exists():
+            raise RuntimeError(f"file not found: {p}")
+        content = p.read_bytes()
+        blob = _api(
+            "POST",
+            f"{base}/git/blobs",
+            pat,
+            data={"content": base64.b64encode(content).decode(), "encoding": "base64"},
+        )
+        tree_entries.append({
+            "path": rel,
+            "mode": "100644",
+            "type": "blob",
+            "sha": blob["sha"],
+        })
+    new_tree = _api(
+        "POST",
+        f"{base}/git/trees",
+        pat,
+        data={"base_tree": base_tree_sha, "tree": tree_entries},
+    )
+    commit = _api(
+        "POST",
+        f"{base}/git/commits",
+        pat,
+        data={
+            "message": commit_message,
+            "tree": new_tree["sha"],
+            "parents": [head_sha],
+        },
+    )
+    new_sha = commit["sha"]
+    _api(
+        "PATCH",
+        f"{base}/git/refs/heads/{branch}",
+        pat,
+        data={"sha": new_sha, "force": False},
+    )
+    return new_sha, {
+        "head_before": head_sha,
+        "tree_sha": new_tree["sha"],
+        "commit_sha": new_sha,
+    }
+
+
+def atomic_push(
+    commit_message: str,
+    files: List[str],
+    *,
+    branch: str = "main",
+    remotes: Optional[List[str]] = None,
+    strategy: str = "same_tree_sha",
+    idempotency_key: Optional[str] = None,
+    repo_root: Path = _DEFAULT_REPO_ROOT,
+) -> Dict[str, Any]:
+    """Push the same blob set to multiple remotes atomically.
+
+    Returns:
+        {
+            ok: bool,
+            landed: {remote_alias: commit_sha},
+            tree_sha_per_remote: {remote_alias: tree_sha},
+            drift_detected: bool,
+            transport_used: 'github_rest_api',
+            cached: bool,
+            strategy: str
+        }
+    """
+    if strategy != "same_tree_sha":
+        return {
+            "ok": False,
+            "error": "unsupported_strategy",
+            "hint": f"MVP supports 'same_tree_sha' only; got {strategy!r}",
+        }
+    remotes = remotes or list(ALLOWED_REMOTES)
+    for r in remotes:
+        if r not in ALLOWED_REMOTES:
+            return {
+                "ok": False,
+                "error": "unsupported_remote",
+                "hint": f"MVP accepts {ALLOWED_REMOTES}; got {r!r}",
+            }
+    cached = _check_idempotency(idempotency_key)
+    if cached is not None:
+        cached["cached"] = True
+        return cached
+    git_remotes = parse_git_config(repo_root)
+    missing = [r for r in remotes if r not in git_remotes]
+    if missing:
+        return {
+            "ok": False,
+            "error": "git_config_remote_missing",
+            "missing": missing,
+            "have": list(git_remotes.keys()),
+        }
+    landed: Dict[str, str] = {}
+    tree_sha_per: Dict[str, str] = {}
+    for alias in remotes:
+        owner, repo, pat = git_remotes[alias]
+        sha, meta = _push_one_remote(owner, repo, pat, branch, commit_message, files, repo_root)
+        landed[alias] = sha
+        tree_sha_per[alias] = meta["tree_sha"]
+    tree_shas = list(tree_sha_per.values())
+    same_tree = len(set(tree_shas)) == 1
+    result = {
+        "ok": True,
+        "landed": landed,
+        "tree_sha_per_remote": tree_sha_per,
+        "drift_detected": not same_tree,
+        "transport_used": "github_rest_api",
+        "cached": False,
+        "strategy": strategy,
+        "branch": branch,
+    }
+    _store_idempotency(idempotency_key, result)
+    return result

{meshcode-2.11.20 → meshcode-2.11.21}/meshcode/meshcode_mcp/server.py

@@ -5398,6 +5398,80 @@ def meshcode_remember(
     return result
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_atomic_push(
+    commit_message: str,
+    files: List[str],
+    branch: str = "main",
+    remotes: Optional[List[str]] = None,
+    idempotency_key: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Push same blob set to multiple git remotes atomically (same tree SHA).
+    MESH-IMPROVE-3 (feedback session 5651f137 — 4/4 cycle convergence).
+
+    Args:
+        commit_message: full commit message (multi-line ok).
+        files: list of repo-relative paths to include in the commit.
+        branch: target branch on each remote (default "main").
+        remotes: subset of {"origin","lovable2"}; defaults to both.
+        idempotency_key: if same key seen twice within 1h, returns cached result
+            (avoids double-commit on retry — covers dulwich-shutdown-traceback).
+
+    Returns: {ok, landed:{remote:sha}, tree_sha_per_remote, drift_detected,
+             transport_used:'github_rest_api', cached:bool, strategy, branch}
+    """
+    if not commit_message or not commit_message.strip():
+        return {"error": "commit_message cannot be empty"}
+    if not files:
+        return {"error": "files list cannot be empty"}
+    try:
+        from meshcode import atomic_push as _ap
+        return _ap.atomic_push(
+            commit_message=commit_message,
+            files=files,
+            branch=branch,
+            remotes=remotes,
+            strategy="same_tree_sha",
+            idempotency_key=idempotency_key,
+        )
+    except Exception as e:
+        return {"error": str(e), "error_type": type(e).__name__}
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_context_budget() -> Dict[str, Any]:
+    """Self-pacing hint for the agent's reply verbosity.
+    MESH-IMPROVE-10 (feedback session 5651f137).
+
+    Returns: {messages_seen, suggestion: 'short'|'normal'|'verbose',
+             rationale: str}.
+
+    Note: server cannot know the actual conversation token count (Anthropic
+    doesn't expose). Suggestion is derived from proxies the server CAN see —
+    cumulative msg count + recent msg sizes. Treat as a hint, not a hard
+    truth.
+    """
+    seen = len(_SEEN_MSG_IDS)
+    # Heuristic: <50 msgs = verbose ok; 50-150 = normal; >150 = short
+    if seen < 50:
+        suggestion = "verbose"
+        rationale = "fresh session — full detail is fine"
+    elif seen < 150:
+        suggestion = "normal"
+        rationale = "mid-session — standard verbosity"
+    else:
+        suggestion = "short"
+        rationale = "deep session — prefer tight prose, drop redundant context"
+    return {
+        "ok": True,
+        "messages_seen": seen,
+        "suggestion": suggestion,
+        "rationale": rationale,
+    }
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_recall_mesh(key: str) -> Dict[str, Any]:

{meshcode-2.11.20 → meshcode-2.11.21}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.20
+Version: 2.11.21
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.11.20 → meshcode-2.11.21}/meshcode.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ meshcode/__init__.py
 meshcode/__main__.py
 meshcode/_stop_hook_template.py
 meshcode/ascii_art.py
+meshcode/atomic_push.py
 meshcode/cli.py
 meshcode/comms_v4.py
 meshcode/compat.py

{meshcode-2.11.20 → meshcode-2.11.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.11.20"
+version = "2.11.21"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}