patternfetch-mcp 0.2.0

package/README.md

@@ -0,0 +1,15 @@
+# patternfetch-mcp
+
+Local **stdio MCP bridge** for [patternfetch](https://patternfetch.com) — token-compact crypto market-state briefs (compact candles, chart patterns, support/resistance, regime, interpreted RSI/EMA) in one call, so an agent never dumps raw OHLCV into context.
+
+```bash
+npx patternfetch-mcp
+```
+
+Claude Desktop / Cursor / any stdio MCP client:
+
+```json
+{ "mcpServers": { "patternfetch": { "command": "npx", "args": ["-y", "patternfetch-mcp"], "env": { "PATTERNFETCH_API_KEY": "pf_..." } } } }
+```
+
+`tools/list` works with no key; tool calls use `PATTERNFETCH_API_KEY` (or x402). Override the endpoint with `PATTERNFETCH_MCP_URL`. Proxies to the hosted MCP at `patternfetch.com/mcp`. Full client + docs: [patternfetch-client](https://github.com/MarvinRey7879/patternfetch-client). Impersonal market data, not investment advice.

package/mcp-tools.json

@@ -0,0 +1,79 @@
+[
+  {
+    "name": "patternfetch_brief",
+    "description": "Get a token-compact market-state brief for a crypto ticker + timeframe. Returns compact candles, detected chart/candlestick patterns with geometric confidence, support/resistance levels, trend/regime, and interpreted indicators (RSI/EMA state) plus a one-line summary. WHEN: an agent needs the current technical picture of a market without dumping raw OHLCV into context (saves tokens, avoids numeric hallucination). WHEN NOT: you need order execution, portfolio advice, or non-crypto assets. Example: {\"ticker\":\"BTC/USDT\",\"timeframe\":\"4h\"}. Output is impersonal market data, NOT investment advice.",
+    "inputSchema": {
+      "type": "object",
+      "required": [
+        "ticker",
+        "timeframe"
+      ],
+      "properties": {
+        "ticker": {
+          "type": "string"
+        },
+        "timeframe": {
+          "type": "string"
+        },
+        "limit": {
+          "type": "integer"
+        }
+      }
+    }
+  },
+  {
+    "name": "patternfetch_delta",
+    "description": "Get only what CHANGED since your last brief for a ticker+timeframe (trend flips, new patterns, RSI-state changes). WHEN: an agent polls the same market repeatedly and wants minimal tokens. Returns changed=false when nothing material changed. Impersonal data, not advice.",
+    "inputSchema": {
+      "type": "object",
+      "required": [
+        "ticker",
+        "timeframe"
+      ],
+      "properties": {
+        "ticker": {
+          "type": "string"
+        },
+        "timeframe": {
+          "type": "string"
+        },
+        "limit": {
+          "type": "integer"
+        }
+      }
+    }
+  },
+  {
+    "name": "patternfetch_analogs",
+    "description": "Find historical windows whose shape resembles the current price action and return the FULL distribution of what followed (win-rate, median, min, max, n) over a fixed forward horizon. WHEN: an agent wants historical context for a setup. NOT a prediction, NOT a backtest of a strategy; past distribution does not guarantee future results. Impersonal data, not advice.",
+    "inputSchema": {
+      "type": "object",
+      "required": [
+        "ticker",
+        "timeframe"
+      ],
+      "properties": {
+        "ticker": {
+          "type": "string"
+        },
+        "timeframe": {
+          "type": "string"
+        },
+        "window": {
+          "type": "integer"
+        },
+        "horizon": {
+          "type": "integer"
+        }
+      }
+    }
+  },
+  {
+    "name": "patternfetch_capabilities",
+    "description": "List supported assets, timeframes, endpoints, and limits for patternfetch.",
+    "inputSchema": {
+      "type": "object",
+      "properties": {}
+    }
+  }
+]

package/mcp.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// patternfetch — zero-dependency stdio MCP bridge.
+// Proxies Model Context Protocol calls to the hosted patternfetch MCP server.
+// tools/list is served from an embedded snapshot (mcp-tools.json) so introspection
+// always succeeds, even before the first network round-trip; tool calls are
+// forwarded to the remote endpoint.
+//
+// Env:
+//   PATTERNFETCH_MCP_URL   override the remote MCP endpoint (default https://patternfetch.com/mcp)
+//   PATTERNFETCH_API_KEY   optional bearer key for authenticated (non-x402) calls
+import { stdin, stdout, env, exit } from "node:process";
+import { readFileSync } from "node:fs";
+
+const REMOTE = env.PATTERNFETCH_MCP_URL || "https://patternfetch.com/mcp";
+const API_KEY = env.PATTERNFETCH_API_KEY || "";
+const PROTOCOL = "2025-06-18";
+const SERVER_INFO = { name: "patternfetch", version: "0.1.0" };
+
+let STATIC_TOOLS = [];
+try {
+  STATIC_TOOLS = JSON.parse(readFileSync(new URL("./mcp-tools.json", import.meta.url), "utf8"));
+} catch { /* snapshot optional; remote tools/list still works */ }
+
+stdout.on("error", () => {}); // ignore EPIPE if the client closes the pipe early
+
+function send(msg) {
+  stdout.write(JSON.stringify(msg) + "\n");
+}
+
+// Remote may answer with plain JSON or an SSE frame ("event: message\ndata: {...}").
+function parseRpc(text) {
+  const s = text.trim();
+  if (s.startsWith("{")) {
+    try { return JSON.parse(s); } catch { /* fall through to SSE parse */ }
+  }
+  for (const line of s.split(/\r?\n/)) {
+    const m = line.match(/^data:\s*(.*)$/);
+    if (m) {
+      try { return JSON.parse(m[1]); } catch { /* ignore non-JSON data lines */ }
+    }
+  }
+  return null;
+}
+
+async function remoteRpc(method, params) {
+  const res = await fetch(REMOTE, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "accept": "application/json, text/event-stream",
+      ...(API_KEY ? { authorization: `Bearer ${API_KEY}` } : {}),
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+  });
+  const j = parseRpc(await res.text());
+  if (!j) throw new Error("invalid response from remote MCP");
+  if (j.error) throw new Error(j.error.message || "remote MCP error");
+  return j.result;
+}
+
+async function listTools() {
+  try {
+    const r = await remoteRpc("tools/list", {});
+    if (r && Array.isArray(r.tools) && r.tools.length) return r.tools;
+  } catch { /* remote unreachable — fall back to embedded snapshot */ }
+  return STATIC_TOOLS;
+}
+
+async function handle(msg) {
+  const { id, method, params } = msg;
+  if (method === "initialize")
+    return send({ jsonrpc: "2.0", id, result: { protocolVersion: PROTOCOL, capabilities: { tools: {} }, serverInfo: SERVER_INFO } });
+  if (method === "ping")
+    return send({ jsonrpc: "2.0", id, result: {} });
+  if (typeof method === "string" && method.startsWith("notifications/"))
+    return; // notifications carry no id and need no reply
+  if (method === "tools/list")
+    return send({ jsonrpc: "2.0", id, result: { tools: await listTools() } });
+  if (method === "tools/call") {
+    try {
+      return send({ jsonrpc: "2.0", id, result: await remoteRpc("tools/call", params) });
+    } catch (e) {
+      return send({ jsonrpc: "2.0", id, result: { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true } });
+    }
+  }
+  if (id !== undefined)
+    return send({ jsonrpc: "2.0", id, error: { code: -32601, message: `Method not found: ${method}` } });
+}
+
+let buf = "";
+let pending = 0;
+let ended = false;
+const tryExit = () => { if (ended && pending === 0) setImmediate(() => exit(0)); };
+stdin.setEncoding("utf8");
+stdin.on("data", (chunk) => {
+  buf += chunk;
+  let i;
+  while ((i = buf.indexOf("\n")) >= 0) {
+    const line = buf.slice(0, i).trim();
+    buf = buf.slice(i + 1);
+    if (!line) continue;
+    let msg;
+    try { msg = JSON.parse(line); } catch { continue; }
+    pending++;
+    Promise.resolve(handle(msg)).catch(() => {}).finally(() => { pending--; tryExit(); });
+  }
+});
+// Exit only once stdin is closed AND every in-flight response has been flushed.
+stdin.on("end", () => { ended = true; tryExit(); });

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "patternfetch-mcp",
+  "version": "0.2.0",
+  "description": "Local stdio MCP bridge for patternfetch — token-compact crypto market-state briefs (candles, patterns, support/resistance, regime, RSI/EMA) in one call. Proxies to the hosted patternfetch MCP server.",
+  "type": "module",
+  "bin": { "patternfetch-mcp": "mcp.js" },
+  "files": ["mcp.js", "mcp-tools.json", "README.md"],
+  "engines": { "node": ">=18" },
+  "keywords": ["patternfetch", "mcp", "crypto", "trading", "market-data", "technical-analysis", "ai-agent", "stdio", "x402"],
+  "homepage": "https://patternfetch.com",
+  "repository": { "type": "git", "url": "git+https://github.com/MarvinRey7879/patternfetch-client.git" },
+  "license": "MIT",
+  "author": "patternfetch"
+}