meshcode 2.11.19__tar.gz → 2.11.21__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.19
+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.19 → meshcode-2.11.21}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.19"
+__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.19 → meshcode-2.11.21}/meshcode/meshcode_mcp/server.py

@@ -5334,6 +5334,8 @@ def meshcode_remember(
     value: Any,
     weight: int = 5,
     emotion_tag: Optional[str] = None,
+    scope: str = "agent",
+    promote_from: Optional[str] = None,
 ) -> Dict[str, Any]:
     """Store a persistent memory (survives restarts). Only for reusable learnings, NOT task data.
 
@@ -5341,16 +5343,22 @@ def meshcode_remember(
         key: Short key (e.g. "team_conventions").
         value: Any JSON-serializable value.
         weight: 1-10, default 5 (neutral). Higher = ranks higher on recall.
-            Use 8-10 for hard-won lessons (e.g. Samuel-frustrated-4x).
-        emotion_tag: Optional free-form tag (e.g. "frustration", "delight",
-            "concern"). Surfaced in recall hints so agents see why a memory
-            ranked.
+        emotion_tag: Optional free-form tag.
+        scope: 'agent' (default, per-agent memory) OR 'mesh' (shared across
+            the meshwork; visible to all agents). MESH-IMPROVE-2 (mig 339).
+            On write conflict with an existing mesh value, server records the
+            contradiction; resolve via meshcode_resolve_contradiction.
+        promote_from: when scope='mesh', set this to an existing agent-scope
+            memory key — server lifts that value to mesh-scope without
+            duplicating the data. Caller's `value` arg is ignored when set.
     """
     if not key or not key.strip():
         return {"error": "key cannot be empty"}
     key = key.strip()
     if not isinstance(weight, int) or weight < 1 or weight > 10:
         return {"error": "weight must be an integer 1..10"}
+    if scope not in ("agent", "mesh"):
+        return {"error": f"scope must be 'agent' or 'mesh', got {scope!r}"}
     api_key = _get_api_key()
     json_value = value if isinstance(value, (dict, list)) else json.dumps(value)
     if isinstance(json_value, str):
@@ -5358,6 +5366,20 @@ def meshcode_remember(
             json_value = json.loads(json_value)
         except (json.JSONDecodeError, TypeError):
             json_value = {"_raw": value}
+    if scope == "mesh":
+        # MESH-IMPROVE-2: mesh-scope write via mig 339 RPC. Surfaces
+        # contradiction metadata in the response when an existing value
+        # differs from the new one.
+        return be.sb_rpc("mc_meshwork_remember", {
+            "p_api_key": api_key,
+            "p_project_id": _PROJECT_ID,
+            "p_key": key,
+            "p_value": json_value,
+            "p_writer_agent": AGENT_NAME,
+            "p_weight": weight,
+            "p_emotion_tag": emotion_tag,
+            "p_promote_from_agent_key": promote_from,
+        })
     result = be.sb_rpc("mc_memory_set", {
         "p_api_key": api_key,
         "p_agent_name": AGENT_NAME,
@@ -5368,15 +5390,126 @@ def meshcode_remember(
         "p_weight": weight,
         "p_emotion_tag": emotion_tag,
     })
-    # Best-effort sync to Obsidian vault (if configured)
     if isinstance(result, dict) and result.get("ok"):
         try:
             _sync_to_obsidian(key, json_value)
         except Exception:
-            pass  # Obsidian sync is best-effort, never block memory writes
+            pass
     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]:
+    """Read a mesh-scoped memory + any open contradictions on it.
+    MESH-IMPROVE-2 (mig 339).
+    """
+    if not key or not key.strip():
+        return {"error": "key cannot be empty"}
+    return be.sb_rpc("mc_meshwork_recall", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_key": key.strip(),
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_resolve_contradiction(key: str, winning_value: Any) -> Dict[str, Any]:
+    """Pick a winning value for a mesh-scoped memory with open contradictions.
+    Marks every loser as superseded. MESH-IMPROVE-2 (mig 339).
+    """
+    if not key or not key.strip():
+        return {"error": "key cannot be empty"}
+    json_value = winning_value if isinstance(winning_value, (dict, list)) else json.dumps(winning_value)
+    if isinstance(json_value, str):
+        try:
+            json_value = json.loads(json_value)
+        except (json.JSONDecodeError, TypeError):
+            json_value = {"_raw": winning_value}
+    return be.sb_rpc("mc_meshwork_resolve_contradiction", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_key": key.strip(),
+        "p_winning_value": json_value,
+        "p_resolver": AGENT_NAME,
+    })
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_recall(key: Optional[str] = None) -> Dict[str, Any]:

{meshcode-2.11.19 → meshcode-2.11.21}/meshcode/rpc_allowlist.py

@@ -67,6 +67,10 @@ AGENT_CALLABLE_RPCS = [
     "mc_memory_list",
     "mc_memory_search",
     "mc_memory_contradictions",
+    # Mesh-scoped memory (mig 339)
+    "mc_meshwork_remember",
+    "mc_meshwork_recall",
+    "mc_meshwork_resolve_contradiction",
 
     # ── Decisions / outcomes
     "mc_has_open_decision",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.19
+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.19 → 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.19 → meshcode-2.11.21}/pyproject.toml

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