restyle-mcp 0.1.0__py3-none-any.whl

restyle_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: restyle-mcp
+Version: 0.1.0
+Summary: MCP server that restyles a draft into your own voice (runtime persona + local RAG exemplars + deterministic stripper). Style only, never content. One tool: restyle_as_me.
+Requires-Python: >=3.11
+Requires-Dist: anthropic[vertex]>=0.40
+Requires-Dist: fastembed>=0.4
+Requires-Dist: fastmcp>=3.0.2
+Requires-Dist: numpy>=1.26

restyle_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+voice_mcp/__init__.py,sha256=Aw8ad1LWuUjMcXGK3BIeRKVME_QGgOfdl8ru2bYe4gE,3792
+voice_mcp/persona.md,sha256=y_bD1iYIAV61KTMG2nuxGOwp8Avn7yio5VCKX1BkBJE,924
+voice_mcp/rag.py,sha256=rO1fQGr9b3jcRlF8uhts7vNV6KhLlKsLfm1e31rc36M,4278
+voice_mcp/stripper.py,sha256=GGYaN4ZtGreJsUkXmfCFHxpwehhrHkOZ2ATWsqfeqME,1140
+restyle_mcp-0.1.0.dist-info/METADATA,sha256=rKd0cbn-hH2P65J8j5oyZ9QFzdpRA9OHU4ZbdNB66MQ,385
+restyle_mcp-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+restyle_mcp-0.1.0.dist-info/entry_points.txt,sha256=rW5yRrgYVcqmX2Ffeiet5A2NB9-uSeFB0ea8s1Jhg-k,82
+restyle_mcp-0.1.0.dist-info/RECORD,,

restyle_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

restyle_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+voice-mcp = voice_mcp:main
+voice-mcp-index = voice_mcp.rag:main

voice_mcp/__init__.py

@@ -0,0 +1,106 @@
+"""voice-mcp — restyle a draft into Peter's voice. One tool: restyle_as_me.
+
+STYLE ONLY, never content. Composition (facts) stays with the calling
+model (Spark) + a live fact source (zep/KG); this tool only re-voices a
+draft the model already wrote. It returns the styled text so Peter can
+review before sending (review = send). See plans/004 in the voice repo.
+
+Pipeline: RAG-retrieve clean exemplars (local fastembed index) -> fill the
+persona prompt -> Haiku rewrite -> deterministic stripper -> return.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from fastmcp import FastMCP
+
+from .rag import Retriever, format_exemplars
+from .stripper import strip_tells
+
+PKG = Path(__file__).resolve().parent
+PERSONA_PATH = Path(os.environ.get("VOICE_PERSONA") or (PKG / "persona.md"))
+INDEX_PATH = Path(os.environ.get("VOICE_INDEX") or "/data/rag_index.pkl")
+MODEL = os.environ.get("VOICE_MODEL", "claude-haiku-4-5-20251001")
+K = int(os.environ.get("VOICE_K", "6"))
+
+mcp = FastMCP("voice-mcp")
+
+_client = None
+_retriever: Retriever | None = None
+_retriever_tried = False
+
+
+def _persona_template() -> str:
+    # the prompt is the block between the first pair of --- fences
+    return PERSONA_PATH.read_text(encoding="utf-8").split("\n---\n")[1].strip()
+
+
+def _get_client():
+    global _client
+    if _client is None:
+        if os.environ.get("VOICE_ANTHROPIC_BACKEND") == "vertex":
+            # Claude over Google Cloud Vertex AI: keeps inference inside the
+            # GCP perimeter (no personal Anthropic key), auth via ADC. Reads
+            # ANTHROPIC_VERTEX_PROJECT_ID + CLOUD_ML_REGION from the env
+            # (region "global" carries the newest Claude models). Use the
+            # Vertex model id form, e.g. VOICE_MODEL=claude-haiku-4-5@20251001.
+            from anthropic import AnthropicVertex
+            _client = AnthropicVertex()
+        else:
+            from anthropic import Anthropic
+            _client = Anthropic()
+    return _client
+
+
+def _get_retriever() -> Retriever | None:
+    global _retriever, _retriever_tried
+    if not _retriever_tried:
+        _retriever_tried = True
+        if INDEX_PATH.exists():
+            _retriever = Retriever(str(INDEX_PATH))
+    return _retriever
+
+
+def restyle(text: str, channel: str | None = None) -> str:
+    """Plain pipeline (testable): RAG -> persona -> Haiku -> stripper."""
+    text = (text or "").strip()
+    if not text:
+        return text
+    r = _get_retriever()
+    exemplars = format_exemplars(r.retrieve(text, channel, k=K, exclude=(text,))) if r else ""
+    system = _persona_template().replace("{EXEMPLARS}", exemplars or "(no examples available)")
+    msg = _get_client().messages.create(
+        model=MODEL,
+        max_tokens=600,
+        system=system,
+        messages=[{"role": "user",
+                   "content": f"Rewrite this in your voice; keep all facts, change only style:\n\n{text}"}],
+    )
+    return strip_tells(msg.content[0].text.strip())
+
+
+@mcp.tool
+def restyle_as_me(text: str, channel: str | None = None) -> str:
+    """Rewrite a draft message into Peter's voice — STYLE ONLY, never changing
+    facts or content. Use on a draft *before sending*: call this, then show
+    the returned text to Peter and send exactly that (review = send). Pass
+    `channel` ("imessage", "whatsapp", "email", or "linkedin") when known so
+    the register matches. Returns the restyled message text."""
+    return restyle(text, channel)
+
+
+def main() -> None:
+    transport = os.environ.get("MCP_TRANSPORT", "http")
+    if transport == "stdio":
+        mcp.run()
+    else:
+        mcp.run(
+            transport="http",
+            host=os.environ.get("HOST", "0.0.0.0"),
+            port=int(os.environ.get("PORT", "8000")),
+        )
+
+
+if __name__ == "__main__":
+    main()

voice_mcp/persona.md

@@ -0,0 +1,22 @@
+# Restyle persona — default template
+
+Generic default voice prompt for `restyle_as_me`. This ships with the
+package as a neutral fallback; the real persona is supplied at runtime via
+the `VOICE_PERSONA` env var (a private file kept out of git alongside the
+RAG index). The tool replaces `{EXEMPLARS}` with RAG-retrieved real replies
+at call time. No private content lives in this file.
+
+---
+
+You are the author of the draft below, rewriting it into your own voice.
+Embody the author; never break character, never identify as an AI.
+
+YOUR JOB: change only the STYLE. Preserve every fact, name, number, date,
+decision, and intent in the draft exactly. Do not add or remove
+information. Output only the rewritten message, nothing else.
+
+HOW YOU WRITE (real examples of your messages):
+{EXEMPLARS}
+
+Rewrite the draft below in your voice; match the register and rhythm of the
+examples above; keep all facts, change only style.

voice_mcp/rag.py

@@ -0,0 +1,108 @@
+"""Cheap, local exemplar retrieval for restyle_as_me.
+
+No GPU, no hosting, no API: a small ONNX embedder (fastembed) over the
+*clean* corpus, cosine top-k in-memory. The restyle tool is handed a DRAFT
+(Peter's outgoing text), so we index on Peter's REPLIES and query with the
+draft — "here are past messages of yours most like this one" — to fill
+persona.md's {EXEMPLARS}. Index is built locally from ~/voice-corpora and
+shipped to a Railway volume; it is NEVER committed (private correspondence).
+
+  voice-mcp-index build ~/voice-corpora /data/rag_index.pkl
+  voice-mcp-index query ~/voice-corpora/rag_index.pkl "draft text" --channel imessage
+"""
+from __future__ import annotations
+import json, re, pickle, argparse
+from pathlib import Path
+import numpy as np
+
+MODEL = "BAAI/bge-small-en-v1.5"  # ~130MB ONNX, CPU
+AUTO = re.compile(r"upcoming event|Release notes for|has been canceled|RSVP|"
+                  r"Forwarded message|Firebase|invited to test|\u22c5", re.I)
+
+def clean(s: str) -> bool:
+    """Reject contamination: em-dashes (AI tell; Peter is anti-em-dash) and
+    automated/notification/forwarded junk."""
+    return bool(s) and "\u2014" not in s and not AUTO.search(s)
+
+def _embedder():
+    from fastembed import TextEmbedding
+    return TextEmbedding(model_name=MODEL)
+
+def _key(channel: str, text: str) -> str:
+    return f"[{channel}] {text}"
+
+def load_clean_replies(corpora_dir: str):
+    rows = []
+    for ch in ["imessage", "whatsapp", "email", "linkedin"]:
+        p = Path(corpora_dir) / f"{ch}.jsonl"
+        if not p.exists():
+            continue
+        for l in open(p):
+            r = json.loads(l)
+            rep = (r.get("reply") or "").strip()
+            if clean(rep) and 4 <= len(rep) <= 300:
+                rows.append({"reply": rep, "channel": r.get("channel", ch)})
+    # de-dup identical replies (keep first)
+    seen, uniq = set(), []
+    for r in rows:
+        if r["reply"] in seen:
+            continue
+        seen.add(r["reply"]); uniq.append(r)
+    return uniq
+
+def build_index(corpora_dir: str, out: str) -> int:
+    rows = load_clean_replies(corpora_dir)
+    emb = _embedder()
+    vecs = np.array(list(emb.embed([_key(r["channel"], r["reply"]) for r in rows])), dtype=np.float32)
+    vecs /= (np.linalg.norm(vecs, axis=1, keepdims=True) + 1e-9)
+    Path(out).parent.mkdir(parents=True, exist_ok=True)
+    with open(out, "wb") as f:
+        pickle.dump({"rows": rows, "vecs": vecs, "model": MODEL}, f)
+    return len(rows)
+
+class Retriever:
+    def __init__(self, index_path: str):
+        with open(index_path, "rb") as f:
+            d = pickle.load(f)
+        self.rows, self.vecs = d["rows"], d["vecs"]
+        self.emb = _embedder()
+
+    def retrieve(self, draft: str, channel: str | None = None, k: int = 6,
+                 same_channel_bonus: float = 0.04, exclude=()):
+        q = np.array(list(self.emb.embed([_key(channel, draft) if channel else draft]))[0], dtype=np.float32)
+        q /= (np.linalg.norm(q) + 1e-9)
+        sims = self.vecs @ q
+        if channel and same_channel_bonus:
+            sims = sims + np.array([same_channel_bonus if r["channel"] == channel else 0.0
+                                    for r in self.rows], dtype=np.float32)
+        out = []
+        for i in np.argsort(-sims):
+            r = self.rows[i]
+            if r["reply"] in exclude:
+                continue
+            out.append(r)
+            if len(out) >= k:
+                break
+        return out
+
+def format_exemplars(exs) -> str:
+    return "\n".join(f"- {e['reply']}" for e in exs)
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("cmd", choices=["build", "query"])
+    ap.add_argument("arg1")               # build: corpora_dir ; query: index_path
+    ap.add_argument("arg2", nargs="?")    # build: out         ; query: draft text
+    ap.add_argument("--channel")
+    ap.add_argument("-k", type=int, default=6)
+    a = ap.parse_args()
+    if a.cmd == "build":
+        out = a.arg2 or str(Path(a.arg1) / "rag_index.pkl")
+        n = build_index(a.arg1, out)
+        print(f"indexed {n} clean replies -> {out}")
+    else:
+        for e in Retriever(a.arg1).retrieve(a.arg2, a.channel, a.k):
+            print(f'[{e["channel"]}] {e["reply"]}')
+
+if __name__ == "__main__":
+    main()

voice_mcp/stripper.py

@@ -0,0 +1,26 @@
+"""Deterministic, content-preserving stripper — the safety net.
+
+Peter is strictly semicolons, NEVER em-dashes (an AI tell). The persona
+already suppresses em-dashes, but a model can leak one; this guarantees
+none survive. Also drops corporate sign-offs. All transforms are
+mechanical and meaning-preserving — safe to run on outgoing text.
+"""
+from __future__ import annotations
+import re
+
+_SIGNOFFS = (r"Best regards|Kind regards|Warm regards|Best wishes|"
+             r"Best|Regards|Sincerely|Cheers|Warmly|Yours truly|Respectfully")
+
+def strip_tells(s: str) -> str:
+    if not s:
+        return s
+    # em-dash -> semicolon (Peter's join); handles spaced and bare forms.
+    s = re.sub(r"\s*\u2014\s*", "; ", s)
+    s = s.replace("\u2013", "-")          # en-dash -> hyphen (ranges)
+    # tidy doubled/space-before punctuation the swap can create
+    s = re.sub(r";\s*;", ";", s)
+    s = re.sub(r"\s+;", ";", s)
+    s = re.sub(r";\s*([.!?])", r"\1", s)
+    # drop a trailing corporate sign-off block (keep a bare "Peter").
+    s = re.sub(rf"\n+\s*(?:{_SIGNOFFS})[,.!]?\s*(?:\n+.*)?$", "", s, flags=re.I | re.S)
+    return s.strip()