profile-wrap-mcp 0.2.1__tar.gz

profile_wrap_mcp-0.2.1/.gitignore

@@ -0,0 +1,52 @@
+# Fonts and photos never enter the repository
+*.woff
+*.woff2
+*.ttf
+*.otf
+*.eot
+*.jpg
+*.jpeg
+*.heic
+*.heif
+*.tif
+*.tiff
+brand/fonts/
+assets/fonts/
+photos/
+# The OFL demo fonts are the one exception: force-add them (git add -f) and pin their hash in release/leak-allow.json
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+build/
+dist/
+.venv/
+venv/
+
+# Zipapps are built in release, never committed
+*.pyz
+
+# Secrets
+.env
+.env.*
+!.env.example
+token.json
+*.pem
+*.key
+*.p12
+secrets/
+leak-denylist*.json
+
+# Node
+node_modules/
+
+# Local state
+work/
+.DS_Store
+Thumbs.db

profile_wrap_mcp-0.2.1/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.5
+Name: profile-wrap-mcp
+Version: 0.2.1
+Summary: MCP server (stdio) for Profile-Wrap: workspace status, drafts, gate, facts, review state, and posting of board-Allowed drafts only. Not affiliated with LinkedIn.
+Project-URL: Homepage, https://github.com/NJ-Burrito/profile-wrap
+Project-URL: Documentation, https://github.com/NJ-Burrito/profile-wrap/blob/main/docs/MCP.md
+Project-URL: Issues, https://github.com/NJ-Burrito/profile-wrap/issues
+Author: profile-wrap contributors
+License: MIT
+Keywords: bilingual,content,mcp,model-context-protocol,official-api,profile-wrap
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: mcp<3,>=2.3
+Requires-Dist: profile-wrap<0.3,>=0.2.0
+Description-Content-Type: text/markdown
+
+# profile-wrap-mcp
+
+<!-- mcp-name: io.github.NJ-Burrito/profile-wrap-mcp -->
+mcp-name: io.github.NJ-Burrito/profile-wrap-mcp
+
+A stdio [MCP](https://modelcontextprotocol.io) server for a [Profile-Wrap](https://github.com/NJ-Burrito/profile-wrap) workspace.
+It lets an MCP client (Claude Code, Codex, any other) check the workspace, draft a post from a topic, run the
+fact gate, manage unverified facts and read the review board. It can also post, but **only a draft a person
+already pressed Allow on, on the review board**.
+
+Independent, open source (MIT). **Not affiliated with LinkedIn.** The server talks to LinkedIn only through the
+official API with your own developer app, and only inside `post_allowed`.
+
+## Tools
+
+| Tool | What it does | Writes |
+|---|---|---|
+| `workspace_status` | posting mode, pauses and stops, 20 h gap, token state, draft counts, posts today | nothing |
+| `calendar_list` | content-calendar entries, optional status filter | nothing |
+| `draft_create` | new text draft from a topic with your chosen provider; verified facts only; state `draft` | `drafts/<slug>/` |
+| `gate_run` | the deterministic gate on a draft (numbers, claims, language, banned patterns) | `gates.json` |
+| `facts_list` | the fact register with each fact's status | nothing |
+| `facts_add` | adds a fact as **unverified**; a person verifies it in a terminal | `research/facts.md` |
+| `review_state` | review-board state of one draft or all, and whether it was Allowed | nothing |
+| `post_allowed` | posts one board-Allowed draft; `confirm=false` (default) is a dry run | ledger, draft status |
+
+Resources: `pw://calendar`, `pw://drafts`, `pw://drafts/{slug}`.
+
+## Safety
+
+- `post_allowed` refuses every state except `allowed` (draft, revising, hold, rejected, needs_check, missed, posted, demo),
+  and refuses an `allowed` status that has no board Allow as the latest entry in the review history.
+- It calls `profile_wrap.linkedin.post.publish`, the same function as `profile-wrap post --now`: gate PASS, 20 h gap,
+  one post a day, posting lock, 429/403 stop, pauses, and the ledger row written before anything is sent.
+- No tool reads direct messages, sends connection invitations, comments, likes or verifies a fact.
+- No key or token is ever returned. `draft_create` sends the topic and your verified facts to the provider you chose.
+
+## Install
+
+```bash
+uvx profile-wrap-mcp --workspace /path/to/your/workspace
+claude mcp add profile-wrap -- uvx profile-wrap-mcp --workspace /path/to/your/workspace
+```
+
+Without `--workspace` the server uses `PROFILE_WRAP_WORKSPACE`, then the usual Profile-Wrap lookup.
+More: [docs/MCP.md](https://github.com/NJ-Burrito/profile-wrap/blob/main/docs/MCP.md).

profile_wrap_mcp-0.2.1/README.md

@@ -0,0 +1,46 @@
+# profile-wrap-mcp
+
+<!-- mcp-name: io.github.NJ-Burrito/profile-wrap-mcp -->
+mcp-name: io.github.NJ-Burrito/profile-wrap-mcp
+
+A stdio [MCP](https://modelcontextprotocol.io) server for a [Profile-Wrap](https://github.com/NJ-Burrito/profile-wrap) workspace.
+It lets an MCP client (Claude Code, Codex, any other) check the workspace, draft a post from a topic, run the
+fact gate, manage unverified facts and read the review board. It can also post, but **only a draft a person
+already pressed Allow on, on the review board**.
+
+Independent, open source (MIT). **Not affiliated with LinkedIn.** The server talks to LinkedIn only through the
+official API with your own developer app, and only inside `post_allowed`.
+
+## Tools
+
+| Tool | What it does | Writes |
+|---|---|---|
+| `workspace_status` | posting mode, pauses and stops, 20 h gap, token state, draft counts, posts today | nothing |
+| `calendar_list` | content-calendar entries, optional status filter | nothing |
+| `draft_create` | new text draft from a topic with your chosen provider; verified facts only; state `draft` | `drafts/<slug>/` |
+| `gate_run` | the deterministic gate on a draft (numbers, claims, language, banned patterns) | `gates.json` |
+| `facts_list` | the fact register with each fact's status | nothing |
+| `facts_add` | adds a fact as **unverified**; a person verifies it in a terminal | `research/facts.md` |
+| `review_state` | review-board state of one draft or all, and whether it was Allowed | nothing |
+| `post_allowed` | posts one board-Allowed draft; `confirm=false` (default) is a dry run | ledger, draft status |
+
+Resources: `pw://calendar`, `pw://drafts`, `pw://drafts/{slug}`.
+
+## Safety
+
+- `post_allowed` refuses every state except `allowed` (draft, revising, hold, rejected, needs_check, missed, posted, demo),
+  and refuses an `allowed` status that has no board Allow as the latest entry in the review history.
+- It calls `profile_wrap.linkedin.post.publish`, the same function as `profile-wrap post --now`: gate PASS, 20 h gap,
+  one post a day, posting lock, 429/403 stop, pauses, and the ledger row written before anything is sent.
+- No tool reads direct messages, sends connection invitations, comments, likes or verifies a fact.
+- No key or token is ever returned. `draft_create` sends the topic and your verified facts to the provider you chose.
+
+## Install
+
+```bash
+uvx profile-wrap-mcp --workspace /path/to/your/workspace
+claude mcp add profile-wrap -- uvx profile-wrap-mcp --workspace /path/to/your/workspace
+```
+
+Without `--workspace` the server uses `PROFILE_WRAP_WORKSPACE`, then the usual Profile-Wrap lookup.
+More: [docs/MCP.md](https://github.com/NJ-Burrito/profile-wrap/blob/main/docs/MCP.md).

profile_wrap_mcp-0.2.1/glama.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://glama.ai/mcp/schemas/server.json",
+  "maintainers": ["NJ-Burrito"]
+}

profile_wrap_mcp-0.2.1/profile_wrap_mcp/__init__.py

@@ -0,0 +1,7 @@
+"""profile-wrap-mcp: a stdio MCP server over a Profile-Wrap workspace.
+
+Independent open-source tool, not affiliated with LinkedIn. It reads and drafts; the only tool that
+can reach LinkedIn is ``post_allowed``, and it refuses every draft a person has not Allowed on the
+review board.
+"""
+__version__ = "0.1.0"

profile_wrap_mcp-0.2.1/profile_wrap_mcp/__main__.py

@@ -0,0 +1,4 @@
+from .server import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

profile_wrap_mcp-0.2.1/profile_wrap_mcp/core.py

@@ -0,0 +1,261 @@
+"""The tool logic, free of any MCP types, so it can be tested directly and through a client.
+
+Nothing here reads DMs or sends invitations. The one outbound path to LinkedIn is
+``profile_wrap.linkedin.post.publish`` (called from ``post_allowed``); there is no second posting path.
+"""
+from __future__ import annotations
+
+import datetime as _dt
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+from profile_wrap import config as config_mod
+from profile_wrap import ledger, limits
+from profile_wrap.atomic import atomic_write_json, atomic_write_text
+from profile_wrap.board.security import SLUG_RE
+from profile_wrap.board.store import BoardStore
+from profile_wrap.facts import registers as reg
+from profile_wrap.fsutil import is_inside
+from profile_wrap.gate.claims import facts_path
+from profile_wrap.linkedin import auth, post
+from profile_wrap.plan import calendar as cal_mod
+from profile_wrap.providers import ProviderError, get_provider
+from profile_wrap.providers import settings as prov_settings
+
+MAX_POSTS_PER_DAY = 1
+MAX_TOPIC = 400
+MAX_CAPTION = 3000
+
+# Review-board state names shown to the model. "allowed" is the board's "queued" (set only by a
+# person pressing Allow, after a gate PASS).
+STATE_NAMES = {"queued": "allowed", "draft": "draft", "revising": "revising", "hold": "hold",
+               "missed": "missed", "needs_check": "needs_check", "posted": "posted",
+               "rejected": "rejected", "demo": "demo"}
+
+
+@dataclass
+class Context:
+    ws: Path
+    gate_fn: Optional[Callable[..., Dict[str, Any]]] = None      # default: the real gate
+    client: Any = None                                           # default: a real LinkedIn client
+    provider_factory: Callable[..., Any] = get_provider
+    now: Optional[Callable[[], _dt.datetime]] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+    def cfg(self) -> Dict[str, Any]:
+        return config_mod.load(self.ws)
+
+    def gate(self, slug: str, write: bool = True) -> Dict[str, Any]:
+        if self.gate_fn is not None:
+            return self.gate_fn(slug, self.ws, write)
+        return post.default_gate(slug, self.ws, write)
+
+
+class ToolRefused(Exception):
+    """A request was refused on purpose. The message is safe to show the model."""
+
+
+def _slug(slug: str) -> str:
+    if not isinstance(slug, str) or not SLUG_RE.match(slug):
+        raise ToolRefused("slug must be lowercase letters, digits and hyphens (1-100 characters)")
+    return slug
+
+
+def _draft_dir(ctx: Context, slug: str) -> Path:
+    d = ctx.ws / "drafts" / _slug(slug)
+    if not is_inside(d, ctx.ws) or not (d / "meta.json").is_file():
+        raise ToolRefused(f"no draft '{slug}'")
+    return d
+
+
+def _meta(d: Path) -> Dict[str, Any]:
+    try:
+        data = json.loads((d / "meta.json").read_text(encoding="utf-8-sig"))
+    except (OSError, ValueError):
+        return {"status": "unreadable"}
+    return data if isinstance(data, dict) else {"status": "unreadable"}
+
+
+def _now(ctx: Context) -> Optional[_dt.datetime]:
+    return ctx.now() if ctx.now else None
+
+
+# ------------------------------------------------------------------ workspace_status
+
+def workspace_status(ctx: Context) -> Dict[str, Any]:
+    cfg = ctx.cfg()
+    modes = config_mod.effective_modes(cfg, ctx.ws)
+    counts: Dict[str, int] = {}
+    for p in sorted((ctx.ws / "drafts").glob("*/meta.json")):
+        st = STATE_NAMES.get(str(_meta(p.parent).get("status")), "unreadable")
+        counts[st] = counts.get(st, 0) + 1
+    last = ledger.last_activity(ctx.ws)
+    tok = auth.token_status(auth.secrets_dir(cfg), int(cfg["linkedin"]["token_warn_days"]))
+    return {"workspace": str(ctx.ws), "posting_mode": modes["posting"], "paused": limits.pause_flags(ctx.ws),
+            "stop": post.stop_active(ctx.ws), "gap_problem": post.gap_problem(ctx.ws, cfg, _now(ctx)),
+            "token": {"state": tok["state"], "days_left": tok["days_left"]},
+            "drafts_by_state": counts, "ledger_rows": len(ledger.entries(ctx.ws)),
+            "last_post_activity": last.isoformat() if last else None,
+            "posts_today": ledger.posts_today(ctx.ws), "max_posts_per_day": MAX_POSTS_PER_DAY}
+
+
+# ------------------------------------------------------------------ calendar
+
+def calendar_list(ctx: Context, status: Optional[str] = None, limit: int = 60) -> Dict[str, Any]:
+    try:
+        entries = cal_mod.load(ctx.ws)["entries"]
+    except cal_mod.CalendarError as exc:
+        raise ToolRefused(str(exc)) from exc
+    if status:
+        entries = [e for e in entries if e.get("status") == status]
+    limit = max(1, min(int(limit), 365))
+    return {"count": len(entries), "entries": entries[:limit]}
+
+
+# ------------------------------------------------------------------ facts
+
+def facts_list(ctx: Context, status: Optional[str] = None) -> Dict[str, Any]:
+    register = reg.load_register(facts_path(ctx.ws, ctx.cfg()), "fact")
+    rows = [{"id": e.id, "claim": e.text, "numbers": e.numbers_raw, "source": e.source,
+             "status": e.status} for e in register.entries if not status or e.status == status]
+    return {"count": len(rows), "facts": rows, "problems": register.problems}
+
+
+def facts_add(ctx: Context, claim: str, source: str, numbers: str = "") -> Dict[str, Any]:
+    """Adds an UNVERIFIED fact (status draft). Verification is a human step in a terminal."""
+    try:
+        e = reg.add_entry(facts_path(ctx.ws, ctx.cfg()), "fact", text=claim, numbers=numbers, source=source)
+    except ValueError as exc:
+        raise ToolRefused(str(exc)) from exc
+    return {"id": e.id, "status": e.status,
+            "next": f"A person verifies it: profile-wrap facts verify {e.id} --evidence <path|url>. "
+                    "Drafts cannot cite it until then."}
+
+
+# ------------------------------------------------------------------ draft_create
+
+def _slugify(text: str, today: _dt.date) -> str:
+    base = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")[:60].strip("-") or "draft"
+    return f"{base}-{today.isoformat()}"
+
+
+def draft_create(ctx: Context, topic: str, lang: str = "en", slug: Optional[str] = None) -> Dict[str, Any]:
+    topic = (topic or "").strip()
+    if not topic or len(topic) > MAX_TOPIC:
+        raise ToolRefused(f"topic is required and must be at most {MAX_TOPIC} characters")
+    cfg = ctx.cfg()
+    today = (ctx.now() if ctx.now else _dt.datetime.now(_dt.timezone.utc)).date()
+    slug = _slug(slug) if slug else _slugify(topic, today)
+    if not SLUG_RE.match(slug):
+        slug = f"draft-{today.isoformat()}"
+    folder = ctx.ws / "drafts" / slug
+    if folder.exists():
+        raise ToolRefused(f"draft '{slug}' already exists; nothing was overwritten")
+    chosen = prov_settings.load(ctx.ws)
+    if not chosen.get("provider"):
+        raise ToolRefused("no provider is chosen yet: run 'profile-wrap providers use <id>'")
+    verified = [e for e in reg.load_register(facts_path(ctx.ws, cfg), "fact").entries
+                if e.status == "verified"]
+    facts_txt = "\n".join(f"- {e.id}: {e.text} ({e.numbers_raw})" for e in verified) or "(none)"
+    persona = cfg.get("persona", {})
+    system = ("You write one LinkedIn post caption. Plain text, short lines, no em dashes. "
+              "Use ONLY the verified facts below for any claim or number about the author; never invent "
+              "numbers, results or stories. Reply with the caption text only.\n"
+              f"Language: {lang}. Author: {persona.get('name') or 'the author'}, {persona.get('role') or ''}.\n"
+              f"Verified facts:\n{facts_txt}")
+    try:
+        provider = ctx.provider_factory(chosen["provider"], chosen.get("model"), chosen.get("base_url"))
+        result = provider.complete(system, [{"role": "user", "content": f"Topic: {topic}"}], max_tokens=700)
+    except ProviderError as exc:
+        raise ToolRefused(f"provider failed ({exc.kind}): {exc}") from exc
+    caption = (result.text or "").strip()
+    if not caption:
+        raise ToolRefused("the provider returned no text; nothing was written")
+    caption = caption[:MAX_CAPTION]
+    pillars = persona.get("pillars") or [{"id": "P1"}]
+    meta = {"schema_version": 1, "slug": slug, "title": topic[:120], "lang": lang, "format": "text",
+            "pillar": str(pillars[0].get("id", "P1")), "status": "draft", "claims": [],
+            "created_by": "profile-wrap-mcp", "provider": result.provider, "model": result.model}
+    folder.mkdir(parents=True)
+    atomic_write_text(folder / "caption.txt", caption + "\n")
+    atomic_write_json(folder / "meta.json", meta)
+    gate = ctx.gate(slug, False)
+    return {"slug": slug, "status": "draft", "provider": result.provider, "model": result.model,
+            "caption": caption, "gate_preview": gate.get("summary"),
+            "next": "A person reviews it and presses Allow on the board. Nothing was posted."}
+
+
+# ------------------------------------------------------------------ gate_run
+
+def gate_run(ctx: Context, slug: str) -> Dict[str, Any]:
+    _draft_dir(ctx, slug)
+    res = ctx.gate(slug, True)
+    return {"slug": slug, "summary": res.get("summary"), "fails": res.get("fails", []),
+            "warnings": res.get("warnings", [])}
+
+
+# ------------------------------------------------------------------ review_state
+
+def _allowed_by_board(ctx: Context, d: Path, meta: Dict[str, Any]) -> Optional[str]:
+    """None when a person Allowed this draft on the board; otherwise the reason it did not happen."""
+    if meta.get("status") != "queued":
+        return f"state is '{STATE_NAMES.get(str(meta.get('status')), meta.get('status'))}', not 'allowed'"
+    hist = BoardStore(ctx.ws).history(d)
+    last = hist[-1] if hist else None
+    if not last or last.get("action") != "allow" or last.get("to") != "queued":
+        return "the review history has no board Allow as its latest decision"
+    return None
+
+
+def review_state(ctx: Context, slug: Optional[str] = None) -> Dict[str, Any]:
+    dirs = [_draft_dir(ctx, slug)] if slug else sorted(
+        p.parent for p in (ctx.ws / "drafts").glob("*/meta.json") if SLUG_RE.match(p.parent.name))
+    out = []
+    store = BoardStore(ctx.ws)
+    for d in dirs:
+        meta = _meta(d)
+        hist = store.history(d)
+        why = _allowed_by_board(ctx, d, meta)
+        out.append({"slug": d.name, "state": STATE_NAMES.get(str(meta.get("status")), "unreadable"),
+                    "allowed_on_board": why is None, "not_allowed_because": why,
+                    "last_decision": hist[-1] if hist else None,
+                    "scheduled_at": meta.get("scheduled_at")})
+    return {"count": len(out), "drafts": out}
+
+
+# ------------------------------------------------------------------ post_allowed
+
+def post_allowed(ctx: Context, slug: str, confirm: bool = False) -> Dict[str, Any]:
+    """Post one draft a person already Allowed. confirm=false returns the dry-run plan only."""
+    d = _draft_dir(ctx, slug)
+    why = _allowed_by_board(ctx, d, _meta(d))
+    if why:
+        return {"status": "refused", "kind": "not_allowed", "slug": slug,
+                "reason": f"only drafts Allowed on the review board can be posted: {why}"}
+    cfg = ctx.cfg()
+    if ledger.posts_today(ctx.ws) >= MAX_POSTS_PER_DAY:
+        return {"status": "refused", "kind": "daily_cap", "slug": slug,
+                "reason": f"daily cap reached: at most {MAX_POSTS_PER_DAY} post a day"}
+    if not confirm:
+        plan = post.plan(ctx.ws, slug, cfg, gate_fn=ctx.gate_fn)
+        return {"status": "dry", "slug": slug, "plan": plan,
+                "reason": "nothing was sent. Call again with confirm=true to post."}
+    out = post.publish(ctx.ws, slug, cfg, by="mcp", client=ctx.client, gate_fn=ctx.gate_fn,
+                       now=_now(ctx), require_status="queued")
+    return out.as_dict()
+
+
+# ------------------------------------------------------------------ resources
+
+def read_draft(ctx: Context, slug: str) -> Dict[str, Any]:
+    d = _draft_dir(ctx, slug)
+    cap = d / "caption.txt"
+    return {"slug": slug, "meta": _meta(d),
+            "caption": cap.read_text(encoding="utf-8-sig") if cap.is_file() else ""}
+
+
+def list_drafts(ctx: Context) -> Dict[str, Any]:
+    return review_state(ctx)

profile_wrap_mcp-0.2.1/profile_wrap_mcp/server.py

@@ -0,0 +1,153 @@
+"""The MCP server: tool and resource wiring over ``core``. stdio transport only."""
+from __future__ import annotations
+
+import argparse
+import functools
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from mcp.server.mcpserver import MCPServer
+from mcp_types import ToolAnnotations
+
+from . import __version__, core
+from .core import Context
+
+INSTRUCTIONS = (
+    "Profile-Wrap workspace tools. Independent open-source tool, not affiliated with LinkedIn. "
+    "Everything is read-only or draft-only except post_allowed, which posts a draft ONLY when a person "
+    "has already pressed Allow on the review board. No tool reads direct messages or sends "
+    "connection invitations. Facts you add are unverified until a person verifies them."
+)
+
+READ = ToolAnnotations(readOnlyHint=True, openWorldHint=False)
+WRITE_LOCAL = ToolAnnotations(readOnlyHint=False, destructiveHint=False, openWorldHint=False)
+POSTS = ToolAnnotations(readOnlyHint=False, destructiveHint=False, idempotentHint=False, openWorldHint=True)
+
+
+def _explained(fn):
+    """A deliberate refusal becomes a readable result; the SDK would otherwise mask it as a bare error."""
+    @functools.wraps(fn)
+    def run(*a, **k):
+        try:
+            return fn(*a, **k)
+        except core.ToolRefused as exc:
+            return {"status": "refused", "reason": str(exc)}
+    return run
+
+
+def build_server(ctx: Context) -> MCPServer:
+    app = MCPServer("profile-wrap", instructions=INSTRUCTIONS, version=__version__)
+    tool = app.tool
+
+    @tool(annotations=READ)
+    @_explained
+    def workspace_status() -> Dict[str, Any]:
+        """Summarise the Profile-Wrap workspace: posting mode, pauses and stops, the 20 h gap guard,
+        token state (never the token), draft counts by review state, and how many posts went out today.
+        Read-only; makes no network call."""
+        return core.workspace_status(ctx)
+
+    @tool(annotations=READ)
+    @_explained
+    def calendar_list(status: Optional[str] = None, limit: int = 60) -> Dict[str, Any]:
+        """List content-calendar entries (planned, built, posted, skipped, blocked), optionally
+        filtered by status. Read-only."""
+        return core.calendar_list(ctx, status, limit)
+
+    @tool(annotations=WRITE_LOCAL)
+    @_explained
+    def draft_create(topic: str, lang: str = "en", slug: Optional[str] = None) -> Dict[str, Any]:
+        """Create a new text draft from a topic using the provider chosen with 'profile-wrap providers use'.
+        The model sees only VERIFIED facts and is told not to invent numbers. The draft starts in state
+        'draft'; it never overwrites an existing draft, is never queued, and nothing is posted. The topic
+        is sent to the chosen provider (your own key, or your local claude CLI)."""
+        return core.draft_create(ctx, topic, lang, slug)
+
+    @tool(annotations=WRITE_LOCAL)
+    @_explained
+    def gate_run(slug: str) -> Dict[str, Any]:
+        """Run the deterministic gate (numbers, claims, language, banned patterns) on drafts/<slug> and
+        record gates.json. Returns PASS or FAIL with the failing lines. Local only; no model, no network."""
+        return core.gate_run(ctx, slug)
+
+    @tool(annotations=READ)
+    @_explained
+    def facts_list(status: Optional[str] = None) -> Dict[str, Any]:
+        """List the fact register (id, claim, numbers, source, status: draft or verified). Only
+        verified facts may back a number in a post. Read-only."""
+        return core.facts_list(ctx, status)
+
+    @tool(annotations=WRITE_LOCAL)
+    @_explained
+    def facts_add(claim: str, source: str, numbers: str = "") -> Dict[str, Any]:
+        """Add one fact as UNVERIFIED (status draft). It cannot back a post until a person verifies it
+        in a terminal ('profile-wrap facts verify'). This server has no verify tool, by design."""
+        return core.facts_add(ctx, claim, source, numbers)
+
+    @tool(annotations=READ)
+    @_explained
+    def review_state(slug: Optional[str] = None) -> Dict[str, Any]:
+        """Show the review-board state of one draft (or all): draft, revising, hold, allowed, rejected,
+        needs_check, missed, posted, demo; whether a person Allowed it on the board; the last board
+        decision. 'allowed' is the only state post_allowed accepts. Read-only."""
+        return core.review_state(ctx, slug)
+
+    @tool(annotations=POSTS)
+    @_explained
+    def post_allowed(slug: str, confirm: bool = False) -> Dict[str, Any]:
+        """Post ONE draft to LinkedIn through the official API, but only if a person already pressed Allow
+        on the review board. Refuses draft, revising, hold, rejected, needs_check, missed, posted and demo
+        drafts, and refuses an 'allowed' status that lacks a board Allow in its review history. Also
+        enforces the gate PASS, the 20 hour gap between posts, the 1 post a day cap, the posting lock, a
+        429/403 stop, pauses, and writes the ledger row before anything is sent. With confirm=false (the
+        default) it returns the dry-run plan and sends nothing. This is the only tool that can reach LinkedIn."""
+        return core.post_allowed(ctx, slug, confirm)
+
+    @app.resource("pw://calendar", mime_type="application/json")
+    def calendar_resource() -> str:
+        """The content calendar (strategy/calendar.json)."""
+        return json.dumps(core.calendar_list(ctx, None, 365), ensure_ascii=False, indent=2)
+
+    @app.resource("pw://drafts", mime_type="application/json")
+    def drafts_resource() -> str:
+        """Every draft with its review-board state."""
+        return json.dumps(core.list_drafts(ctx), ensure_ascii=False, indent=2)
+
+    @app.resource("pw://drafts/{slug}", mime_type="application/json")
+    def draft_resource(slug: str) -> str:
+        """One draft: meta.json and caption.txt."""
+        return json.dumps(core.read_draft(ctx, slug), ensure_ascii=False, indent=2)
+
+    return app
+
+
+def resolve_workspace(arg: Optional[str]) -> Path:
+    if arg:
+        return Path(arg).expanduser().resolve()
+    from profile_wrap.gate.config import resolve_workspace as _resolve
+    return _resolve(None)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    p = argparse.ArgumentParser(prog="profile-wrap-mcp",
+                                description="stdio MCP server over a Profile-Wrap workspace (not affiliated with LinkedIn)")
+    p.add_argument("--workspace", help="workspace folder (default: PROFILE_WRAP_WORKSPACE, else the usual lookup)")
+    p.add_argument("--version", action="store_true")
+    args = p.parse_args(argv)
+    if args.version:
+        print(__version__)
+        return 0
+    ws = resolve_workspace(args.workspace)
+    if not ws.is_dir():
+        print(f"profile-wrap-mcp: workspace not found: {ws}", file=sys.stderr)
+        return 2
+    os.environ.setdefault("PYTHONUTF8", "1")
+    build_server(Context(ws=ws)).run("stdio")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

profile_wrap_mcp-0.2.1/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "profile-wrap-mcp"
+version = "0.2.1"
+description = "MCP server (stdio) for Profile-Wrap: workspace status, drafts, gate, facts, review state, and posting of board-Allowed drafts only. Not affiliated with LinkedIn."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "profile-wrap contributors" }]
+keywords = ["mcp", "model-context-protocol", "profile-wrap", "content", "official-api", "bilingual"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: MacOS",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+]
+dependencies = [
+  "profile_wrap>=0.2.0,<0.3",
+  "mcp>=2.3,<3",
+]
+
+[project.urls]
+Homepage = "https://github.com/NJ-Burrito/profile-wrap"
+Documentation = "https://github.com/NJ-Burrito/profile-wrap/blob/main/docs/MCP.md"
+Issues = "https://github.com/NJ-Burrito/profile-wrap/issues"
+
+[project.scripts]
+profile-wrap-mcp = "profile_wrap_mcp.server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["profile_wrap_mcp"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"