stndp-cli 0.1.0__py3-none-any.whl

stndp/mcp_server.py

@@ -0,0 +1,582 @@
+"""A local stdio MCP server bundled in the CLI (`stn mcp`).
+
+Lets a coding agent (Claude Code, Codex, Copilot, …) read and write the shared
+context graph through typed tools — no hosted server and no second login: it reuses
+the user's `stn login` token via the CLI's HTTP client. One line of agent config
+(`{"command": "stn", "args": ["mcp"]}`) is the entire integration; `stn agent setup`
+writes it for you.
+
+A minimal, spec-compliant JSON-RPC 2.0 server over newline-delimited stdio:
+`initialize`, `tools/list`, `tools/call`, `ping`. Tool descriptions are
+**prescriptive about when to call them**, because recent models under-reach for
+tools without an explicit trigger — that's what drives agents to log decisions and
+checkpoints as a byproduct of work rather than on request.
+"""
+from __future__ import annotations
+
+import importlib.metadata
+import json
+import os
+import sys
+from typing import Any
+
+from rich.console import Console
+
+from stndp import main
+
+PROTOCOL_VERSION = "2025-06-18"
+try:
+    _VERSION = importlib.metadata.version("stndp-cli")
+except importlib.metadata.PackageNotFoundError:  # not installed (e.g. raw source run)
+    _VERSION = "0.0.0"
+SERVER_INFO = {"name": "stndp", "version": _VERSION}
+_TYPES = ("entry", "decision", "checkpoint", "episode", "bug")  # graph-anchor node kinds (get_context)
+# Every result type search can return — the originals plus the identity-only entities
+# the server's trigram channel surfaces. Mirrors the API's `_IDENT_SPECS`.
+_SEARCH_TYPES = _TYPES + (
+    "decision_version", "entry_version", "dump", "snapshot", "draft",
+    "repo", "branch", "directory", "file", "tracker_project", "workitem",
+    "user", "team", "org", "project",
+)
+
+
+def _agent_header() -> dict[str, str]:
+    """The `X-Stndp-Agent` label stamped on writes so the API attributes
+    agent-authored context. Configurable per agent via STNDP_AGENT_LABEL (e.g.
+    "claude-code", "codex"); defaults to "mcp"."""
+    return {"X-Stndp-Agent": os.environ.get("STNDP_AGENT_LABEL") or "mcp"}
+
+
+def _call(method: str, path: str, **kwargs: Any) -> Any:
+    return main._api_request(method, path, **kwargs)
+
+
+class InvalidParams(Exception):
+    """An agent-supplied argument failed validation; surfaced as JSON-RPC -32602
+    so junk never reaches the API."""
+
+
+def _as_int(value: Any, field: str) -> int:
+    """Coerce an agent-supplied id to int, rejecting junk (floats with a
+    fractional part, non-numeric strings, bools)."""
+    if isinstance(value, bool) or value is None:
+        raise InvalidParams(f"{field!r} must be an integer")
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        raise InvalidParams(f"{field!r} must be an integer, got {value!r}")
+
+
+def _as_type(value: Any) -> str:
+    """Validate a graph-anchor node-type arg (get_context) against the declared enum."""
+    if value not in _TYPES:
+        raise InvalidParams(f"'type' must be one of {_TYPES}, got {value!r}")
+    return value
+
+
+def _as_search_type(value: Any) -> str:
+    """Validate a search `type` filter against the broader set of result kinds."""
+    if value not in _SEARCH_TYPES:
+        raise InvalidParams(f"'type' must be one of {_SEARCH_TYPES}, got {value!r}")
+    return value
+
+
+# ── tool handlers (each returns the API's JSON result) ────────────────────────
+def _t_resume(a: dict) -> Any:
+    return _call("GET", "/v1/resume", params=({"team": a["team"]} if a.get("team") else None))
+
+
+def _t_checkpoint(a: dict) -> Any:
+    body: dict[str, Any] = {"focus": a["focus"], "kind": "state"}
+    for k in ("reason", "next_step", "status"):
+        if a.get(k):
+            body[k] = a[k]
+    params: dict[str, Any] = {}
+    if a.get("team"):
+        params["team"] = a["team"]
+    ep_id = main._open_episode_id()   # auto-attach to the open arc, if any
+    if ep_id:
+        params["episode"] = ep_id
+    return _call("POST", "/v1/checkpoints", params=(params or None), json=body,
+                 headers=_agent_header())
+
+
+def _t_decide(a: dict) -> Any:
+    body: dict[str, Any] = {"title": a["title"], "body": a.get("why") or a["title"]}
+    if a.get("tags"):
+        body["tags"] = a["tags"]
+    params: dict[str, Any] = {"team": a["team"]}
+    ep_id = main._open_episode_id()
+    if ep_id:
+        params["episode"] = ep_id
+    return _call("POST", "/v1/decisions", params=params, json=body, headers=_agent_header())
+
+
+def _t_episode_start(a: dict) -> Any:
+    body: dict[str, Any] = {"title": a["title"]}
+    if a.get("plan"):
+        body["plan"] = a["plan"]
+    ep = _call("POST", "/v1/episodes", params={"team": a["team"]}, json=body,
+               headers=_agent_header())
+    if isinstance(ep, dict) and ep.get("id"):
+        main._set_open_episode(ep)    # subsequent checkpoint/decide/bug auto-attach
+    return ep
+
+
+def _t_episode_close(a: dict) -> Any:
+    eid = _as_int(a.get("episode_id"), "episode_id")
+    body: dict[str, Any] = {}
+    for src, dst in (("did", "outcome"), ("result", "result"), ("surprise", "surprise")):
+        if a.get(src):
+            body[dst] = a[src]
+    ep = _call("POST", f"/v1/episodes/{eid}/close", json=body, headers=_agent_header())
+    main._clear_open_episode(eid)
+    return ep
+
+
+def _t_bug(a: dict) -> Any:
+    body: dict[str, Any] = {"symptom": a["symptom"]}
+    for src, dst in (("root_cause", "root_cause"), ("fix", "fix"), ("where", "where_ref")):
+        if a.get(src):
+            body[dst] = a[src]
+    body["episode_id"] = (_as_int(a["episode_id"], "episode_id")
+                          if a.get("episode_id") else main._open_episode_id())
+    return _call("POST", "/v1/bugs", params={"team": a["team"]}, json=body,
+                 headers=_agent_header())
+
+
+def _t_search(a: dict) -> Any:
+    params: dict[str, Any] = {"q": a["query"], "limit": a.get("limit", 10)}
+    if a.get("type"):
+        params["type"] = _as_search_type(a["type"])
+    if a.get("team"):
+        params["team"] = a["team"]
+    return _call("GET", "/v1/search", params=params)
+
+
+def _t_get_context(a: dict) -> Any:
+    node_type = _as_type(a.get("type"))
+    node_id = _as_int(a.get("id"), "id")
+    return _call("GET", "/v1/graph/neighbors", params={"type": node_type, "id": node_id})
+
+
+def _t_list_blockers(a: dict) -> Any:
+    return _call("GET", "/v1/mentions", params={"unresolved": True})
+
+
+def _t_link(a: dict) -> Any:
+    body = {"object_type": _as_type(a.get("type")), "object_id": _as_int(a.get("id"), "id"),
+            "ref": a["ref"]}
+    return _call("POST", "/v1/links", json=body, headers=_agent_header())
+
+
+def _t_file_context(a: dict) -> Any:
+    params: dict[str, Any] = {"path": a["path"], "limit": a.get("limit", 20)}
+    if a.get("repo"):
+        params["repo"] = _as_int(a["repo"], "repo")
+    return _call("GET", "/v1/files/context", params=params)
+
+
+def _t_whoami(a: dict) -> Any:
+    """The authenticated identity behind this MCP session (the user who ran `stn
+    login`), plus the agent label writes are attributed to. Local config — same
+    source as `stn whoami` — so it needs no API round-trip."""
+    cfg = main._load_config()
+    return {"logged_in": bool(cfg.get("user_id")), "handle": cfg.get("handle"),
+            "user_id": cfg.get("user_id"), "team_id": cfg.get("team_id"),
+            "email": cfg.get("email"), "api_url": cfg.get("api_url"),
+            "agent_label": os.environ.get("STNDP_AGENT_LABEL") or "mcp"}
+
+
+def _t_glob(a: dict) -> Any:
+    """Capture this session's local git/repo/commit/GitHub context into the graph.
+    Idempotent — safe to call at session start. Runs the same capture as `stn glob`."""
+    return main._glob_capture(team=a.get("team"), no_github=bool(a.get("no_github")),
+                              force=bool(a.get("force")))
+
+
+def _t_timeline(a: dict) -> Any:
+    """Recent team context (entries/decisions/checkpoints/episodes/bugs) merged
+    newest-first — server-side via /v1/timeline, the same as `stn timeline`."""
+    params: dict[str, Any] = {"team": a["team"]}
+    if a.get("days") is not None:
+        params["days"] = int(a["days"])
+    return _call("GET", "/v1/timeline", params=params)
+
+
+def _t_guide(a: dict) -> Any:
+    """The stndp workflow playbook — the SAME content as `stn guide` and the rules
+    block, served from main's single source of truth so the three never drift."""
+    topic = (a or {}).get("topic")
+    sections = main.GUIDE_TOPICS
+    if topic:
+        sections = [t for t in main.GUIDE_TOPICS if t[0] == topic]
+        if not sections:
+            raise InvalidParams(f"'topic' must be one of {main.GUIDE_KEYS}, got {topic!r}")
+    return {"intro": main.GUIDE_INTRO,
+            "topics": [{"key": k, "title": ti, "body": b} for k, ti, b in sections]}
+
+
+TOOLS: list[dict[str, Any]] = [
+    {"name": "guide",
+     "description": "How to use stndp — the workflow playbook (load context → record as "
+                    "you go → draft the standup) and the available tools. Call this if "
+                    "you're unsure when or how to use stndp's tools. Optional `topic` "
+                    "narrows to one section: start, files, record, standup, discover.",
+     "inputSchema": {"type": "object",
+                     "properties": {"topic": {"type": "string",
+                                              "enum": list(main.GUIDE_KEYS)}}},
+     "handler": _t_guide},
+    {"name": "resume",
+     "description": "Reload your working state before starting work: your last checkpoint "
+                    "(focus, why, next step), open blockers, and live ticket/PR status. Call "
+                    "this FIRST at the start of a task to pick up where you (or another agent) "
+                    "left off.",
+     "inputSchema": {"type": "object", "properties": {"team": {"type": "string"}}},
+     "handler": _t_resume},
+    {"name": "glob",
+     "description": "Capture this session's local git/repo context (current branch, commit, "
+                    "recent commits, and your GitHub activity) into the graph. Call this at the "
+                    "START of a session so your work is anchored to the right repo/branch — it's "
+                    "idempotent, so calling it again on the same commit is a no-op.",
+     "inputSchema": {"type": "object",
+                     "properties": {"team": {"type": "string"},
+                                    "no_github": {"type": "boolean"},
+                                    "force": {"type": "boolean"}}},
+     "handler": _t_glob},
+    {"name": "search",
+     "description": "Search the team's shared memory BEFORE reasoning from scratch — find out "
+                    "what was already decided and why. Covers decisions, entries, and your "
+                    "checkpoints, and (by identity) any other entity the platform tracks: "
+                    "repos, work items, files, people, teams. Great for absolute-identity "
+                    "lookups too ('hydra service', a Jira key, a file path). Each hit comes "
+                    "with its connected context (tickets/PRs, supersession chain).",
+     "inputSchema": {"type": "object",
+                     "properties": {"query": {"type": "string"},
+                                    "type": {"type": "string",
+                                             "enum": list(_SEARCH_TYPES)},
+                                    "team": {"type": "string"},
+                                    "limit": {"type": "integer"}},
+                     "required": ["query"]},
+     "handler": _t_search},
+    {"name": "timeline",
+     "description": "A unified, time-ordered feed of recent context in a team — entries, "
+                    "decisions, and your checkpoints merged newest-first. Use it to catch up on "
+                    "what's happened lately before diving in.",
+     "inputSchema": {"type": "object",
+                     "properties": {"team": {"type": "string"},
+                                    "days": {"type": "integer"}},
+                     "required": ["team"]},
+     "handler": _t_timeline},
+    {"name": "decide",
+     "description": "Record a durable, team-visible decision or learning into shared memory. "
+                    "Call this whenever you CHOOSE between alternatives or REJECT an approach "
+                    "(especially 'why we did NOT do X') — before moving on, so the rationale "
+                    "isn't lost. Put the trade-offs and rejected options in `why`.",
+     "inputSchema": {"type": "object",
+                     "properties": {"title": {"type": "string"},
+                                    "why": {"type": "string",
+                                            "description": "Rationale, including rejected alternatives"},
+                                    "tags": {"type": "array", "items": {"type": "string"}},
+                                    "team": {"type": "string"}},
+                     "required": ["title", "team"]},
+     "handler": _t_decide},
+    {"name": "checkpoint",
+     "description": "Save your current working state (what you're doing, why, and the next "
+                    "step) so it can be reloaded later with `resume`. Call this when you pause, "
+                    "switch tasks, or finish a chunk of work. Private to the user.",
+     "inputSchema": {"type": "object",
+                     "properties": {"focus": {"type": "string",
+                                              "description": "What you're working on"},
+                                    "reason": {"type": "string", "description": "Why"},
+                                    "next_step": {"type": "string", "description": "The next step"},
+                                    "team": {"type": "string"}},
+                     "required": ["focus"]},
+     "handler": _t_checkpoint},
+    {"name": "episode_start",
+     "description": "Open an EPISODE — the arc of one non-trivial unit of work (plan → done → "
+                    "result). Call this at the START of genuine multi-step work whose plan-vs-"
+                    "outcome delta is worth keeping; the checkpoints, decisions and bugs you "
+                    "record while it's open auto-attach to it. Do NOT open one for a one-line "
+                    "change, a single decision, or a single bug — record those standalone. Most "
+                    "work needs no episode.",
+     "inputSchema": {"type": "object",
+                     "properties": {"title": {"type": "string"},
+                                    "plan": {"type": "string",
+                                             "description": "What you intend to do, and why"},
+                                    "team": {"type": "string"}},
+                     "required": ["title", "team"]},
+     "handler": _t_episode_start},
+    {"name": "episode_close",
+     "description": "Close the open EPISODE when the work is done: record what actually happened "
+                    "(`did`), the observable `result`, and the `surprise` — what changed from the "
+                    "plan (the real, durable learning). This promotes the episode to team-visible "
+                    "shared memory. Capture the surprise honestly; the delta is the whole point.",
+     "inputSchema": {"type": "object",
+                     "properties": {"episode_id": {"type": "integer"},
+                                    "did": {"type": "string",
+                                            "description": "What actually happened"},
+                                    "result": {"type": "string",
+                                               "description": "The observable result"},
+                                    "surprise": {"type": "string",
+                                                 "description": "What changed from the plan"}},
+                     "required": ["episode_id"]},
+     "handler": _t_episode_close},
+    {"name": "bug",
+     "description": "Record a BUG you hit and (usually) fixed during the work — the highest-reuse, "
+                    "least-recorded knowledge. Call this whenever you diagnose and fix a "
+                    "non-obvious bug, so a future agent searching the symptom finds your exact "
+                    "{cause, fix}. Team-visible; attaches to the open episode automatically.",
+     "inputSchema": {"type": "object",
+                     "properties": {"symptom": {"type": "string",
+                                                "description": "What went wrong (observed)"},
+                                    "root_cause": {"type": "string",
+                                                   "description": "Why it happened"},
+                                    "fix": {"type": "string", "description": "How you fixed it"},
+                                    "where": {"type": "string",
+                                              "description": "File / commit / area"},
+                                    "team": {"type": "string"}},
+                     "required": ["symptom", "team"]},
+     "handler": _t_bug},
+    {"name": "get_context",
+     "description": "Get everything connected to a context node (an entry/decision/checkpoint/"
+                    "episode/bug id returned by search or resume): linked decisions, the "
+                    "supersession chain, the episode an item belongs to, and the tickets/PRs it "
+                    "touches.",
+     "inputSchema": {"type": "object",
+                     "properties": {"type": {"type": "string", "enum": list(_TYPES)},
+                                    "id": {"type": "integer"}},
+                     "required": ["type", "id"]},
+     "handler": _t_get_context},
+    {"name": "list_blockers",
+     "description": "List open blockers that name the user — things others have put on them "
+                    "that are still unresolved.",
+     "inputSchema": {"type": "object", "properties": {}},
+     "handler": _t_list_blockers},
+    {"name": "link",
+     "description": "Attach an external work item — a Jira key (PROJ-123), a GitHub PR url, or "
+                    "any url — to a context node (an entry/decision/checkpoint id from search or "
+                    "resume). Call this when your work connects to a ticket or PR, so the graph "
+                    "can show live ticket/PR status next to the decision or entry it relates to.",
+     "inputSchema": {"type": "object",
+                     "properties": {"type": {"type": "string", "enum": list(_TYPES)},
+                                    "id": {"type": "integer"},
+                                    "ref": {"type": "string",
+                                            "description": "PROJ-123, a PR url, or any url"}},
+                     "required": ["type", "id", "ref"]},
+     "handler": _t_link},
+    {"name": "file_context",
+     "description": "Before you EDIT or REASON ABOUT a file, call this to load what's already "
+                    "known about it: decisions made about it, who last touched it and why, and "
+                    "the tickets/PRs it relates to. Pass a repo-relative file path "
+                    "(app/billing/services.py) — or a directory to get the whole subtree's "
+                    "context, or path#symbol (services.py#charge) to narrow to a class/function. "
+                    "Don't reason from scratch about code that already has recorded history.",
+     "inputSchema": {"type": "object",
+                     "properties": {"path": {"type": "string",
+                                             "description": "Repo-relative file/dir path, or path#symbol"},
+                                    "repo": {"type": "integer",
+                                             "description": "Optional repo id; omit to match any visible repo"},
+                                    "limit": {"type": "integer"}},
+                     "required": ["path"]},
+     "handler": _t_file_context},
+    {"name": "whoami",
+     "description": "Identify who you're acting as: the authenticated user (handle, team) behind "
+                    "this session and the agent label your writes are attributed to. Call this if "
+                    "you're unsure which user/team context decisions and checkpoints will be saved "
+                    "under.",
+     "inputSchema": {"type": "object", "properties": {}},
+     "handler": _t_whoami},
+]
+
+_BY_NAME = {t["name"]: t for t in TOOLS}
+
+
+# ── MCP resources ─────────────────────────────────────────────────────────────
+# Read-only project context the agent can *load* as ambient state — cheaper and
+# cleaner than a tool round-trip when it just wants the current memory in context.
+def _r_recent_decisions() -> Any:
+    return _call("GET", "/v1/decisions")
+
+
+def _r_open_blockers() -> Any:
+    return _call("GET", "/v1/mentions", params={"unresolved": True})
+
+
+def _r_recent_checkpoints() -> Any:
+    return _call("GET", "/v1/checkpoints")
+
+
+RESOURCES: list[dict[str, Any]] = [
+    {"uri": "stndp://decisions/recent", "name": "Recent decisions",
+     "description": "The team's recent durable decisions — what was chosen and why.",
+     "mimeType": "application/json", "fetch": _r_recent_decisions},
+    {"uri": "stndp://blockers/open", "name": "Open blockers",
+     "description": "Unresolved blockers that name you — what others are waiting on.",
+     "mimeType": "application/json", "fetch": _r_open_blockers},
+    {"uri": "stndp://checkpoints/recent", "name": "Recent checkpoints",
+     "description": "Your recent working-state checkpoints (focus, why, next step).",
+     "mimeType": "application/json", "fetch": _r_recent_checkpoints},
+]
+_RES_BY_URI = {r["uri"]: r for r in RESOURCES}
+
+
+# ── MCP prompts ───────────────────────────────────────────────────────────────
+# Canned flows that encode the resume→work→checkpoint→decide protocol as first-class,
+# invocable steps (the agent gets the trigger as a message, not buried in prose).
+def _p_start_task(args: dict) -> dict:
+    task = (args or {}).get("task", "").strip()
+    suffix = f' for: "{task}"' if task else ""
+    text = ("Before starting, reload shared context with the stndp MCP tools:\n"
+            "1. Call `resume` to pick up your last checkpoint and open blockers.\n"
+            f"2. Call `search`{suffix} to find what was already decided and why — don't "
+            "reason from scratch if a decision already exists.\n"
+            "3. Then proceed, calling `decide` as you make choices.")
+    return {"description": "Start a task by reloading shared context first.",
+            "messages": [{"role": "user", "content": {"type": "text", "text": text}}]}
+
+
+def _p_wrap_up(args: dict) -> dict:
+    text = ("Wrap up this chunk of work in shared context:\n"
+            "1. Call `checkpoint` with your current focus, why, and the next step, so it can "
+            "be reloaded later with `resume`.\n"
+            "2. For every choice you made or approach you rejected, call `decide` (put the "
+            "rejected alternatives in `why`) so the rationale isn't lost.")
+    return {"description": "Save working state and log decisions before stopping.",
+            "messages": [{"role": "user", "content": {"type": "text", "text": text}}]}
+
+
+def _p_log_decision(args: dict) -> dict:
+    a = args or {}
+    title = a.get("title", "").strip()
+    why = a.get("why", "").strip()
+    text = ("Record this decision in shared team memory by calling the `decide` tool:\n"
+            f"- title: {title or '<the decision in one line>'}\n"
+            f"- why: {why or '<the rationale, including the alternatives you rejected>'}\n"
+            "Include the trade-offs and any 'why we did NOT do X' — the most valuable, "
+            "most-often-lost part.")
+    return {"description": "Log a decision with its rationale and rejected alternatives.",
+            "messages": [{"role": "user", "content": {"type": "text", "text": text}}]}
+
+
+PROMPTS: list[dict[str, Any]] = [
+    {"name": "start-task",
+     "description": "Reload shared context (resume + search) before starting a task.",
+     "arguments": [{"name": "task", "description": "What you're about to work on",
+                    "required": False}],
+     "build": _p_start_task},
+    {"name": "wrap-up",
+     "description": "Checkpoint your state and log decisions before you stop.",
+     "arguments": [], "build": _p_wrap_up},
+    {"name": "log-decision",
+     "description": "Record a decision with its rationale and rejected alternatives.",
+     "arguments": [{"name": "title", "description": "The decision in one line", "required": False},
+                   {"name": "why", "description": "Rationale incl. rejected alternatives",
+                    "required": False}],
+     "build": _p_log_decision},
+]
+_PROMPT_BY_NAME = {p["name"]: p for p in PROMPTS}
+
+
+def _result(req_id: Any, result: Any) -> dict:
+    return {"jsonrpc": "2.0", "id": req_id, "result": result}
+
+
+def _error(req_id: Any, code: int, message: str) -> dict:
+    return {"jsonrpc": "2.0", "id": req_id, "error": {"code": code, "message": message}}
+
+
+def handle_message(msg: dict) -> dict | None:
+    """Process one JSON-RPC request; return the response dict, or None for a
+    notification (no id, e.g. `notifications/initialized`) that takes no reply."""
+    method = msg.get("method")
+    req_id = msg.get("id")
+    if method is None or req_id is None:
+        return None
+    if method == "initialize":
+        return _result(req_id, {"protocolVersion": PROTOCOL_VERSION,
+                                "capabilities": {"tools": {}, "resources": {}, "prompts": {}},
+                                "serverInfo": SERVER_INFO})
+    if method == "ping":
+        return _result(req_id, {})
+    if method == "tools/list":
+        return _result(req_id, {"tools": [
+            {"name": t["name"], "description": t["description"], "inputSchema": t["inputSchema"]}
+            for t in TOOLS
+        ]})
+    if method == "tools/call":
+        params = msg.get("params") or {}
+        tool = _BY_NAME.get(params.get("name"))
+        if tool is None:
+            return _error(req_id, -32602, f"unknown tool: {params.get('name')}")
+        try:
+            data = tool["handler"](params.get("arguments") or {})
+        except InvalidParams as exc:  # bad agent args → JSON-RPC invalid params
+            return _error(req_id, -32602, f"invalid params: {exc}")
+        except Exception as exc:  # surface tool errors to the agent, not the transport
+            return _result(req_id, {"content": [{"type": "text", "text": f"error: {exc}"}],
+                                    "isError": True})
+        return _result(req_id, {
+            "content": [{"type": "text", "text": json.dumps(data, default=str)}],
+            "structuredContent": {"result": data},
+            "isError": False,
+        })
+    if method == "resources/list":
+        return _result(req_id, {"resources": [
+            {"uri": r["uri"], "name": r["name"], "description": r["description"],
+             "mimeType": r["mimeType"]} for r in RESOURCES
+        ]})
+    if method == "resources/read":
+        params = msg.get("params") or {}
+        uri = params.get("uri")
+        res = _RES_BY_URI.get(uri)
+        if res is None:
+            return _error(req_id, -32602, f"unknown resource: {uri}")
+        try:
+            data = res["fetch"]()
+        except Exception as exc:  # an API hiccup is the transport's problem to report
+            return _error(req_id, -32603, f"resource error: {exc}")
+        return _result(req_id, {"contents": [
+            {"uri": uri, "mimeType": "application/json", "text": json.dumps(data, default=str)}
+        ]})
+    if method == "prompts/list":
+        return _result(req_id, {"prompts": [
+            {"name": p["name"], "description": p["description"], "arguments": p["arguments"]}
+            for p in PROMPTS
+        ]})
+    if method == "prompts/get":
+        params = msg.get("params") or {}
+        prompt = _PROMPT_BY_NAME.get(params.get("name"))
+        if prompt is None:
+            return _error(req_id, -32602, f"unknown prompt: {params.get('name')}")
+        return _result(req_id, prompt["build"](params.get("arguments") or {}))
+    return _error(req_id, -32601, f"method not found: {method}")
+
+
+def _write(response: dict) -> None:
+    sys.stdout.write(json.dumps(response) + "\n")
+    sys.stdout.flush()
+
+
+def serve() -> None:
+    """Run the MCP server over newline-delimited JSON-RPC on stdio (blocking).
+
+    stdout carries ONLY the JSON-RPC protocol. The CLI's HTTP error paths print
+    Rich diagnostics to `main.console`, which defaults to stdout and would corrupt
+    the stream mid-tool-call — so reroute that console to stderr before serving.
+    """
+    main.console = Console(stderr=True)
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            msg = json.loads(line)
+        except json.JSONDecodeError:
+            # Don't silently drop malformed input — answer with a spec parse error.
+            _write({"jsonrpc": "2.0", "id": None,
+                    "error": {"code": -32700, "message": "parse error"}})
+            continue
+        response = handle_message(msg)
+        if response is not None:
+            _write(response)

stndp_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: stndp-cli
+Version: 0.1.0
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.26.7

stndp_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+stndp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stndp/main.py,sha256=RdkTImwQB2UNXYG-rK9XoaivT7g96MSsMQcf25WIJbk,130504
+stndp/mcp_server.py,sha256=Au2udXJ78xmI5WB44IkfSkks9yWO6eAeBRnId1Tsg9E,29374
+stndp_cli-0.1.0.dist-info/METADATA,sha256=0a5OrNEqRhdp7Pma71IMNeWPMEiMN9R6JF_Kw-U0Srw,163
+stndp_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+stndp_cli-0.1.0.dist-info/entry_points.txt,sha256=Ji8SrWfwFbOCUP9zDxFDGBMLQMHFbXVQJ1oTw9nlHRU,39
+stndp_cli-0.1.0.dist-info/top_level.txt,sha256=28ULs1Po-J9guFphP4BpMMBLTCxDSExme0-5Prbc1vo,6
+stndp_cli-0.1.0.dist-info/RECORD,,

stndp_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stndp_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stn = stndp.main:app

stndp_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+stndp