ply-ui-cli 1.1.118

package/dist/commands/diff.js

@@ -0,0 +1,174 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/diff.ts
+var diff_exports = {};
+__export(diff_exports, {
+  diff: () => diff
+});
+module.exports = __toCommonJS(diff_exports);
+var import_path3 = __toESM(require("path"));
+var import_vendor = require("../vendor");
+
+// src/config.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+
+// src/brand.ts
+var CLI_BIN = "ply-ui-cli";
+var CLI_NPX = `npx ${CLI_BIN}`;
+var MCP_PACKAGE = "ply-ui-mcp";
+var MCP_NPX = `npx -y ${MCP_PACKAGE}`;
+
+// src/config.ts
+function readConfig() {
+  const configPath = import_path.default.resolve(process.cwd(), "base-ui.json");
+  if (!import_fs.default.existsSync(configPath)) {
+    console.error(`base-ui.json not found. Please run "${CLI_NPX} init" first.`);
+    return null;
+  }
+  try {
+    const config = JSON.parse(import_fs.default.readFileSync(configPath, "utf8"));
+    if (!config || !config.aliases || !config.aliases.components) {
+      throw new Error("Missing aliases.components in base-ui.json");
+    }
+    return config;
+  } catch (err) {
+    console.error(`Error reading base-ui.json: ${err.message}`);
+    return null;
+  }
+}
+
+// src/lockfile.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var LOCKFILE_NAME = "base-ui-lock.json";
+var LOCKFILE_VERSION = 1;
+function lockfilePath() {
+  return import_path2.default.resolve(process.cwd(), LOCKFILE_NAME);
+}
+function readLockFile() {
+  const p = lockfilePath();
+  if (!import_fs2.default.existsSync(p)) {
+    return { version: LOCKFILE_VERSION, components: {} };
+  }
+  try {
+    const parsed = JSON.parse(import_fs2.default.readFileSync(p, "utf8"));
+    if (parsed && typeof parsed === "object" && parsed.components) {
+      return { version: parsed.version ?? LOCKFILE_VERSION, components: parsed.components };
+    }
+  } catch {
+  }
+  return { version: LOCKFILE_VERSION, components: {} };
+}
+
+// src/commands/diff.ts
+var import_registry = require("../registry");
+var import_sync = require("../sync");
+async function diff(components) {
+  const config = readConfig();
+  if (!config) {
+    process.exitCode = 1;
+    return;
+  }
+  const componentsRoot = import_path3.default.resolve(process.cwd(), config.aliases.components);
+  const lock = readLockFile();
+  const tracked = Object.keys(lock.components).sort();
+  if (!tracked.length) {
+    console.log('No components are tracked yet. Components installed with "add" (after this version of the CLI) are tracked automatically.');
+    return;
+  }
+  const targets = components.length ? components : tracked;
+  const unknown = targets.filter((n) => !tracked.includes(n));
+  if (unknown.length) {
+    console.error(`\u2716 Not tracked: ${unknown.join(", ")}`);
+    console.error(`  Tracked components: ${tracked.join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+  const spinner = (0, import_vendor.ora)(`Checking ${targets.length} component${targets.length === 1 ? "" : "s"} against upstream...`).start();
+  let index;
+  try {
+    index = await (0, import_registry.fetchIndex)();
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exitCode = 1;
+    return;
+  }
+  const results = [];
+  for (const name of targets) {
+    results.push(await (0, import_sync.computeComponentDiff)(name, componentsRoot, lock, index));
+  }
+  spinner.stop();
+  let anyChanges = false;
+  let anyConflicts = false;
+  const upToDate = [];
+  const errored = [];
+  for (const result of results) {
+    if (result.error) {
+      errored.push(result.name);
+      console.log(`
+\u2716 ${result.name}: ${result.error}`);
+      continue;
+    }
+    if (!(0, import_sync.hasChanges)(result)) {
+      upToDate.push(result.name);
+      continue;
+    }
+    anyChanges = true;
+    if ((0, import_sync.hasConflicts)(result)) anyConflicts = true;
+    console.log(`
+${result.name}${result.tier === "pro" ? "  (pro)" : ""}`);
+    for (const file of result.files) {
+      if (file.status === "unchanged") continue;
+      console.log(`  ${file.path}  \u2014  ${(0, import_sync.statusLabel)(file.status)}`);
+      if (file.status === "upstream-changed" || file.status === "conflict" || file.status === "new-upstream") {
+        console.log((0, import_sync.renderDiff)(file.localContent, file.upstreamContent).split("\n").map((l) => `    ${l}`).join("\n"));
+      }
+    }
+  }
+  if (upToDate.length) {
+    console.log(`
+\u2714 Up to date: ${upToDate.join(", ")}`);
+  }
+  if (anyChanges) {
+    console.log(`
+Run "${CLI_NPX} update${components.length ? " " + components.join(" ") : ""}" to apply upstream changes.`);
+    if (anyConflicts) {
+      console.log("Some files were edited both locally and upstream \u2014 update will ask how to resolve each one.");
+    }
+  }
+  if (errored.length) {
+    process.exitCode = 1;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diff
+});

package/dist/commands/doctor.js

@@ -0,0 +1,332 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  doctor: () => doctor
+});
+module.exports = __toCommonJS(doctor_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_vendor = require("../vendor");
+var import_registry = require("../registry");
+
+// src/brand.ts
+var CLI_BIN = "ply-ui-cli";
+var CLI_NPX = `npx ${CLI_BIN}`;
+var MCP_PACKAGE = "ply-ui-mcp";
+var MCP_NPX = `npx -y ${MCP_PACKAGE}`;
+
+// src/commands/doctor.ts
+var ICON_SPRITES = ["icons.svg", "icons-filled.svg"];
+function pickAngularProject(angularJson) {
+  const projects = angularJson?.projects || {};
+  const names = Object.keys(projects);
+  if (!names.length) return null;
+  const appName = names.find((n) => projects[n].projectType === "application" && projects[n].architect?.build) || names.find((n) => projects[n].architect?.build) || names[0];
+  return { name: appName, project: projects[appName] };
+}
+function resolveAssetsDir(cwd, angularJson) {
+  const picked = pickAngularProject(angularJson);
+  const buildOptions = picked?.project?.architect?.build?.options;
+  if (!buildOptions) return import_path.default.resolve(cwd, "src/assets");
+  const assets = buildOptions.assets || [];
+  const hasSrcAssets = assets.some(
+    (a) => a === "src/assets" || typeof a === "object" && a?.input === "src/assets"
+  );
+  const publicEntry = assets.find(
+    (a) => a === "public" || typeof a === "object" && a?.input === "public"
+  );
+  if (hasSrcAssets) return import_path.default.resolve(cwd, "src/assets");
+  if (publicEntry) return import_path.default.resolve(cwd, "public/assets");
+  return import_path.default.resolve(cwd, "src/assets");
+}
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(import_fs.default.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readTextSafe(filePath) {
+  try {
+    return import_fs.default.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function sourceCovers(source, tailwindDir, targetDir) {
+  const raw = source.replace(/[*?[\]{}].*$/, "");
+  const resolved = import_path.default.resolve(tailwindDir, raw);
+  const resolvedDir = raw.endsWith("/") || raw.endsWith("\\") || import_path.default.extname(raw) === "" ? resolved : import_path.default.dirname(resolved);
+  return targetDir === resolvedDir || targetDir.startsWith(resolvedDir + import_path.default.sep);
+}
+async function doctor(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const relative = (filePath) => import_path.default.relative(cwd, filePath) || ".";
+  const spinner = (0, import_vendor.ora)("Checking Ply setup...").start();
+  const checks = [];
+  const configPath = import_path.default.resolve(cwd, "base-ui.json");
+  let config = null;
+  if (!import_fs.default.existsSync(configPath)) {
+    checks.push({
+      name: "base-ui.json",
+      status: "error",
+      message: `Not found. Run "${CLI_NPX} init" first.`
+    });
+  } else {
+    config = readJsonSafe(configPath);
+    if (!config) {
+      checks.push({
+        name: "base-ui.json",
+        status: "error",
+        message: `${relative(configPath)} exists but is not valid JSON.`
+      });
+    } else if (!config.aliases?.components) {
+      checks.push({
+        name: "base-ui.json",
+        status: "error",
+        message: `${relative(configPath)} is missing aliases.components.`
+      });
+    } else {
+      checks.push({
+        name: "base-ui.json",
+        status: "ok",
+        message: `${relative(configPath)} exists and aliases.components is set.`
+      });
+    }
+  }
+  const angularJsonPath = import_path.default.resolve(cwd, "angular.json");
+  let angularJson = null;
+  if (!import_fs.default.existsSync(angularJsonPath)) {
+    checks.push({
+      name: "Angular workspace",
+      status: "warn",
+      message: "No angular.json found. Is this an Angular workspace?"
+    });
+  } else {
+    angularJson = readJsonSafe(angularJsonPath);
+    const picked = angularJson ? pickAngularProject(angularJson) : null;
+    if (!picked) {
+      checks.push({
+        name: "Angular workspace",
+        status: "error",
+        message: `${relative(angularJsonPath)} has no buildable project.`
+      });
+    } else {
+      checks.push({
+        name: "Angular workspace",
+        status: "ok",
+        message: `Buildable project "${picked.name}" found.`
+      });
+    }
+  }
+  const packageJsonPath = import_path.default.resolve(cwd, "package.json");
+  const packageJson = readJsonSafe(packageJsonPath);
+  if (!packageJson) {
+    checks.push({
+      name: "package.json",
+      status: "error",
+      message: `${relative(packageJsonPath)} not found or invalid.`
+    });
+  } else {
+    const deps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    if (!deps["@angular/cdk"]) {
+      checks.push({
+        name: "Angular CDK",
+        status: "error",
+        message: "@angular/cdk is not installed. Most components need it for overlays."
+      });
+    } else {
+      checks.push({
+        name: "Angular CDK",
+        status: "ok",
+        message: `@angular/cdk ${deps["@angular/cdk"]} installed.`
+      });
+    }
+  }
+  const tailwindPath = import_path.default.resolve(cwd, config?.tailwind?.config || "src/tailwind.css");
+  const tailwindContent = readTextSafe(tailwindPath);
+  if (!tailwindContent) {
+    checks.push({
+      name: "Tailwind entry",
+      status: "error",
+      message: `${relative(tailwindPath)} not found. Set tailwind.config in base-ui.json or create it.`
+    });
+  } else {
+    checks.push({
+      name: "Tailwind entry",
+      status: "ok",
+      message: `${relative(tailwindPath)} exists.`
+    });
+    if (!tailwindContent.includes('@import "tailwindcss"') && !tailwindContent.includes("@import 'tailwindcss'")) {
+      checks.push({
+        name: "Tailwind v4",
+        status: "warn",
+        message: `${relative(tailwindPath)} does not import "tailwindcss". Tailwind v4 is required.`
+      });
+    } else {
+      checks.push({
+        name: "Tailwind v4",
+        status: "ok",
+        message: `${relative(tailwindPath)} imports Tailwind v4.`
+      });
+    }
+    const sourceMatches = tailwindContent.match(/@source\s+["']([^"']+)["']/g) || [];
+    if (!sourceMatches.length) {
+      checks.push({
+        name: "@source paths",
+        status: "warn",
+        message: `No @source directives found in ${relative(tailwindPath)}. Components may not be scanned for classes.`
+      });
+    } else {
+      const componentsAlias2 = config?.aliases?.components || "src/app/components";
+      const componentsDir = import_path.default.resolve(cwd, componentsAlias2);
+      const tailwindDir = import_path.default.dirname(tailwindPath);
+      const hasComponentSource = sourceMatches.some((m) => {
+        const raw = m.match(/@source\s+["']([^"']+)["']/)?.[1];
+        if (!raw) return false;
+        return sourceCovers(raw, tailwindDir, componentsDir);
+      });
+      if (!hasComponentSource) {
+        checks.push({
+          name: "@source paths",
+          status: "warn",
+          message: `@source directives exist but none point to ${componentsAlias2}. Component classes may be missing.`
+        });
+      } else {
+        checks.push({
+          name: "@source paths",
+          status: "ok",
+          message: `@source covers ${componentsAlias2}.`
+        });
+      }
+    }
+  }
+  const stylesPath = import_path.default.resolve(cwd, config?.tailwind?.css || "src/styles.scss");
+  const stylesContent = readTextSafe(stylesPath);
+  if (!stylesContent) {
+    checks.push({
+      name: "Global styles",
+      status: "error",
+      message: `${relative(stylesPath)} not found. Set tailwind.css in base-ui.json or create it.`
+    });
+  } else {
+    const baseCssImport = "@import './base-ui.css'";
+    if (!stylesContent.includes(baseCssImport)) {
+      checks.push({
+        name: "Global styles",
+        status: "warn",
+        message: `${relative(stylesPath)} does not import ${baseCssImport}. Ply global styles will be missing.`
+      });
+    } else {
+      checks.push({
+        name: "Global styles",
+        status: "ok",
+        message: `${relative(stylesPath)} imports base-ui.css.`
+      });
+    }
+    const baseCssPath = import_path.default.join(import_path.default.dirname(stylesPath), "base-ui.css");
+    if (!import_fs.default.existsSync(baseCssPath)) {
+      checks.push({
+        name: "base-ui.css",
+        status: "error",
+        message: `${relative(baseCssPath)} not found. Run "${CLI_NPX} init" to create it.`
+      });
+    } else {
+      checks.push({
+        name: "base-ui.css",
+        status: "ok",
+        message: `${relative(baseCssPath)} exists.`
+      });
+    }
+  }
+  const assetsDir = angularJson ? resolveAssetsDir(cwd, angularJson) : import_path.default.resolve(cwd, "src/assets");
+  const missingSprites = ICON_SPRITES.filter((s) => !import_fs.default.existsSync(import_path.default.join(assetsDir, s)));
+  if (missingSprites.length) {
+    checks.push({
+      name: "Icon sprites",
+      status: "error",
+      message: `Missing ${missingSprites.join(", ")} in ${relative(assetsDir)}. Run "${CLI_NPX} init" to download them.`
+    });
+  } else {
+    checks.push({
+      name: "Icon sprites",
+      status: "ok",
+      message: `${ICON_SPRITES.join(", ")} found in ${relative(assetsDir)}.`
+    });
+  }
+  const componentsAlias = config?.aliases?.components;
+  if (componentsAlias) {
+    const componentsDir = import_path.default.resolve(cwd, componentsAlias);
+    if (!import_fs.default.existsSync(componentsDir)) {
+      checks.push({
+        name: "Components directory",
+        status: "warn",
+        message: `${relative(componentsDir)} does not exist yet. It will be created when you add a component.`
+      });
+    } else {
+      checks.push({
+        name: "Components directory",
+        status: "ok",
+        message: `${relative(componentsDir)} exists.`
+      });
+    }
+  }
+  spinner.succeed("Check complete.");
+  printReport(checks);
+}
+function printReport(checks) {
+  console.log("");
+  for (const check of checks) {
+    const symbol = check.status === "ok" ? "\u2714" : check.status === "warn" ? "\u26A0" : "\u2716";
+    console.log(`${symbol} ${check.name}: ${check.message}`);
+  }
+  const errors = checks.filter((c) => c.status === "error").length;
+  const warnings = checks.filter((c) => c.status === "warn").length;
+  const ok = checks.filter((c) => c.status === "ok").length;
+  console.log("");
+  if (errors === 0 && warnings === 0) {
+    console.log(`\u2714 All ${ok} checks passed. Your project is ready for Ply.`);
+  } else if (errors === 0) {
+    console.log(`\u26A0 ${ok} passed, ${warnings} warning(s). Review the warnings above.`);
+  } else {
+    console.log(`\u2716 ${ok} passed, ${warnings} warning(s), ${errors} error(s). Fix errors before adding components.`);
+    console.log(`  Need help? ${import_registry.SITE_URL}/getting-started/`);
+    process.exitCode = 1;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  doctor
+});