@newtui/mcp 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,61 @@
-# Temporary Holding Version
+# @newtui/mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An [MCP](https://modelcontextprotocol.io) server for the [newt/ui](https://newtui.dev) documentation — Discord-inspired components for React, Vue and plain HTML/CSS. It gives your editor's agent the docs themselves: installation per framework, theming, the token reference, accessibility notes and the registry format, read from the site rather than recalled from memory.
+
+It is the companion to `newtui mcp`, the server inside the CLI: that one answers _which components exist and what their source is_; this one answers _what the documentation says_. Run both.
+
+```bash
+npx @newtui/mcp
+```
+
+## Tools
+
+Every tool is read-only.
+
+| Tool          | What it returns                                                                                                                                    |
+| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `list_docs`   | Every page with its title, route, description and section. `section` filters to one heading of the index, e.g. `Installation`.                     |
+| `search_docs` | Pages ranked by where every keyword appears — title, route, description, section. `content: true` searches page bodies too and adds an excerpt.    |
+| `get_doc`     | One page as Markdown. Takes a route (`/docs/theming`), a slug (`button`, `installation/nuxt`) or a full URL; an unknown page answers with matches. |
+
+## Configure your client
+
+```json
+{
+  "mcpServers": {
+    "newtui-docs": {
+      "command": "npx",
+      "args": ["-y", "@newtui/mcp@latest"]
+    }
+  }
+}
+```
+
+That shape works for Claude Code (`.mcp.json`), Cursor (`.cursor/mcp.json`) and most other clients. Claude Code can also add it in one line:
+
+```bash
+claude mcp add newtui-docs -- npx -y @newtui/mcp@latest
+```
+
+## Pointing it at another site
+
+The site resolves as `--url` > `NEWTUI_DOCS_URL` > `https://newtui.dev`:
+
+```bash
+npx @newtui/mcp --url http://localhost:4321
+NEWTUI_DOCS_URL=http://localhost:4321 npx @newtui/mcp
+```
+
+The server reads what the site publishes for agents: `llms.txt` for the page index, `llms-full.txt` for full-text search, and the `.md` twin of every page. The Blume dev server serves the twins but not the two `llms` files, so against `localhost:4321` the index comes from the JSON docs API (`/api/docs/pages.json`) and `search_docs` falls back to titles and descriptions — the answer says so in `searchedContent`. A built site (`pnpm --filter docs build`, then any static server on `apps/docs/dist`) has everything.
+
+Responses are cached in memory for five minutes; a 404 is cached too, a server error is not.
+
+## Development
+
+```bash
+pnpm build       # tsdown -> dist/index.js
+pnpm typecheck   # tsc --noEmit
+pnpm test        # vitest, with the network replaced by an in-memory site
+```
+
+newt/ui is an independent, community-built project. It is visually inspired by Discord's client but is not affiliated with, endorsed by, or sponsored by Discord Inc.

package/dist/index.js

@@ -0,0 +1,504 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+//#region package.json
+var version = "0.1.0";
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateMethodInitSpec.js
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.154.0/helpers/esm/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+
+//#endregion
+//#region src/docs.ts
+const DEFAULT_DOCS_URL = "https://newtui.dev";
+/** How long a fetched document stays fresh, in milliseconds. */
+const DEFAULT_CACHE_TTL = 3e5;
+var DocsRequestError = class extends Error {
+	constructor(url, status) {
+		super(`GET ${url} answered ${status}`);
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "status", void 0);
+		this.name = "DocsRequestError";
+		this.url = url;
+		this.status = status;
+	}
+};
+/** The subset of Blume's JSON docs API the fallback index reads. */
+const pagesApiSchema = z.object({ pages: z.array(z.object({
+	route: z.string(),
+	title: z.string(),
+	description: z.string().optional(),
+	contentType: z.string().optional()
+})) });
+/** The docs site resolves as `--url` > `NEWTUI_DOCS_URL` > the default. */
+function resolveDocsUrl(flag, env) {
+	return [flag, env].find((value) => value !== void 0 && value.trim() !== "")?.trim() ?? "https://newtui.dev";
+}
+/** Strip the trailing slash so `${base}${path}` never doubles one. */
+function normaliseBaseUrl(url) {
+	return new URL(url).toString().replace(/\/+$/u, "");
+}
+const DEFAULT_HOST = new URL(DEFAULT_DOCS_URL).host;
+function pagePathOf(href, base) {
+	const link = new URL(href, base);
+	if (link.host !== base.host && link.host !== DEFAULT_HOST) return null;
+	const path = link.pathname.replace(/\/+$/u, "") || "/";
+	const segments = path.split("/");
+	const last = segments.at(-1) ?? "";
+	if (segments.some((segment) => segment.startsWith(".")) || last.includes(".")) return null;
+	return path;
+}
+const LINK_LINE = /^- \[(?<title>[^\]]+)\]\((?<href>[^)\s]+)\)(?::\s*(?<description>.*))?$/u;
+/** Parse an `llms.txt` page index into entries rebased on `baseUrl`. */
+function parseLlmsTxt(source, baseUrl) {
+	const base = new URL(baseUrl);
+	const entries = [];
+	const seen = /* @__PURE__ */ new Set();
+	let section;
+	for (const line of source.split("\n")) {
+		if (line.startsWith("## ")) {
+			section = line.slice(3).trim();
+			continue;
+		}
+		const groups = LINK_LINE.exec(line.trim())?.groups;
+		if (groups?.title === void 0 || groups.href === void 0) continue;
+		const path = pagePathOf(groups.href, base);
+		if (path === null || seen.has(path)) continue;
+		seen.add(path);
+		entries.push(toEntry(baseUrl, path, groups.title, groups.description?.trim(), section));
+	}
+	return entries;
+}
+/** Parse Blume's `/api/docs/pages.json` into the same entries. */
+function parsePagesApi(source, baseUrl) {
+	const { pages } = pagesApiSchema.parse(JSON.parse(source));
+	return pages.filter((page) => page.route !== "/404").map((page) => toEntry(baseUrl, page.route.replace(/\/+$/u, "") || "/", page.title, page.description, page.contentType));
+}
+function parseLlmsFull(source, baseUrl) {
+	const base = new URL(baseUrl);
+	const lines = source.split("\n");
+	const starts = [];
+	for (let index = 1; index < lines.length; index++) {
+		const href = /^Source: (?<href>\S+)$/u.exec(lines[index] ?? "")?.groups?.href;
+		if (href === void 0 || !(lines[index - 1] ?? "").startsWith("# ")) continue;
+		const path = pagePathOf(href, base);
+		if (path !== null) starts.push({
+			path,
+			heading: index - 1
+		});
+	}
+	const bodies = /* @__PURE__ */ new Map();
+	starts.forEach((start, position) => {
+		const end = starts[position + 1]?.heading ?? lines.length;
+		bodies.set(start.path, lines.slice(start.heading + 2, end).join("\n").trim());
+	});
+	return bodies;
+}
+function toEntry(baseUrl, path, title, description, section) {
+	const entry = {
+		title,
+		path,
+		url: `${baseUrl}${path === "/" ? "" : path}`,
+		markdownUrl: `${baseUrl}${markdownPathFor(path)}`
+	};
+	if (description !== void 0 && description !== "") entry.description = description;
+	if (section !== void 0) entry.section = section;
+	return entry;
+}
+/** Blume writes `/docs.md` for `/docs` and `/index.md` for the home page. */
+function markdownPathFor(path) {
+	return path === "/" ? "/index.md" : `${path}.md`;
+}
+/**
+* Turn whatever an agent passes — a slug, a route, a full URL, with or
+* without `.md` — into a site-relative route.
+*/
+function toRoute(input) {
+	let value = input.trim();
+	if (/^https?:\/\//u.test(value)) value = new URL(value).pathname;
+	value = value.replace(/[?#].*$/u, "").replace(/\.mdx?$/u, "").replace(/\/+$/u, "");
+	if (value === "" || value === "/index") return "/";
+	return value.startsWith("/") ? value : `/${value}`;
+}
+function terms(query) {
+	return query.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((term) => term.length > 0);
+}
+function countOccurrences(haystack, needle) {
+	let count = 0;
+	let index = haystack.indexOf(needle);
+	while (index !== -1) {
+		count++;
+		index = haystack.indexOf(needle, index + needle.length);
+	}
+	return count;
+}
+function excerptOf(body, query, words) {
+	const lines = body.split("\n").map((line) => line.trim());
+	const lowered = lines.map((line) => line.toLowerCase());
+	const phrase = query.trim().toLowerCase();
+	const tests = [
+		(line) => line.includes(phrase),
+		(line) => words.every((word) => line.includes(word)),
+		(line) => words.some((word) => line.includes(word))
+	];
+	for (const test of tests) {
+		const index = lowered.findIndex(test);
+		const line = lines[index];
+		if (index !== -1 && line !== void 0) return line.length > 200 ? `${line.slice(0, 197)}...` : line;
+	}
+}
+/**
+* Rank entries against a keyword query. Every term has to appear somewhere —
+* the title, the route, the description, the section or (when given) the
+* body — and where it appears decides the weight.
+*/
+function rankEntries(entries, query, bodies) {
+	const words = terms(query);
+	if (words.length === 0) return [];
+	const phrase = words.join(" ");
+	const hits = [];
+	for (const entry of entries) {
+		const title = entry.title.toLowerCase();
+		const titleWords = new Set(terms(entry.title));
+		const route = entry.path.toLowerCase();
+		const description = (entry.description ?? "").toLowerCase();
+		const section = (entry.section ?? "").toLowerCase();
+		const body = bodies?.get(entry.path)?.toLowerCase() ?? "";
+		let score = title === phrase ? 20 : title.includes(phrase) ? 8 : 0;
+		let everyTermFound = true;
+		for (const word of words) {
+			let weight = 0;
+			if (titleWords.has(word)) weight += 10;
+			else if (title.includes(word)) weight += 6;
+			if (route.includes(word)) weight += 4;
+			if (description.includes(word)) weight += 2;
+			if (section.includes(word)) weight += 1;
+			weight += Math.min(countOccurrences(body, word), 5);
+			if (weight === 0) {
+				everyTermFound = false;
+				break;
+			}
+			score += weight;
+		}
+		if (!everyTermFound) continue;
+		const hit = {
+			...entry,
+			score
+		};
+		const excerpt = body === "" ? void 0 : excerptOf(bodies?.get(entry.path) ?? "", query, words);
+		if (excerpt !== void 0) hit.excerpt = excerpt;
+		hits.push(hit);
+	}
+	return hits.toSorted((left, right) => right.score - left.score || left.path.localeCompare(right.path));
+}
+var _fetcher = /* @__PURE__ */ new WeakMap();
+var _ttl = /* @__PURE__ */ new WeakMap();
+var _now = /* @__PURE__ */ new WeakMap();
+var _cache = /* @__PURE__ */ new WeakMap();
+var _DocsClient_brand = /* @__PURE__ */ new WeakSet();
+var DocsClient = class {
+	constructor(options) {
+		_classPrivateMethodInitSpec(this, _DocsClient_brand);
+		_defineProperty(this, "baseUrl", void 0);
+		_classPrivateFieldInitSpec(this, _fetcher, void 0);
+		_classPrivateFieldInitSpec(this, _ttl, void 0);
+		_classPrivateFieldInitSpec(this, _now, void 0);
+		_classPrivateFieldInitSpec(this, _cache, /* @__PURE__ */ new Map());
+		this.baseUrl = normaliseBaseUrl(options.baseUrl);
+		_classPrivateFieldSet2(_fetcher, this, options.fetcher ?? ((url) => fetch(url, { signal: AbortSignal.timeout(15e3) })));
+		_classPrivateFieldSet2(_ttl, this, options.ttl ?? 3e5);
+		_classPrivateFieldSet2(_now, this, options.now ?? Date.now);
+	}
+	/** Every page the site lists, in the order `llms.txt` lists them. */
+	async listDocs() {
+		const llms = await _assertClassBrand(_DocsClient_brand, this, _get).call(this, "/llms.txt");
+		if (llms !== null) return parseLlmsTxt(llms, this.baseUrl);
+		const api = await _assertClassBrand(_DocsClient_brand, this, _get).call(this, "/api/docs/pages.json");
+		if (api !== null) return parsePagesApi(api, this.baseUrl);
+		throw new DocsRequestError(`${this.baseUrl}/llms.txt`, 404);
+	}
+	async searchDocs(query, includeContent) {
+		const entries = await this.listDocs();
+		const bodies = includeContent ? await _assertClassBrand(_DocsClient_brand, this, _bodies).call(this) : null;
+		return {
+			searchedContent: bodies !== null,
+			hits: rankEntries(entries, query, bodies ?? void 0)
+		};
+	}
+	/**
+	* One page's Markdown. A bare slug (`button`) is matched against the index
+	* first — the last segment of a route — then tried under `/docs/`.
+	*/
+	async getDoc(input) {
+		const route = toRoute(input);
+		const entries = await this.listDocs().catch(() => []);
+		const slug = route.slice(1);
+		const known = new Set(entries.map((entry) => entry.path));
+		const guesses = [
+			route,
+			`/docs${route}`,
+			...entries.filter((entry) => entry.path.endsWith(route)).map((entry) => entry.path)
+		];
+		const candidates = /* @__PURE__ */ new Set([...guesses.filter((path) => known.has(path)), ...guesses]);
+		for (const path of candidates) {
+			const markdown = await _assertClassBrand(_DocsClient_brand, this, _get).call(this, markdownPathFor(path));
+			if (markdown !== null) return {
+				found: true,
+				entry: entries.find((candidate) => candidate.path === path) ?? toEntry(this.baseUrl, path, path, void 0, void 0),
+				markdown
+			};
+		}
+		return {
+			found: false,
+			path: route,
+			suggestions: rankEntries(entries, terms(slug).map((word) => word.slice(0, Math.max(4, word.length - 2))).join(" ")).slice(0, 5)
+		};
+	}
+};
+/**
+* A cached GET. `null` means the site answered 404 — a fact worth caching
+* too; any other failure throws and is not cached, so the next call retries.
+*/
+async function _get(path) {
+	const url = `${this.baseUrl}${path}`;
+	const cached = _classPrivateFieldGet2(_cache, this).get(url);
+	if (cached !== void 0 && cached.expires > _classPrivateFieldGet2(_now, this).call(this)) return cached.value;
+	const value = _classPrivateFieldGet2(_fetcher, this).call(this, url).then(async (response) => {
+		if (response.status === 404) return null;
+		if (!response.ok) throw new DocsRequestError(url, response.status);
+		return response.text();
+	});
+	if (_classPrivateFieldGet2(_ttl, this) > 0) {
+		_classPrivateFieldGet2(_cache, this).set(url, {
+			expires: _classPrivateFieldGet2(_now, this).call(this) + _classPrivateFieldGet2(_ttl, this),
+			value
+		});
+		value.catch(() => _classPrivateFieldGet2(_cache, this).delete(url));
+	}
+	return value;
+}
+/** Page bodies keyed by route, or `null` when the site has no `llms-full.txt`. */
+async function _bodies() {
+	const full = await _assertClassBrand(_DocsClient_brand, this, _get).call(this, "/llms-full.txt");
+	return full === null ? null : parseLlmsFull(full, this.baseUrl);
+}
+
+//#endregion
+//#region src/server.ts
+const DEFAULT_LIMIT = 10;
+const MAX_LIMIT = 50;
+/** A tool answering in prose or Markdown. */
+function text(message) {
+	return { content: [{
+		type: "text",
+		text: message
+	}] };
+}
+/** A tool reporting a failure the agent should read rather than retry blindly. */
+function failure(message) {
+	return {
+		...text(message),
+		isError: true
+	};
+}
+function asJson(value) {
+	return JSON.stringify(value, null, 2);
+}
+function createServer(docs) {
+	const server = new McpServer({
+		name: "newtui-docs",
+		version
+	});
+	server.registerTool("list_docs", {
+		title: "List documentation pages",
+		description: "Every page of the newt/ui documentation (Discord-inspired components for React, Vue and HTML/CSS) with its title, route, description and section. Use it to find the page to read with get_doc.",
+		inputSchema: { section: z.string().optional().describe("Only pages listed under this section, e.g. 'Installation' or 'Forms'. Case-insensitive.") },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ section }) => {
+		const all = await docs.listDocs();
+		const pages = section === void 0 ? all : all.filter((page) => page.section?.toLowerCase() === section.toLowerCase());
+		return text(asJson({
+			site: docs.baseUrl,
+			count: pages.length,
+			pages
+		}));
+	});
+	server.registerTool("search_docs", {
+		title: "Search the documentation",
+		description: "Keyword search over the newt/ui docs. Ranks pages by where every query term appears: title first, then route, description and section. Set content to true to search page bodies as well — slower, but it finds a prop or a token mentioned only inside a page.",
+		inputSchema: {
+			query: z.string().min(1).describe("Keywords, e.g. 'dark mode' or 'nuxt install'."),
+			content: z.boolean().optional().describe("Also search the full text of every page."),
+			limit: z.number().int().min(1).max(MAX_LIMIT).optional().describe(`How many results to return. Defaults to ${DEFAULT_LIMIT}.`)
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ query, content, limit }) => {
+		const result = await docs.searchDocs(query, content ?? false);
+		const results = result.hits.slice(0, limit ?? DEFAULT_LIMIT);
+		return text(asJson({
+			site: docs.baseUrl,
+			query,
+			searchedContent: result.searchedContent,
+			count: results.length,
+			results
+		}));
+	});
+	server.registerTool("get_doc", {
+		title: "Read a documentation page",
+		description: "One page of the newt/ui docs as Markdown. Accepts a route ('/docs/theming'), a slug ('button', 'installation/nuxt') or a full newtui.dev URL. Read this rather than recalling an API from memory.",
+		inputSchema: { path: z.string().min(1).describe("The page: a route, a slug or a URL.") },
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, async ({ path }) => {
+		const page = await docs.getDoc(path);
+		if (!page.found) return failure(`No documentation page at "${page.path}". Closest matches:\n\n${asJson({
+			site: docs.baseUrl,
+			path: page.path,
+			suggestions: page.suggestions
+		})}`);
+		return text(`<!-- Source: ${page.entry.url} -->\n\n${page.markdown}`);
+	});
+	return server;
+}
+/** Serve over stdio, which is how every MCP client launches a local server. */
+async function startServer(docs) {
+	await createServer(docs).connect(new StdioServerTransport());
+}
+
+//#endregion
+//#region src/index.ts
+const HELP = `newtui-mcp — an MCP server for the newt/ui documentation
+
+Usage
+  $ npx @newtui/mcp [--url <site>]
+
+Options
+  --url <site>   the docs site to read (default: ${DEFAULT_DOCS_URL})
+                 also read from NEWTUI_DOCS_URL
+  -h, --help     show this help
+  -v, --version  print the version
+
+The server speaks MCP over stdio; an editor launches it, not a person.`;
+async function main() {
+	const { values } = parseArgs({ options: {
+		url: { type: "string" },
+		help: {
+			type: "boolean",
+			short: "h"
+		},
+		version: {
+			type: "boolean",
+			short: "v"
+		}
+	} });
+	if (values.help === true) {
+		console.log(HELP);
+		return;
+	}
+	if (values.version === true) {
+		console.log(version);
+		return;
+	}
+	const baseUrl = resolveDocsUrl(values.url, process.env.NEWTUI_DOCS_URL);
+	let docs;
+	try {
+		docs = new DocsClient({ baseUrl });
+	} catch {
+		console.error(`newtui-mcp: "${baseUrl}" is not a URL.`);
+		process.exit(1);
+	}
+	await startServer(docs);
+}
+main().catch((error) => {
+	console.error(`newtui-mcp: ${error instanceof Error ? error.message : String(error)}`);
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@newtui/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "MCP server for the newt/ui documentation — lets a coding agent list, search and read the Discord-inspired component library's docs. Part of the WolfStar toolchain.",
+  "keywords": [
+    "component-library",
+    "design-system",
+    "discord",
+    "documentation",
+    "mcp",
+    "model-context-protocol",
+    "ui",
+    "wolfstar"
+  ],
+  "homepage": "https://newtui.dev/docs/mcp",
+  "bugs": {
+    "url": "https://github.com/wolfstar-project/newt-ui/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "@wolfstar",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wolfstar-project/newt-ui.git",
+    "directory": "packages/mcp"
+  },
+  "bin": {
+    "newtui-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsdown --config-loader unrun",
+    "dev": "tsdown --config-loader unrun --watch",
+    "prepack": "pnpm run build",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsdown": "^0.22.14",
+    "typescript": "^5.7.2",
+    "unrun": "^0.3.1",
+    "vitest": "^5.0.4"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}