@wot-ui/cli 0.0.1-beta.10

package/data/versions.json

@@ -0,0 +1,10 @@
+{
+  "latest": "2.0.0-alpha.5",
+  "supported": [
+    "2.0.0-alpha.5"
+  ],
+  "aliases": {
+    "v2": "2.0.0-alpha.5",
+    "latest": "2.0.0-alpha.5"
+  }
+}

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1,414 @@
+#!/usr/bin/env node
+import { a as resolveVersion, i as listComponents, n as lintProject, o as loadMetadataFile, r as findComponent, s as version, t as analyzeUsage } from "./scanner-_isnOGJK.mjs";
+import process from "node:process";
+import { Command } from "commander";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+//#region src/utils/output.ts
+function writeStdout(message) {
+	process.stdout.write(message);
+}
+function writeLine(message = "") {
+	writeStdout(`${message}\n`);
+}
+function writeJson(value) {
+	writeLine(JSON.stringify(value, null, 2));
+}
+
+//#endregion
+//#region src/commands/shared.ts
+function addQueryOptions(command) {
+	return command.option("--format <format>", "output format: text, json, markdown", "text").option("--version <version>", "target wot-ui version");
+}
+function normalizeQueryOptions(options) {
+	return {
+		format: options.format === "json" || options.format === "markdown" ? options.format : "text",
+		version: typeof options.version === "string" ? options.version : void 0
+	};
+}
+function printError(message, format) {
+	if (format === "json") writeJson({
+		error: true,
+		message
+	});
+	else console.error(message);
+}
+function getComponentLabel(component) {
+	return `${component.name} ${component.nameZh}`;
+}
+function getComponentDescription(component) {
+	return component.descriptionZh;
+}
+function formatCssVars(cssVars) {
+	return cssVars.map((cssVar) => ({
+		name: cssVar.name,
+		defaultValue: cssVar.defaultValue ?? cssVar.token ?? "-",
+		description: cssVar.description
+	}));
+}
+
+//#endregion
+//#region src/commands/changelog.ts
+function registerChangelogCommand(program) {
+	addQueryOptions(program.command("changelog").argument("[versionOrComponent]", "Version or component name").argument("[component]", "Optional component name").description("Show changelog entries")).action((versionOrComponent, componentArg, options) => {
+		const query = normalizeQueryOptions(options);
+		try {
+			const metadata = loadMetadataFile(resolveVersion(query.version));
+			let versionFilter;
+			let componentFilter;
+			if (versionOrComponent && /^v?\d/.test(versionOrComponent)) versionFilter = versionOrComponent;
+			else if (versionOrComponent) componentFilter = versionOrComponent;
+			if (componentArg) componentFilter = componentArg;
+			const entries = (metadata.changelog ?? []).filter((entry) => {
+				const versionMatches = versionFilter ? entry.version === versionFilter || `v${entry.version}` === versionFilter : true;
+				const componentMatches = componentFilter ? (entry.components ?? []).some((component) => component.toLowerCase() === componentFilter.toLowerCase()) : true;
+				return versionMatches && componentMatches;
+			});
+			if (query.format === "json") {
+				writeJson({ entries });
+				return;
+			}
+			writeLine(entries.flatMap((entry) => [
+				`${entry.version}${entry.date ? ` (${entry.date})` : ""}`,
+				entry.summary,
+				...entry.highlights.map((item) => `- ${item}`),
+				""
+			]).join("\n").trim());
+		} catch (error) {
+			printError(error instanceof Error ? error.message : "Failed to load changelog", query.format);
+			process.exitCode = 1;
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/demo.ts
+function registerDemoCommand(program) {
+	addQueryOptions(program.command("demo").argument("<component>", "Component name or wd-* tag").argument("[name]", "Demo name").description("Show component demo source code")).action((componentName, demoName, options) => {
+		const query = normalizeQueryOptions(options);
+		try {
+			const component = findComponent(componentName, query.version);
+			if (!component) {
+				printError(`Component not found: ${componentName}`, query.format);
+				process.exitCode = 1;
+				return;
+			}
+			const demos = component.demos ?? [];
+			if (!demoName) {
+				if (query.format === "json") {
+					writeJson({
+						component: component.name,
+						demos
+					});
+					return;
+				}
+				writeLine(demos.map((demo$1) => `- ${demo$1.name}: ${demo$1.title}`).join("\n"));
+				return;
+			}
+			const demo = demos.find((item) => item.name.toLowerCase() === demoName.toLowerCase());
+			if (!demo) {
+				printError(`Demo not found: ${demoName}`, query.format);
+				process.exitCode = 1;
+				return;
+			}
+			if (query.format === "json") {
+				writeJson({
+					component: component.name,
+					demo
+				});
+				return;
+			}
+			writeLine(demo.code);
+		} catch (error) {
+			printError(error instanceof Error ? error.message : "Failed to load demo", query.format);
+			process.exitCode = 1;
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/doc.ts
+function registerDocCommand(program) {
+	addQueryOptions(program.command("doc").argument("<component>", "Component name or wd-* tag").description("Print component markdown documentation")).action((componentName, options) => {
+		const query = normalizeQueryOptions(options);
+		try {
+			const component = findComponent(componentName, query.version);
+			if (!component?.doc) {
+				printError(`Documentation not found: ${componentName}`, query.format);
+				process.exitCode = 1;
+				return;
+			}
+			if (query.format === "json") {
+				writeJson({
+					name: component.name,
+					doc: component.doc
+				});
+				return;
+			}
+			writeLine(component.doc);
+		} catch (error) {
+			printError(error instanceof Error ? error.message : "Failed to load documentation", query.format);
+			process.exitCode = 1;
+		}
+	});
+}
+
+//#endregion
+//#region src/utils/project.ts
+function readPackageJson(dir) {
+	const packageJsonPath = join(dir, "package.json");
+	if (!existsSync(packageJsonPath)) return void 0;
+	return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+}
+function getDependencyVersion(pkg, name) {
+	return pkg?.dependencies?.[name] ?? pkg?.devDependencies?.[name];
+}
+function detectWotDependency(pkg) {
+	const version$1 = getDependencyVersion(pkg, "@wot-ui/ui");
+	return version$1 ? `@wot-ui/ui@${version$1}` : void 0;
+}
+function createCheck(name, status, message, suggestion) {
+	if (status === "pass") return {
+		name,
+		status,
+		message
+	};
+	return {
+		name,
+		status,
+		severity: status === "fail" ? "error" : "warning",
+		message,
+		suggestion
+	};
+}
+function diagnoseProject(targetDir) {
+	const dir = resolve(targetDir);
+	const pkg = readPackageJson(dir);
+	const checks = [];
+	if (!pkg) {
+		checks.push(createCheck("package-json", "fail", "No package.json found in target directory.", "Run the command in a project root or pass a directory containing package.json."));
+		return {
+			dir,
+			checks
+		};
+	}
+	checks.push(createCheck("package-json", "pass", "package.json found."));
+	const wotVersion = detectWotDependency(pkg);
+	if (wotVersion) checks.push(createCheck("wot-ui-installed", "pass", `Detected ${wotVersion}.`));
+	else checks.push(createCheck("wot-ui-installed", "fail", "No @wot-ui/ui dependency detected.", "Add @wot-ui/ui to dependencies before using doctor, usage, and lint."));
+	const vueVersion = getDependencyVersion(pkg, "vue");
+	if (vueVersion) checks.push(createCheck("vue-version", vueVersion.includes("3") ? "pass" : "warn", `Detected vue ${vueVersion}.`, vueVersion.includes("3") ? void 0 : "wot-ui v2 is designed for Vue 3 based projects."));
+	else checks.push(createCheck("vue-version", "warn", "Vue dependency not found.", "Add vue@3 to align with wot-ui v2 expectations."));
+	const uniAppVersion = getDependencyVersion(pkg, "@dcloudio/uni-app") ?? getDependencyVersion(pkg, "uni-app");
+	if (uniAppVersion) checks.push(createCheck("uni-app-version", "pass", `Detected uni-app ${uniAppVersion}.`));
+	else checks.push(createCheck("uni-app-version", "warn", "uni-app dependency not found.", "If this is a uni-app project, add @dcloudio/uni-app."));
+	const typescriptVersion = getDependencyVersion(pkg, "typescript");
+	if (typescriptVersion) checks.push(createCheck("typescript", "pass", `Detected typescript ${typescriptVersion}.`));
+	else checks.push(createCheck("typescript", "warn", "TypeScript dependency not found.", "Add TypeScript if you want type-safe wot-ui development and CLI analysis."));
+	const hasNodeModules = existsSync(join(dir, "node_modules"));
+	checks.push(createCheck("node-modules", hasNodeModules ? "pass" : "warn", hasNodeModules ? "node_modules directory found." : "node_modules directory not found.", hasNodeModules ? void 0 : "Run your package manager install command before deeper diagnostics."));
+	return {
+		dir,
+		checks
+	};
+}
+
+//#endregion
+//#region src/commands/doctor.ts
+function registerDoctorCommand(program) {
+	addQueryOptions(program.command("doctor").argument("[dir]", "Project directory", ".").description("Diagnose a wot-ui project")).action((dir, options) => {
+		const query = normalizeQueryOptions(options);
+		try {
+			const report = diagnoseProject(resolve(dir));
+			if (query.format === "json") {
+				writeJson(report);
+				return;
+			}
+			writeLine([`Directory: ${report.dir}`, ...report.checks.map((check) => `${check.status.toUpperCase()} ${check.name}: ${check.message}${check.suggestion ? ` | ${check.suggestion}` : ""}`)].join("\n"));
+		} catch (error) {
+			printError(error instanceof Error ? error.message : "Failed to diagnose project", query.format);
+			process.exitCode = 1;
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/info.ts
+function registerInfoCommand(program) {
+	addQueryOptions(program.command("info").argument("<component>", "Component name or wd-* tag").description("Show component props, events, slots and CSS variables")).action((componentName, options) => {
+		const query = normalizeQueryOptions(options);
+		try {
+			const component = findComponent(componentName, query.version);
+			if (!component) {
+				printError(`Component not found: ${componentName}`, query.format);
+				process.exitCode = 1;
+				return;
+			}
+			if (query.format === "json") {
+				writeJson(component);
+				return;
+			}
+			writeLine([
+				`${getComponentLabel(component)} (${component.tag})`,
+				getComponentDescription(component),
+				"",
+				"Props:",
+				...component.props.map((prop) => `- ${prop.name}: ${prop.type}${prop.default ? ` = ${prop.default}` : ""} | ${prop.description}`),
+				"",
+				"Events:",
+				...component.events.map((event) => `- ${event.name}${event.payload ? ` (${event.payload})` : ""}: ${event.description}`),
+				"",
+				"Slots:",
+				...component.slots.map((slot) => `- ${slot.name}: ${slot.description}`),
+				"",
+				"CSS Variables:",
+				...component.cssVars.map((cssVar) => {
+					const defaultValue = cssVar.defaultValue ?? cssVar.token;
+					return `- ${cssVar.name}${defaultValue ? ` = ${defaultValue}` : ""}: ${cssVar.description}`;
+				})
+			].join("\n"));
+		} catch (error) {
+			printError(error instanceof Error ? error.message : "Failed to load component info", query.format);
+			process.exitCode = 1;
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/lint.ts
+function registerLintCommand(program) {
+	addQueryOptions(program.command("lint").argument("[dir]", "Project directory", ".").description("Lint wot-ui usage")).action((dir, options) => {
+		const query = normalizeQueryOptions(options);
+		try {
+			const report = lintProject(resolve(dir), query.version);
+			if (query.format === "json") {
+				writeJson(report);
+				return;
+			}
+			if (!report.issues.length) {
+				writeLine(`No lint issues found. Scanned files: ${report.scannedFiles}`);
+				return;
+			}
+			writeLine([`Scanned files: ${report.scannedFiles}`, ...report.issues.map((issue) => `${issue.severity.toUpperCase()} ${issue.file}:${issue.line} [${issue.rule}] ${issue.message}`)].join("\n"));
+		} catch (error) {
+			printError(error instanceof Error ? error.message : "Failed to lint project", query.format);
+			process.exitCode = 1;
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/list.ts
+function registerListCommand(program) {
+	addQueryOptions(program.command("list").description("List available wot-ui components")).action((options) => {
+		const query = normalizeQueryOptions(options);
+		try {
+			const components = listComponents(query.version);
+			if (query.format === "json") {
+				writeJson({ components });
+				return;
+			}
+			writeLine(components.map((component) => `- ${getComponentLabel(component)} (${component.tag}): ${getComponentDescription(component)}`).join("\n"));
+		} catch (error) {
+			printError(error instanceof Error ? error.message : "Failed to list components", query.format);
+			process.exitCode = 1;
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/mcp.ts
+function registerMcpCommand(program) {
+	program.command("mcp").description("Start the wot-ui MCP server").action(async () => {
+		const { startMcpServer } = await import("./server-BLoIUV7u.mjs");
+		await startMcpServer();
+	});
+}
+
+//#endregion
+//#region src/commands/token.ts
+function registerTokenCommand(program) {
+	addQueryOptions(program.command("token").argument("[component]", "Component name or wd-* tag").description("Query component CSS variables")).action((componentName, options) => {
+		const query = normalizeQueryOptions(options);
+		try {
+			if (!componentName) {
+				writeJson(listComponents(query.version).flatMap((component$1) => component$1.cssVars.map((cssVar) => ({
+					component: component$1.name,
+					...cssVar
+				}))));
+				return;
+			}
+			const component = findComponent(componentName, query.version);
+			if (!component) {
+				printError(`Component not found: ${componentName}`, query.format);
+				process.exitCode = 1;
+				return;
+			}
+			if (query.format === "json") {
+				writeJson({
+					name: component.name,
+					cssVars: formatCssVars(component.cssVars)
+				});
+				return;
+			}
+			writeLine([component.name, ...component.cssVars.map((cssVar) => {
+				const defaultValue = cssVar.defaultValue ?? cssVar.token;
+				return `- ${cssVar.name}${defaultValue ? ` = ${defaultValue}` : ""}: ${cssVar.description}`;
+			})].join("\n"));
+		} catch (error) {
+			printError(error instanceof Error ? error.message : "Failed to query CSS variables", query.format);
+			process.exitCode = 1;
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/usage.ts
+function registerUsageCommand(program) {
+	addQueryOptions(program.command("usage").argument("[dir]", "Project directory", ".").description("Analyze project usage of wot-ui")).action((dir, options) => {
+		const query = normalizeQueryOptions(options);
+		try {
+			const report = analyzeUsage(resolve(dir), query.version);
+			if (query.format === "json") {
+				writeJson(report);
+				return;
+			}
+			const lines = [
+				`Scanned files: ${report.scannedFiles}`,
+				"Components:",
+				...report.components.map((component) => `- ${component.name} (${component.tag}): ${component.count} in ${component.files.join(", ")}`)
+			];
+			if (report.imports.length) lines.push("", "Imports:", ...report.imports.map((item) => `- ${item}`));
+			writeLine(lines.join("\n"));
+		} catch (error) {
+			printError(error instanceof Error ? error.message : "Failed to analyze project usage", query.format);
+			process.exitCode = 1;
+		}
+	});
+}
+
+//#endregion
+//#region src/app.ts
+function createCliProgram() {
+	const program = new Command();
+	program.name("wot").description("wot-ui AI toolkit CLI").version(version);
+	registerListCommand(program);
+	registerInfoCommand(program);
+	registerDocCommand(program);
+	registerDemoCommand(program);
+	registerTokenCommand(program);
+	registerChangelogCommand(program);
+	registerDoctorCommand(program);
+	registerUsageCommand(program);
+	registerLintCommand(program);
+	registerMcpCommand(program);
+	return program;
+}
+
+//#endregion
+//#region src/index.ts
+await createCliProgram().parseAsync(process.argv);
+
+//#endregion
+export {  };

package/dist/scanner-_isnOGJK.mjs

@@ -0,0 +1,203 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { gunzipSync } from "node:zlib";
+import { parse } from "@vue/compiler-sfc";
+
+//#region package.json
+var version = "0.0.1-beta.10";
+
+//#endregion
+//#region src/data/loader.ts
+const currentDir = dirname(fileURLToPath(import.meta.url));
+function resolveDataDir() {
+	const candidates = [
+		join(currentDir, "..", "data"),
+		join(currentDir, "..", "..", "data"),
+		join(currentDir, "data")
+	];
+	for (const candidate of candidates) if (existsSync(join(candidate, "versions.json")) || existsSync(join(candidate, "versions.json.gz"))) return candidate;
+	throw new Error("Unable to locate bundled data directory");
+}
+const dataDir = resolveDataDir();
+function readJsonFile(baseName) {
+	const jsonPath = join(dataDir, `${baseName}.json`);
+	if (existsSync(jsonPath)) return JSON.parse(readFileSync(jsonPath, "utf8"));
+	const gzipPath = join(dataDir, `${baseName}.json.gz`);
+	if (existsSync(gzipPath)) {
+		const compressed = readFileSync(gzipPath);
+		return JSON.parse(gunzipSync(compressed).toString("utf8"));
+	}
+	throw new Error(`Data file not found for ${baseName}`);
+}
+function loadVersionsFile() {
+	return readJsonFile("versions");
+}
+function loadMetadataFile(versionKey) {
+	return readJsonFile(versionKey);
+}
+
+//#endregion
+//#region src/data/version.ts
+const VERSION_KEY = "v2";
+function resolveVersion(requested) {
+	const versions = loadVersionsFile();
+	if (!requested) return VERSION_KEY;
+	const normalized = requested.trim();
+	if (versions.aliases[normalized]) return VERSION_KEY;
+	if (versions.supported.includes(normalized)) return VERSION_KEY;
+	if (normalized === VERSION_KEY) return VERSION_KEY;
+	throw new Error(`Unsupported wot-ui version: ${requested}`);
+}
+
+//#endregion
+//#region src/data/metadata.ts
+function loadResolvedMetadata(version$1) {
+	return loadMetadataFile(resolveVersion(version$1));
+}
+function listComponents(version$1) {
+	return loadResolvedMetadata(version$1).components;
+}
+function findComponent(name, version$1) {
+	const normalized = name.trim().toLowerCase();
+	return listComponents(version$1).find((component) => component.name.toLowerCase() === normalized || component.tag.toLowerCase() === normalized);
+}
+
+//#endregion
+//#region src/utils/files.ts
+const DEFAULT_IGNORES = new Set([
+	".git",
+	".idea",
+	".output",
+	".turbo",
+	".vscode",
+	"dist",
+	"build",
+	"coverage",
+	"node_modules"
+]);
+function walkFiles(rootDir, extensions) {
+	const results = [];
+	function visit(dir) {
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			if (DEFAULT_IGNORES.has(entry.name)) continue;
+			const fullPath = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				visit(fullPath);
+				continue;
+			}
+			if (extensions.some((extension) => entry.name.endsWith(extension))) results.push(fullPath);
+		}
+	}
+	visit(rootDir);
+	return results;
+}
+function safeRelative(rootDir, filePath) {
+	return relative(rootDir, filePath) || ".";
+}
+
+//#endregion
+//#region src/utils/scanner.ts
+const IMPORT_RE = /from\s+['"]([^'"]*wot[^'"]*)['"]/g;
+const TAG_RE = /<\s*(wd-[a-z0-9-]+)/gi;
+const BUTTON_RE = /<wd-button\b([^>]*)>([\s\S]*?)<\/wd-button>|<wd-button\b([^>]*)\/>/gi;
+function getLineNumber(source, index) {
+	return source.slice(0, index).split("\n").length;
+}
+function collectTemplateTags(content) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const match of content.matchAll(TAG_RE)) {
+		const tag = match[1]?.toLowerCase();
+		if (!tag) continue;
+		counts.set(tag, (counts.get(tag) ?? 0) + 1);
+	}
+	return counts;
+}
+function collectImports(scriptContent) {
+	const imports = /* @__PURE__ */ new Set();
+	for (const match of scriptContent.matchAll(IMPORT_RE)) if (match[1]) imports.add(match[1]);
+	return [...imports];
+}
+function analyzeUsage(targetDir, version$1) {
+	const dir = resolve(targetDir);
+	const files = walkFiles(dir, [".vue"]);
+	const knownByTag = new Map(listComponents(version$1).map((component) => [component.tag.toLowerCase(), component]));
+	const usageMap = /* @__PURE__ */ new Map();
+	const imports = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		const parsed = parse(readFileSync(file, "utf8"), { filename: file });
+		const template = parsed.descriptor.template?.content ?? "";
+		const script = [parsed.descriptor.script?.content ?? "", parsed.descriptor.scriptSetup?.content ?? ""].filter(Boolean).join("\n");
+		for (const item of collectImports(script)) imports.add(item);
+		for (const [tag, count] of collectTemplateTags(template)) {
+			const known = knownByTag.get(tag);
+			const key = known?.name ?? tag;
+			const existing = usageMap.get(key);
+			if (existing) {
+				existing.count += count;
+				if (!existing.files.includes(safeRelative(dir, file))) existing.files.push(safeRelative(dir, file));
+				continue;
+			}
+			usageMap.set(key, {
+				name: known?.name ?? tag,
+				tag,
+				count,
+				files: [safeRelative(dir, file)]
+			});
+		}
+	}
+	return {
+		scannedFiles: files.length,
+		components: [...usageMap.values()].sort((left, right) => right.count - left.count || left.name.localeCompare(right.name)),
+		imports: [...imports].sort()
+	};
+}
+function lintProject(targetDir, version$1) {
+	const dir = resolve(targetDir);
+	const files = walkFiles(dir, [".vue"]);
+	const issues = [];
+	for (const file of files) {
+		const template = parse(readFileSync(file, "utf8"), { filename: file }).descriptor.template?.content ?? "";
+		for (const match of template.matchAll(TAG_RE)) {
+			const tag = match[1]?.toLowerCase();
+			if (!tag) continue;
+			if (!findComponent(tag, version$1)) issues.push({
+				file: safeRelative(dir, file),
+				line: getLineNumber(template, match.index ?? 0),
+				rule: "unknown-component",
+				severity: "warning",
+				message: `Unknown wot-ui component tag: ${tag}`
+			});
+		}
+		for (const match of template.matchAll(BUTTON_RE)) {
+			const attrs = (match[1] ?? match[3] ?? "").trim();
+			const body = (match[2] ?? "").replace(/<[^>]+>/g, "").trim();
+			if (!/\bicon\s*=/.test(attrs) && !body) issues.push({
+				file: safeRelative(dir, file),
+				line: getLineNumber(template, match.index ?? 0),
+				rule: "button-content",
+				severity: "warning",
+				message: "wd-button should include visible text content or an icon attribute."
+			});
+			const component = findComponent("wd-button", version$1);
+			for (const prop of component?.props ?? []) {
+				if (!prop.deprecated) continue;
+				if (!(/* @__PURE__ */ new RegExp(`\\b${prop.name}\\b`)).test(attrs)) continue;
+				issues.push({
+					file: safeRelative(dir, file),
+					line: getLineNumber(template, match.index ?? 0),
+					rule: "deprecated-prop",
+					severity: "warning",
+					message: prop.replacement ? `Deprecated prop ${prop.name} detected on wd-button. Use ${prop.replacement} instead.` : `Deprecated prop ${prop.name} detected on wd-button.`
+				});
+			}
+		}
+	}
+	return {
+		scannedFiles: files.length,
+		issues
+	};
+}
+
+//#endregion
+export { resolveVersion as a, listComponents as i, lintProject as n, loadMetadataFile as o, findComponent as r, version as s, analyzeUsage as t };