meshcode 2.11.84__tar.gz → 2.11.85__tar.gz

{meshcode-2.11.84 → meshcode-2.11.85}/PKG-INFO

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

{meshcode-2.11.84 → meshcode-2.11.85}/meshcode/__init__.py

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

meshcode-2.11.85/meshcode/_session_handoff_template.py

@@ -0,0 +1,245 @@
+"""Session-handoff hook templates — single source of truth for the
+PreCompact (write) + SessionStart (read) hooks.
+
+CTX-CLOSE-RELAUNCH (task bcd157a9, backend2): when a commander/agent session
+gets recycled at high context — either by Claude Code's in-place autocompact
+or by a clean close+relaunch — the IN-FLIGHT working context (which task I was
+mid-executing, what I just edited/decided this session) is lost. meshcode_boot
+restores mesh state (tasks, inbox, memory) authoritatively, but NOT the
+conversational thread. These two hooks bridge that gap:
+
+  * PreCompact  -> session_handoff_write.py: dump a compact snapshot of the
+    recent transcript tail to .claude/handoff.json BEFORE the context is
+    compacted/the session exits. Pure local file I/O — no creds, no network,
+    no MCP — so it is safe to run in any hook subprocess on any platform.
+  * SessionStart -> session_handoff_read.py: on the next (fresh) session,
+    inject that snapshot back as additionalContext so the agent resumes the
+    thread, then archive it so it is injected exactly once.
+
+Stored as string constants (same pattern as _stop_hook_template.py) so
+`meshcode patch-hooks` can backfill existing workspaces without a full
+re-scaffold. The recycle TRIGGER itself (mc_request_recycle / wait-loop
+must_exit=recycle / hostd context branch) is owned by the daemon/server side
+and is intentionally NOT in these scripts — handoff preservation is decoupled
+from whatever causes the restart, so it works for autocompact, clean recycle,
+crash-respawn, or a manual relaunch alike.
+"""
+
+# Shared constants kept in sync between the two bodies.
+_HANDOFF_FILENAME = "handoff.json"
+_HANDOFF_MAX_TURNS = 24          # transcript tail entries to preserve
+_HANDOFF_MAX_CHARS_PER_TURN = 1200
+_HANDOFF_MAX_AGE_S = 24 * 3600   # ignore stale handoffs on read
+
+HANDOFF_WRITE_BODY = '''#!/usr/bin/env python3
+"""PreCompact hook: snapshot the recent transcript tail to .claude/handoff.json
+so a fresh post-recycle session can resume the in-flight thread.
+
+CTX-CLOSE-RELAUNCH (task bcd157a9). Pure local file I/O — never touches the
+network, never imports meshcode, never blocks. Any failure is swallowed and the
+hook exits 0 so it can NEVER stall or break a Claude Code compaction/exit.
+
+Claude Code passes a JSON event on stdin:
+  {"hook_event_name":"PreCompact","session_id":..,"transcript_path":..,
+   "trigger":"auto"|"manual", ...}
+"""
+import json
+import os
+import sys
+from pathlib import Path
+
+MAX_TURNS = 24
+MAX_CHARS_PER_TURN = 1200
+
+
+def _project_dir() -> Path:
+    # Claude Code exports CLAUDE_PROJECT_DIR for hooks; fall back to cwd.
+    return Path(os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd())
+
+
+def _text_from_message(msg) -> str:
+    """Flatten a transcript message's content into plain text + tool markers."""
+    if isinstance(msg, str):
+        return msg
+    if not isinstance(msg, dict):
+        return ""
+    content = msg.get("content")
+    if isinstance(content, str):
+        return content
+    parts = []
+    if isinstance(content, list):
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            btype = block.get("type")
+            if btype == "text" and block.get("text"):
+                parts.append(str(block["text"]))
+            elif btype == "tool_use":
+                parts.append(f"[tool_use:{block.get('name','?')}]")
+            elif btype == "tool_result":
+                parts.append("[tool_result]")
+    return " ".join(parts).strip()
+
+
+def _extract_tail(transcript_path: str):
+    """Return up to MAX_TURNS (role, text) tuples from the end of the JSONL
+    transcript, skipping empty / meta-only entries."""
+    p = Path(transcript_path) if transcript_path else None
+    if not p or not p.exists():
+        return []
+    rows = []
+    try:
+        with p.open("r", encoding="utf-8", errors="replace") as fh:
+            for line in fh:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                except (json.JSONDecodeError, ValueError):
+                    continue
+                msg = obj.get("message") if isinstance(obj, dict) else None
+                role = (obj.get("type") or (msg or {}).get("role") or "").strip()
+                if role not in ("user", "assistant", "human"):
+                    continue
+                text = _text_from_message(msg if msg is not None else obj)
+                if not text:
+                    continue
+                if len(text) > MAX_CHARS_PER_TURN:
+                    text = text[:MAX_CHARS_PER_TURN] + " …[truncated]"
+                rows.append(("user" if role in ("user", "human") else "assistant", text))
+    except OSError:
+        return []
+    return rows[-MAX_TURNS:]
+
+
+def main() -> int:
+    try:
+        raw = sys.stdin.read()
+        event = json.loads(raw) if raw.strip() else {}
+    except (json.JSONDecodeError, ValueError):
+        event = {}
+
+    tail = _extract_tail(event.get("transcript_path", ""))
+    handoff = {
+        "schema": 1,
+        "session_id": event.get("session_id"),
+        "trigger": event.get("trigger") or event.get("hook_event_name") or "precompact",
+        "agent": os.environ.get("MESHCODE_AGENT"),
+        "project": os.environ.get("MESHCODE_PROJECT"),
+        "turns": [{"role": r, "text": t} for (r, t) in tail],
+    }
+    try:
+        d = _project_dir() / ".claude"
+        d.mkdir(parents=True, exist_ok=True)
+        tmp = d / "handoff.json.tmp"
+        tmp.write_text(json.dumps(handoff, ensure_ascii=False, indent=2), encoding="utf-8")
+        tmp.replace(d / "handoff.json")
+    except OSError as e:
+        sys.stderr.write(f"[session_handoff_write] skipped: {e}\\n")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as e:  # never break compaction
+        sys.stderr.write(f"[session_handoff_write] error: {e}\\n")
+        sys.exit(0)
+'''
+
+HANDOFF_READ_BODY = '''#!/usr/bin/env python3
+"""SessionStart hook: if a handoff snapshot exists, inject it as
+additionalContext so a freshly-recycled session resumes the in-flight thread,
+then archive it so it is injected exactly once.
+
+CTX-CLOSE-RELAUNCH (task bcd157a9). Pure local file I/O — no network, no
+meshcode import, never blocks. meshcode_boot remains authoritative for mesh
+state; this only restores the conversational thread.
+
+Claude Code passes a JSON event on stdin:
+  {"hook_event_name":"SessionStart","source":"startup"|"resume"|"compact",..}
+and reads our additionalContext from this hook's stdout JSON:
+  {"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":..}}
+"""
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+MAX_AGE_S = 24 * 3600
+
+
+def _project_dir() -> Path:
+    return Path(os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd())
+
+
+def _emit(context: str) -> None:
+    sys.stdout.write(json.dumps({
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": context,
+        }
+    }))
+
+
+def _render(handoff: dict) -> str:
+    turns = handoff.get("turns") or []
+    if not turns:
+        return ""
+    lines = [
+        "## Recovered session handoff (CTX-CLOSE-RELAUNCH)",
+        "",
+        "Your previous session was recycled at high context. meshcode_boot has "
+        "the authoritative mesh state (tasks/inbox/memory); the thread tail "
+        "below is the in-flight context that boot does not restore. Use it to "
+        "resume what you were mid-doing, then run the normal boot loop.",
+        "",
+        f"_trigger: {handoff.get('trigger','?')} · turns preserved: {len(turns)}_",
+        "",
+    ]
+    for t in turns:
+        role = (t.get("role") or "?").upper()
+        text = (t.get("text") or "").strip()
+        if text:
+            lines.append(f"**{role}:** {text}")
+            lines.append("")
+    return "\\n".join(lines).strip()
+
+
+def main() -> int:
+    path = _project_dir() / ".claude" / "handoff.json"
+    if not path.exists():
+        return 0
+    try:
+        handoff = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, ValueError, OSError):
+        return 0
+
+    # Ignore stale snapshots (mtime-based; avoids resurrecting old threads).
+    try:
+        if (time.time() - path.stat().st_mtime) > MAX_AGE_S:
+            path.replace(path.with_suffix(".stale.json"))
+            return 0
+    except OSError:
+        pass
+
+    context = _render(handoff)
+    if context:
+        _emit(context)
+    # Archive so the handoff is injected exactly once.
+    try:
+        path.replace(path.with_suffix(".consumed.json"))
+    except OSError:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as e:
+        sys.stderr.write(f"[session_handoff_read] error: {e}\\n")
+        sys.exit(0)
+'''