@parity-app/cli 0.0.0-stage → 0.1.0

package/dist/bin.mjs

@@ -0,0 +1,831 @@
+#!/usr/bin/env node
+import { a as describeConsole, c as describeProps, d as mcpCallerName, i as describeComponents, l as describeTokens, n as call, o as describeExec, r as describeAccessibility, s as describeProblems, u as setCaller } from "./client-DsTLQ2lT.mjs";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { dirname, join, normalize, relative, resolve, sep } from "node:path";
+import { parseArgs } from "node:util";
+import { createInterface } from "node:readline";
+// src/check.ts
+/**
+* `parity lib check <library>`: inserts every component of a registry library file into the running app, once on its
+* own and once the way the Assets panel inserts it, inside its parents with its sample, and reports the parts that fail
+* alone but render inside. The tab's project must have the library installed. Exits with 1 below the library's floor
+* in the registry's `in-app.json`.
+*/
+async function runCheck(library, options) {
+	if (!library) throw new Error("parity lib check <library> [--tab t] [--mode m]");
+	const { applyLibraryEdits, componentNode, generateId, librarySource, parseLibraryEdits, withLibraryContext } = await import("./src-FF8eY6EI.mjs");
+	const { registryDir, registryEntries } = await import("./src-DYi23Ypb.mjs");
+	const entry = (await registryEntries()).find((item) => item.manifest.id === library);
+	if (!entry) throw new Error(`The registry has no library "${library}"`);
+	let manifest = entry.manifest;
+	if (manifest.edits) {
+		const edits = typeof manifest.edits === "string" ? parseLibraryEdits(JSON.parse(await readFile(join(dirname(entry.path), manifest.edits), "utf8"))) : manifest.edits;
+		manifest = applyLibraryEdits(manifest, edits).manifest;
+	}
+	const list = manifest.components?.list ?? {};
+	const names = Object.keys(list).filter((name) => list[name].visual !== false);
+	const id = (name) => `${library}/${name}`;
+	const sources = Object.fromEntries(Object.keys(list).map((name) => [id(name), {
+		...librarySource(library, name, list[name], library),
+		declaration: ""
+	}]));
+	const mode = options.mode ?? "desktop-light";
+	const exec = async (label, code) => {
+		const result = await call("exec", {
+			tab: options.tab,
+			label,
+			code
+		});
+		if (!result.ok) throw new Error(result.error ?? `${label} failed`);
+		const line = result.output.find((item) => item.startsWith("{") || item.startsWith("["));
+		if (!line) throw new Error(`${label} printed nothing`);
+		return line;
+	};
+	const infos = JSON.parse(await exec(`Read ${library}'s props`, `const ids = ${JSON.stringify(names.map(id))}
+const known = new Set(Components())
+Print(JSON.stringify(Object.fromEntries(ids.filter((id) => known.has(id)).map((id) => [id, Props(id, { all: true })]))))`));
+	if (names.filter((name) => !infos[id(name)]).length === names.length) throw new Error(`The tab's project doesn't have ${library} installed`);
+	const taken = /* @__PURE__ */ new Set();
+	const alone = names.map((name) => {
+		const node = {
+			type: "component",
+			id: generateId(taken),
+			component: id(name)
+		};
+		taken.add(node.id);
+		return node;
+	});
+	const inside = names.filter((name) => list[name].parents?.length || list[name].sample).map((name) => withLibraryContext(componentNode(id(name), infos[id(name)], taken), sources, [], taken));
+	const failing = async (design, nodes) => {
+		const line = await exec(`Check ${design}`, `for (const design of Designs().filter((d) => d.name === ${JSON.stringify(design)})) DeleteDesign(design.id)
+const spot = FindEmptySpace({ width: 1280, height: 2000 })
+const id = CreateDesign({ name: ${JSON.stringify(design)}, x: spot.x, y: spot.y })
+const grid = Insert(id, { type: "layout", name: "Grid", style: { direction: "row", wrap: true, gap: 4, padding: 4 }, children: [] })
+for (const node of ${JSON.stringify(nodes)}) Insert(grid, node)
+Print(JSON.stringify(await Problems(id, { mode: ${JSON.stringify(mode)} })))`);
+		return failures(JSON.parse(line), library);
+	};
+	const failAlone = await failing(`${library} alone`, alone);
+	const failInside = await failing(`${library} inside`, inside);
+	const report = score(library, mode, names.length, failAlone, failInside, list);
+	report.floor = JSON.parse(await readFile(join(registryDir(), "..", "in-app.json"), "utf8"))[library];
+	if (options.record) {
+		const kept = await recordAppErrors(registryDir(), library, report);
+		console.error(`Kept ${kept} errors from the app for ${library}; run parity lib with --registry to use them.`);
+	}
+	if (options.json) console.log(JSON.stringify(report, null, 2));
+	else console.log(describeCheck(report));
+	if (report.floor !== void 0 && report.score < report.floor) process.exitCode = 1;
+}
+/** Where a library's errors from the app are kept: `app-errors/<id>.json` beside the registry's files. */
+function appErrorsPath(registry, library) {
+	return join(registry, "..", "app-errors", `${library}.json`);
+}
+/** The app's errors kept for a library, by part, or none. */
+async function readAppErrors(registry, library) {
+	return readFile(appErrorsPath(registry, library), "utf8").then((text) => JSON.parse(text), () => void 0);
+}
+/**
+* Adds the parts that failed in the app to those kept before, with their own errors rather than a parent's: one kept
+* from an earlier check stays, so the parent its error named stays in the part's chain once it renders.
+*/
+async function recordAppErrors(registry, library, report) {
+	const kept = { ...await readAppErrors(registry, library) };
+	for (const [name, why] of Object.entries(report.misses)) if (!why.startsWith("inside ")) kept[name] = why;
+	const path = appErrorsPath(registry, library);
+	await mkdir(dirname(path), { recursive: true });
+	const sorted = Object.fromEntries(Object.entries(kept).sort(([a], [b]) => a.localeCompare(b, "en")));
+	await writeFile(path, `${JSON.stringify(sorted, null, 2)}\n`);
+	return Object.keys(sorted).length;
+}
+/**
+* The components of a library that a design's problems name, by why: `aria/Cell: Cell count must match…`, or
+* `"aria/Cell" isn't one of the project's components` for one the project doesn't have.
+*/
+function failures(problems, library) {
+	const failed = /* @__PURE__ */ new Map();
+	const escaped = library.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const pattern = new RegExp(`${escaped}/([\\w.$]+)(?:: |" )(.*)`);
+	for (const { problem } of problems) for (const line of problem.split("\n")) {
+		const match = pattern.exec(line);
+		if (match && !failed.has(match[1])) failed.set(match[1], match[2].slice(0, 160));
+	}
+	return failed;
+}
+/** A part counts once it and every parent it's placed in render. */
+function score(library, mode, components, failAlone, failInside, list) {
+	const placed = [...failAlone.keys()].filter((name) => list[name]?.parents?.length || list[name]?.sample);
+	const hits = placed.filter((name) => !failInside.has(name) && !(list[name].parents ?? []).some((parent) => failInside.has(parent)));
+	const misses = Object.fromEntries(placed.filter((name) => !hits.includes(name)).map((name) => [name, failInside.get(name) ?? `inside ${(list[name].parents ?? []).filter((parent) => failInside.has(parent)).join(", ")}, which fails`]));
+	return {
+		library,
+		mode,
+		components,
+		failAlone: Object.fromEntries(failAlone),
+		placed,
+		hits,
+		misses,
+		score: placed.length === 0 ? 100 : Math.floor(100 * hits.length / placed.length)
+	};
+}
+function describeCheck(report) {
+	const unplaced = Object.keys(report.failAlone).filter((name) => !report.placed.includes(name));
+	const lines = [`${report.library}: ${report.components} components, ${Object.keys(report.failAlone).length} fail on their own, ${report.placed.length} of them placed, ${report.hits.length} render inside their parents (${report.score}%${report.floor === void 0 ? "" : `, at least ${report.floor}%`})`];
+	for (const [name, why] of Object.entries(report.misses)) lines.push(`  ${name}: ${why}`);
+	if (unplaced.length > 0) lines.push(`  Not placed: ${unplaced.join(", ")}`);
+	if (report.floor !== void 0 && report.score < report.floor) lines.push(`Below ${report.library}'s floor.`);
+	return lines.join("\n");
+}
+// src/lib.ts
+/**
+* `parity lib`: writes a `.lib.par` by inspecting a package or the app itself. It runs on its own, with no app open,
+* because it reads the project's files and its own copy of TypeScript.
+*/
+async function runLib(packageName, options) {
+	const { appManifestPath, generateLibrary, manifestText, mergeManifest, reviseLibrary } = await import("./src-8MhDV_sA.mjs");
+	const { covers, registryDir, registryEntries } = await import("./src-DYi23Ypb.mjs");
+	const spec = packageName === void 0 ? void 0 : packageSpec(packageName);
+	let root = resolve(options.root ?? ".");
+	if (spec && (spec.version !== void 0 || options.registry && !options.root)) {
+		const { installedVersion, publishedVersion } = await import("./published-BtL8RM6W.mjs");
+		const listed = (await registryEntries()).filter((entry) => entry.manifest.package?.name === spec.name);
+		if (spec.version === void 0 && listed.length > 1) throw new Error(`The registry has ${listed.length} files for ${spec.name}; name a version, as ${spec.name}@1.2.3`);
+		const version = await publishedVersion(spec.name, spec.version ?? listed[0]?.manifest.package?.version ?? "latest");
+		console.error(`Installing ${spec.name} ${version} on its own…`);
+		root = await installedVersion(spec.name, version);
+	}
+	const { parseLibraryEdits } = await import("./src-8MhDV_sA.mjs");
+	const trialEdits = options.edits ? parseLibraryEdits(JSON.parse(await readFile(resolve(options.edits), "utf8"))) : void 0;
+	const recordedId = options.registry && spec ? options.id ?? (await registryEntries()).find((entry) => entry.manifest.package?.name === spec.name)?.manifest.id : void 0;
+	const appErrors = recordedId ? await readAppErrors(registryDir(), recordedId) : void 0;
+	const generated = await generateLibrary({
+		root,
+		...trialEdits ? { trialEdits } : {},
+		...appErrors ? { appErrors } : {},
+		...options.noExamples ? { examples: false } : {},
+		...options.noTags ? { tags: false } : {},
+		...spec ? { package: spec.name } : {},
+		...options.id ? { id: options.id } : {},
+		...options.name ? { name: options.name } : {},
+		...options.description ? { description: options.description } : {},
+		...options.range ? { range: options.range } : {}
+	});
+	const id = String(generated.manifest.id);
+	let target;
+	if (options.out === "-") target = void 0;
+	else if (options.out) target = resolve(options.out);
+	else if (options.registry) target = join(registryDir(), `${id}.lib.par`);
+	else if (packageName) target = resolve(`${id}.lib.par`);
+	else target = await appManifestPath(root);
+	const existing = target ? await readFile(target, "utf8").then((text) => JSON.parse(text), () => void 0) : void 0;
+	if (!options.range) {
+		const read = generated.manifest.package;
+		const range = read && keptRange(existing, read, (versions) => covers({ package: versions }, read.version));
+		if (range) generated.manifest.package = {
+			...read,
+			range
+		};
+	}
+	let only;
+	if (!options.only || options.only === "all") only = "all";
+	else only = options.only === "new" ? "new" : options.only.split(",");
+	const edits = options.edits && relative(dirname(target ?? resolve(".")), resolve(options.edits)).replaceAll("\\", "/");
+	const { manifest, report } = await reviseLibrary(generated, {
+		root,
+		previous: existing,
+		only,
+		...edits ? { edits } : {},
+		editsBase: dirname(target ?? resolve("."))
+	});
+	if (!target) {
+		console.log(JSON.stringify(manifest, null, 2));
+		console.error(describeReport(report));
+		return;
+	}
+	const written = packageName ? manifest : mergeManifest(existing, manifest);
+	await mkdir(dirname(target), { recursive: true });
+	await writeFile(target, manifestText(written));
+	if (options.json) console.log(JSON.stringify({
+		path: target,
+		report
+	}, null, 2));
+	else console.log(`Wrote ${relative(process.cwd(), target) || target}\n${describeReport(report)}`);
+}
+/**
+* The range a file being written over keeps: its own, while it still covers the version just read, so a range widened
+* by hand (Lucide's, from 0.400) survives regenerating. Undefined when the new range stands.
+*/
+function keptRange(existing, read, covers) {
+	const range = existing?.package?.range;
+	if (typeof range !== "string" || range === read.range) return void 0;
+	return covers({
+		...read,
+		range
+	}) ? range : void 0;
+}
+/** A package as `parity lib` is given it: a name, with a version or tag after an `@` (`@tabler/icons-react@3.50.0`). */
+function packageSpec(text) {
+	const at = text.lastIndexOf("@");
+	return at > 0 ? {
+		name: text.slice(0, at),
+		version: text.slice(at + 1)
+	} : { name: text };
+}
+/** The report in plain words: what was found, then what couldn't be decided. */
+function describeReport(report) {
+	const lines = [];
+	const from = report.package ? ` from ${report.package.name} ${report.package.version}` : "";
+	let kind = "a component library";
+	if (report.kind === "icons") kind = "an icon set";
+	else if (report.kind === "app") kind = "an app";
+	lines.push(`Described ${kind}${from}.`);
+	if (report.kind === "icons") lines.push(`  ${report.icons ?? 0} icons`);
+	if (report.iconTags) {
+		const { matched, of, source } = report.iconTags;
+		lines.push(`  Tags for ${matched} of ${of} icons, from ${source}`);
+	} else lines.push(`  ${report.components} components`);
+	const tokens = Object.entries(report.tokens);
+	const total = tokens.reduce((sum, [, count]) => sum + (count ?? 0), 0);
+	if (total > 0) {
+		const themes = report.themes.length > 0 ? `, with ${report.themes.join(", ")} themes` : "";
+		lines.push(`  ${total} tokens${themes}: ${tokens.map(([category, count]) => `${count} ${category}`).join(", ")}`);
+	}
+	if (report.breakpoints > 0) lines.push(`  ${report.breakpoints} breakpoints`);
+	for (const decorator of report.decorators) lines.push(`  Decorator: ${decorator}`);
+	if (report.providers.length > 0) lines.push(`  Providers and hosts it exports: ${report.providers.join(", ")}`);
+	if (report.ambiguous.length > 0) {
+		lines.push(`Left out, because the types can't say (${report.ambiguous.length}):`);
+		for (const entry of report.ambiguous.slice(0, 20)) lines.push(`  ${entry.name}: ${entry.reason}`);
+		if (report.ambiguous.length > 20) lines.push(`  and ${report.ambiguous.length - 20} more (--json lists them)`);
+	}
+	if (report.examples) {
+		const { repo, commit, how, files, used } = report.examples;
+		const matched = {
+			upstream: "the revision it records",
+			gitHead: "npm's gitHead",
+			tag: "its tag",
+			date: "its publish date"
+		}[how];
+		lines.push(`  Examples: ${files} files from ${repo} at ${commit.slice(0, 10)} (by ${matched}), using ${used} of its components`);
+	}
+	if (report.anatomy) {
+		const { parts, placed, complete, differ } = report.anatomy;
+		lines.push(`  Anatomy: of ${parts} parts its docs nest, ${placed} are placed as they show and ${complete} have every level`);
+		for (const entry of differ.slice(0, 10)) lines.push(`    ${entry.name}: docs ${entry.docs.join(" > ")}; file ${entry.file.join(" > ") || "no parents"}`);
+		if (differ.length > 10) lines.push(`    and ${differ.length - 10} more (--json lists them)`);
+	}
+	if (report.parts) {
+		const parts = report.parts;
+		const signals = Object.entries(parts.parents).map(([signal, count]) => `${count} by ${signal}`);
+		lines.push(`  Parents: ${signals.join(", ") || "none"}`);
+		lines.push(`  ${parts.failedAlone} components fail alone with no props; ${parts.fixed} render inside their parents with samples`);
+		if (parts.failing.length > 0) {
+			lines.push(`Still failing, for a hand edit (${parts.failing.length}):`);
+			for (const entry of parts.failing.slice(0, 20)) lines.push(`  ${entry.name}: ${entry.error.slice(0, 120)}`);
+			if (parts.failing.length > 20) lines.push(`  and ${parts.failing.length - 20} more (--json lists them)`);
+		}
+	}
+	if (report.changes) {
+		const changes = report.changes;
+		lines.push(`Since the last file: ${changes.added.length} new, ${changes.changed.length} changed, ${changes.removed.length} removed, ${changes.unchanged} unchanged`);
+		if (changes.added.length > 0) lines.push(`  New: ${changes.added.slice(0, 30).join(", ")}`);
+		for (const change of changes.changed.slice(0, 20)) {
+			const parts = [
+				change.added.length > 0 ? `props added ${change.added.join(", ")}` : "",
+				change.removed.length > 0 ? `removed ${change.removed.join(", ")}` : "",
+				change.retyped.length > 0 ? `retyped ${change.retyped.join(", ")}` : "",
+				change.as ? `now ${change.as}` : ""
+			].filter(Boolean);
+			lines.push(`  Changed ${change.name}: ${parts.join("; ") || "no fingerprint before"}`);
+		}
+		if (changes.removed.length > 0) lines.push(`  Removed: ${changes.removed.join(", ")}`);
+	}
+	if (report.orphanEdits?.length) lines.push(`Hand edits for exports it no longer has, kept for you to move or delete: ${report.orphanEdits.join(", ")}`);
+	for (const note of report.notes) lines.push(`Note: ${note}`);
+	return lines.join("\n");
+}
+// src/skills.ts
+const root = join(import.meta.dirname, "..", "skills");
+/** Reads the Parity design skill: SKILL.md, or a file it references. */
+async function readSkill(path = "SKILL.md") {
+	const target = normalize(join(root, path));
+	if (relative(root, target).startsWith("..") || relative(root, target).includes(`..${sep}`)) throw new Error(`${path} isn't part of the skill`);
+	try {
+		return await readFile(target, "utf8");
+	} catch {
+		const files = await list();
+		throw new Error(`No skill file ${path}. Files: ${files.join(", ")}`);
+	}
+}
+async function list(directory = root) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (entry) => entry.isDirectory() ? list(join(directory, entry.name)) : [relative(root, join(directory, entry.name)).replaceAll("\\", "/")]))).flat();
+}
+// src/mcp.ts
+const tab = {
+	type: "string",
+	description: "Tab id, project root or name. Defaults to the active tab."
+};
+const tools = [
+	{
+		name: "get_tabs",
+		description: "List the projects open in Parity, one per tab. The active tab is the one the person is looking at.",
+		inputSchema: {
+			type: "object",
+			properties: {}
+		},
+		run: async () => [text(JSON.stringify(await call("tabs"), null, 2))]
+	},
+	{
+		name: "get_app_state",
+		description: "Get a tab's state: its designs (ids, states, modes shown, where their boards are and how big), boards that overlap or crowd each other's titles, the selection, project modes, components and tokens, and what Parity detected in the project (each tool's version, where it's installed and its config, the package manager, and a note naming versions Parity doesn't test). Call it first, and again after the person may have changed things. Keep boards apart: Overlaps() and FindEmptySpace() in execute help place them.",
+		inputSchema: {
+			type: "object",
+			properties: { tab }
+		},
+		run: async (input) => [text(JSON.stringify(await call("state", { tab: input.tab }), null, 2))]
+	},
+	{
+		name: "execute",
+		description: "Run a JavaScript snippet against a tab's designs with the Parity API (read_skill \"execute.md\"). All changes land as one undoable step, or none if it fails. On failure, retry with editId and edits instead of resending.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				description: {
+					type: "string",
+					description: "Shown to the person while it runs. 3 to 8 words, imperative, e.g. \"Add pricing tiers\"."
+				},
+				input: {
+					type: "string",
+					description: "The snippet. Omit when retrying with editId and edits."
+				},
+				editId: {
+					type: "string",
+					description: "The failed call's editId, to patch and rerun its snippet."
+				},
+				edits: {
+					type: "array",
+					description: "Exact find and replace edits to the failed snippet, applied in order.",
+					items: {
+						type: "object",
+						properties: {
+							find: { type: "string" },
+							replace: { type: "string" },
+							all: { type: "boolean" }
+						},
+						required: ["find", "replace"]
+					}
+				},
+				tab
+			},
+			required: ["description"]
+		},
+		run: async (input) => {
+			const result = await call("exec", {
+				tab: input.tab,
+				label: input.description,
+				code: input.input,
+				editId: input.editId,
+				edits: input.edits
+			});
+			return [text(describeExec(result)), ...result.screenshots.map((shot) => image(shot.png))];
+		}
+	},
+	{
+		name: "screenshot",
+		description: "Capture a design in any of its states and modes, rendered offscreen at real widths. state and mode take an id, a list, or \"all\"; mode also takes \"shown\".",
+		inputSchema: {
+			type: "object",
+			properties: {
+				design: {
+					type: "string",
+					description: "Design id or name."
+				},
+				state: { description: "State id, list of ids, or \"all\". Defaults to the state the design shows." },
+				mode: { description: "Mode id, list of ids, \"shown\" or \"all\". Defaults to the primary mode." },
+				scale: {
+					type: "number",
+					description: "Pixel density, 0.25 to 3. Defaults to 1."
+				},
+				tab
+			},
+			required: ["design"]
+		},
+		run: async (input) => {
+			const result = await call("screenshot", input);
+			return [text(describeExec(result)), ...result.screenshots.map((shot) => image(shot.png))];
+		}
+	},
+	{
+		name: "find_problems",
+		description: "Find layout problems in a design, rendered offscreen in every state and the modes it shows unless you narrow it: render errors, content wider than the frame, nodes cut off by a parent that clips, and components that aren't the project's. Run it after changes, with screenshot. state and mode take an id, a list, or \"all\"; mode also takes \"shown\".",
+		inputSchema: {
+			type: "object",
+			properties: {
+				design: {
+					type: "string",
+					description: "Design id or name."
+				},
+				state: { description: "State id, list of ids, or \"all\". Defaults to \"all\"." },
+				mode: { description: "Mode id, list of ids, \"shown\" or \"all\". Defaults to \"shown\"." },
+				tab
+			},
+			required: ["design"]
+		},
+		run: async (input) => [text(describeProblems(await call("problems", input)))]
+	},
+	{
+		name: "check_accessibility",
+		description: "Check a design's accessibility with axe-core against WCAG 2.2 AA, rendered offscreen in every state and the modes it shows unless you narrow it. Lists each rule broken, worst first, with the layers that break it (ids you can pass to execute), the frames, what's wrong and a link on how to fix it. state and mode take an id, a list, or \"all\"; mode also takes \"shown\". Automated checks find some issues, not all.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				design: {
+					type: "string",
+					description: "Design id or name."
+				},
+				state: { description: "State id, list of ids, or \"all\". Defaults to \"all\"." },
+				mode: { description: "Mode id, list of ids, \"shown\" or \"all\". Defaults to \"shown\"." },
+				tab
+			},
+			required: ["design"]
+		},
+		run: async (input) => [text(describeAccessibility(await call("accessibility", input)))]
+	},
+	{
+		name: "get_console",
+		description: "Read what the project's own code wrote to the console: errors, warnings and logs from its components on the canvas, including while the person interacts with them, and from offscreen renders such as screenshots. Oldest first; the same message several times in a row is counted once. clear: true empties it after reading, so the next read shows only what's new.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				clear: {
+					type: "boolean",
+					description: "Empty it after reading."
+				},
+				tab
+			}
+		},
+		run: async (input) => [text(describeConsole(await call("console", input)))]
+	},
+	{
+		name: "open_project",
+		description: "Open a project folder in a new Parity tab, or switch to it if it's already open.",
+		inputSchema: {
+			type: "object",
+			properties: { root: {
+				type: "string",
+				description: "Absolute path."
+			} },
+			required: ["root"]
+		},
+		run: async (input) => [text(JSON.stringify(await call("open", { root: input.root }), null, 2))]
+	},
+	{
+		name: "read_skill",
+		description: "Read Parity's design skill: SKILL.md, or a file it references such as execute.md or guide/web-app.md.",
+		inputSchema: {
+			type: "object",
+			properties: { path: { type: "string" } }
+		},
+		run: async (input) => [text(await readSkill(input.path))]
+	}
+];
+const instructions = "Parity renders a project's real components on a canvas. Designs are trees of the project's own components, layouts and text, styled only with its tokens, with states (like stories) and modes (viewport, theme, locale). Read the skill (read_skill) before designing, start with get_app_state, change designs with execute, check every state and mode with screenshot and find_problems, check accessibility with check_accessibility, and read what the components log with get_console.";
+/** Serves Parity's tools over MCP on stdin and stdout. */
+function serveMcp() {
+	const lines = createInterface({ input: process.stdin });
+	const send = (message) => process.stdout.write(`${JSON.stringify(message)}\n`);
+	lines.on("line", (line) => {
+		if (!line.trim()) return;
+		let message;
+		try {
+			message = JSON.parse(line);
+		} catch {
+			send({
+				jsonrpc: "2.0",
+				id: null,
+				error: {
+					code: -32700,
+					message: "Parse error"
+				}
+			});
+			return;
+		}
+		respond(message).then((reply) => {
+			if (message.id !== void 0 && reply) send({
+				jsonrpc: "2.0",
+				id: message.id,
+				...reply
+			});
+		});
+	});
+}
+async function respond(message) {
+	switch (message.method) {
+		case "initialize": {
+			const name = mcpCallerName(message.params?.clientInfo);
+			setCaller(name, true);
+			return { result: {
+				protocolVersion: message.params?.protocolVersion ?? "2025-06-18",
+				capabilities: { tools: {} },
+				serverInfo: {
+					name: "parity",
+					version: "0.0.0"
+				},
+				instructions
+			} };
+		}
+		case "ping": return { result: {} };
+		case "tools/list": return { result: { tools: tools.map(({ name, description, inputSchema }) => ({
+			name,
+			description,
+			inputSchema
+		})) } };
+		case "tools/call": {
+			const tool = tools.find((candidate) => candidate.name === message.params?.name);
+			if (!tool) return { error: {
+				code: -32602,
+				message: `Unknown tool ${String(message.params?.name)}`
+			} };
+			try {
+				return { result: { content: await tool.run(message.params?.arguments ?? {}) } };
+			} catch (error) {
+				return { result: {
+					content: [text(error instanceof Error ? error.message : String(error))],
+					isError: true
+				} };
+			}
+		}
+		default: return message.method?.startsWith("notifications/") ? void 0 : { error: {
+			code: -32601,
+			message: `Unknown method ${message.method}`
+		} };
+	}
+}
+function text(value) {
+	return {
+		type: "text",
+		text: value
+	};
+}
+function image(data) {
+	return {
+		type: "image",
+		data,
+		mimeType: "image/png"
+	};
+}
+// src/bin.ts
+const usage = `parity: drive the Parity app from a terminal or an agent
+
+  parity tabs                               list open project tabs
+  parity state [--tab t]                    designs, selection, modes, components and tokens of a tab
+  parity exec [file] --label "Do x"         run a snippet (from a file, or stdin) as one undoable step
+       [--edit-id id --edits '[{"find":"a","replace":"b"}]']   retry a failed snippet with edits
+  parity screenshot <design> [--state s|all] [--mode m|shown|all] [--scale 2] [--tab t]
+  parity a11y <design> [--state s|all] [--mode m|shown|all] [--tab t]
+                                            check accessibility with axe-core, in every state and the modes shown
+                                            unless narrowed; exits with 1 when it finds issues
+  parity problems <design> [--state s|all] [--mode m|shown|all] [--tab t]
+                                            render errors, overflow, clipping and unknown components, in every state
+                                            and the modes shown unless narrowed; exits with 1 when it finds any
+  parity console [--clear] [--tab t]        what the project's code wrote to the console, on the canvas and in
+                                            offscreen renders; --clear empties it after reading
+  parity tokens [--category c] [--source semantic|theme] [--search s] [--tab t]
+                                            the tokens styles can name, with their values per theme
+  parity components [--tab t]               the components designs can use, by library
+  parity props <Component> [--all] [--tab t]
+                                            a component's props from its source; --all adds the attributes it passes on
+  parity lib [package] [--root dir] [--out file|-] [--registry] [--id id] [--name n] [--range r] [--json]
+       [--only new|all|A,B] [--edits file] [--no-examples] [--no-tags]
+                                            write a .lib.par: a package's components, tokens, breakpoints, icons and
+                                            decorators, found from its types and styles, with each part's parents and
+                                            what it needs to render, tried with React's server renderer. Without a
+                                            package, the app at --root (the current folder) is described, into the
+                                            .lib.par at its root. Runs without the app; --registry writes into
+                                            Parity's own registry. Over an existing file it reports new, changed and
+                                            removed components; --only new or --only A,B writes just those, keeping
+                                            the rest as they were. Hand edits (the file's edits, or a shared --edits
+                                            file) are kept, and any whose export has gone are reported. Parts
+                                            and samples come first from the library's own examples and stories,
+                                            fetched from its repository at the commit the installed version was
+                                            published from (cached under ~/.parity/cache); --no-examples skips them.
+                                            An icon set's tags are read from its published metadata on npm at the
+                                            same version; --no-tags skips them. A package named with a version or
+                                            tag (lucide-react@1.63.0, lucide-react@latest) is installed on its own at
+                                            that version, under ~/.parity/cache, rather than read from a project;
+                                            so is one written with --registry and no --root, at the version its
+                                            registry file covers. A file written over keeps its range while it
+                                            covers the version read
+  parity lib check <library> [--mode m] [--json] [--record] [--tab t]
+                                            insert every component of a registry library file into the tab's
+                                            project, once alone and once as the Assets panel inserts it, inside its
+                                            parents with its sample, and report the parts that fail alone but render
+                                            inside; exits with 1 below the library's floor in the registry's
+                                            in-app.json. --record keeps why parts failed in the registry's app-errors,
+                                            where parity lib --registry reads the parents they name
+  parity open <folder>                      open a project in a new tab
+  parity skill [file]                       print the design skill, or one of its files
+  parity mcp                                serve these as MCP tools on stdio
+
+Options take a tab id, project root or name with --tab; the active tab is the default.`;
+const { positionals, values } = parseArgs({
+	allowPositionals: true,
+	options: {
+		tab: { type: "string" },
+		label: { type: "string" },
+		"edit-id": { type: "string" },
+		edits: { type: "string" },
+		state: {
+			type: "string",
+			multiple: true
+		},
+		mode: {
+			type: "string",
+			multiple: true
+		},
+		scale: { type: "string" },
+		json: { type: "boolean" },
+		record: { type: "boolean" },
+		clear: { type: "boolean" },
+		all: { type: "boolean" },
+		category: { type: "string" },
+		source: { type: "string" },
+		search: { type: "string" },
+		root: { type: "string" },
+		out: { type: "string" },
+		registry: { type: "boolean" },
+		id: { type: "string" },
+		name: { type: "string" },
+		description: { type: "string" },
+		range: { type: "string" },
+		only: { type: "string" },
+		"no-examples": { type: "boolean" },
+		"no-tags": { type: "boolean" },
+		help: {
+			type: "boolean",
+			short: "h"
+		}
+	}
+});
+const [command, ...rest] = positionals;
+try {
+	await main();
+} catch (error) {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+}
+async function main() {
+	if (!command || values.help) {
+		console.log(usage);
+		return;
+	}
+	switch (command) {
+		case "tabs": return print(await call("tabs"));
+		case "state": return print(await call("state", { tab: values.tab }));
+		case "open":
+			if (!rest[0]) throw new Error("parity open <folder>");
+			return print(await call("open", { root: resolve(rest[0]) }));
+		case "skill":
+			console.log(await readSkill(rest[0]));
+			return;
+		case "mcp":
+			serveMcp();
+			return;
+		case "lib":
+			if (rest[0] === "check") return runCheck(rest[1], {
+				...values.tab ? { tab: values.tab } : {},
+				...values.mode?.[0] ? { mode: values.mode[0] } : {},
+				...values.json ? { json: true } : {},
+				...values.record ? { record: true } : {}
+			});
+			return runLib(rest[0], {
+				...values.root ? { root: values.root } : {},
+				...values.out ? { out: values.out } : {},
+				...values.registry ? { registry: true } : {},
+				...values.id ? { id: values.id } : {},
+				...values.name ? { name: values.name } : {},
+				...values.description ? { description: values.description } : {},
+				...values.range ? { range: values.range } : {},
+				...values.only ? { only: values.only } : {},
+				...values["no-examples"] ? { noExamples: true } : {},
+				...values["no-tags"] ? { noTags: true } : {},
+				...values.edits ? { edits: values.edits } : {},
+				...values.json ? { json: true } : {}
+			});
+		case "exec": {
+			const editId = values["edit-id"];
+			let code;
+			if (!editId) code = rest[0] ? await readFile(rest[0], "utf8") : await stdin();
+			const edits = values.edits ? JSON.parse(values.edits) : void 0;
+			report(await call("exec", {
+				tab: values.tab,
+				label: values.label ?? "Edit from the CLI",
+				code,
+				editId,
+				edits
+			}));
+			return;
+		}
+		case "screenshot":
+			if (!rest[0]) throw new Error("parity screenshot <design> [--state s] [--mode m]");
+			report(await call("screenshot", {
+				tab: values.tab,
+				design: rest[0],
+				state: one(values.state),
+				mode: one(values.mode),
+				scale: values.scale ? Number(values.scale) : void 0
+			}));
+			return;
+		case "a11y":
+		case "accessibility": {
+			if (!rest[0]) throw new Error("parity a11y <design> [--state s] [--mode m]");
+			const result = await call("accessibility", {
+				tab: values.tab,
+				design: rest[0],
+				state: one(values.state),
+				mode: one(values.mode)
+			});
+			if (values.json) print(result);
+			else console.log(describeAccessibility(result));
+			if (result.findings.length > 0) process.exitCode = 1;
+			return;
+		}
+		case "problems": {
+			if (!rest[0]) throw new Error("parity problems <design> [--state s] [--mode m]");
+			const result = await call("problems", {
+				tab: values.tab,
+				design: rest[0],
+				state: one(values.state),
+				mode: one(values.mode)
+			});
+			if (values.json) print(result);
+			else console.log(describeProblems(result));
+			if (result.problems.length > 0) process.exitCode = 1;
+			return;
+		}
+		case "tokens": {
+			const filter = {
+				category: values.category,
+				source: values.source,
+				search: values.search
+			};
+			const tokens = await call("tokens", {
+				tab: values.tab,
+				...filter
+			});
+			if (values.json) print(tokens);
+			else console.log(describeTokens(tokens));
+			return;
+		}
+		case "components": {
+			const result = await call("components", { tab: values.tab });
+			if (values.json) print(result);
+			else console.log(describeComponents(result));
+			return;
+		}
+		case "props": {
+			if (!rest[0]) throw new Error("parity props <Component> [--all]");
+			const result = await call("props", {
+				tab: values.tab,
+				component: rest[0],
+				all: values.all
+			});
+			if (values.json) print(result);
+			else console.log(describeProps(result));
+			return;
+		}
+		case "console": {
+			const result = await call("console", {
+				tab: values.tab,
+				clear: values.clear
+			});
+			if (values.json) print(result);
+			else console.log(describeConsole(result));
+			return;
+		}
+		default: throw new Error(`Unknown command ${command}\n\n${usage}`);
+	}
+}
+function report(result) {
+	if (values.json) print({
+		...result,
+		screenshots: result.screenshots.map(({ png: _png, ...shot }) => shot)
+	});
+	else console.log(describeExec(result));
+	if (!result.ok) process.exitCode = 1;
+}
+/** A repeated option becomes a list; one value stays a string, so "all" and "shown" work. */
+function one(list) {
+	if (!list || list.length === 0) return void 0;
+	return list.length === 1 ? list[0] : list;
+}
+function print(value) {
+	console.log(JSON.stringify(value, null, 2));
+}
+async function stdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8");
+}
+export {};