ply-ui-cli 1.1.118

package/dist/commands/update.js

@@ -0,0 +1,378 @@
+"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/update.ts
+var update_exports = {};
+__export(update_exports, {
+  update: () => update
+});
+module.exports = __toCommonJS(update_exports);
+var import_fs5 = __toESM(require("fs"));
+var import_path6 = __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 import_crypto = __toESM(require("crypto"));
+var LOCKFILE_NAME = "base-ui-lock.json";
+var LOCKFILE_VERSION = 1;
+function hashContent(content) {
+  return import_crypto.default.createHash("sha256").update(content, "utf8").digest("hex");
+}
+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: {} };
+}
+function writeLockFile(lock) {
+  import_fs2.default.writeFileSync(lockfilePath(), JSON.stringify(lock, null, 2) + "\n", "utf8");
+}
+
+// src/path-safety.ts
+var import_path3 = __toESM(require("path"));
+function isSafeFileName(name) {
+  if (import_path3.default.isAbsolute(name) || /^[a-zA-Z]:[\\/]/.test(name)) return false;
+  const segments = name.split(/[\\/]/);
+  return segments.every((s) => s !== "" && s !== "..");
+}
+
+// src/commands/update.ts
+var import_registry = require("../registry");
+var import_sync = require("../sync");
+
+// src/snapshot.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var SNAPSHOT_ROOT = ".base-ui/snapshots";
+function snapshotPath(component, file) {
+  return import_path4.default.resolve(process.cwd(), SNAPSHOT_ROOT, component, file);
+}
+function writeSnapshot(component, file, content) {
+  if (!isSafeFileName(file) || !isSafeFileName(component)) return;
+  const dest = snapshotPath(component, file);
+  import_fs3.default.mkdirSync(import_path4.default.dirname(dest), { recursive: true });
+  import_fs3.default.writeFileSync(dest, content, "utf8");
+}
+
+// src/merge.ts
+var import_fs4 = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path5 = __toESM(require("path"));
+var import_child_process = require("child_process");
+function mergeThreeWay(args) {
+  const dir = import_fs4.default.mkdtempSync(import_path5.default.join(import_os.default.tmpdir(), "base-ui-merge-"));
+  const ancestorPath = import_path5.default.join(dir, "ancestor");
+  const localPath = import_path5.default.join(dir, "local");
+  const upstreamPath = import_path5.default.join(dir, "upstream");
+  try {
+    import_fs4.default.writeFileSync(ancestorPath, args.ancestor, "utf8");
+    import_fs4.default.writeFileSync(localPath, args.local, "utf8");
+    import_fs4.default.writeFileSync(upstreamPath, args.upstream, "utf8");
+    const result = (0, import_child_process.spawnSync)(
+      "git",
+      ["merge-file", "-p", "--diff3", localPath, ancestorPath, upstreamPath],
+      { encoding: "utf8" }
+    );
+    if (result.error) {
+      return {
+        clean: false,
+        text: conflictMarkers(args),
+        error: result.error.message
+      };
+    }
+    const text = result.stdout ?? "";
+    return { clean: result.status === 0, text };
+  } finally {
+    import_fs4.default.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function conflictMarkers(args) {
+  return `<<<<<<< local
+${args.local}` + (args.local.endsWith("\n") ? "" : "\n") + `||||||| ancestor
+${args.ancestor}` + (args.ancestor.endsWith("\n") ? "" : "\n") + `=======
+${args.upstream}` + (args.upstream.endsWith("\n") ? "" : "\n") + `>>>>>>> upstream
+`;
+}
+
+// src/commands/update.ts
+async function resolveConflict(name, file) {
+  while (true) {
+    const res = await (0, import_vendor.prompts)({
+      type: "select",
+      name: "choice",
+      message: `${name}/${file.path} was edited both locally and upstream. What do you want to do?`,
+      choices: [
+        { title: "Merge (3-way, installed snapshot as ancestor)", value: "merge" },
+        { title: "Keep my version (skip)", value: "keep" },
+        { title: "Take the upstream version (overwrite my edits)", value: "upstream" },
+        { title: `Save upstream as ${file.path}.upstream (merge by hand, keep my file as-is)`, value: "save-aside" },
+        { title: "View diff", value: "view" }
+      ]
+    });
+    if (!res.choice || res.choice === "keep") return "keep";
+    if (res.choice === "view") {
+      console.log((0, import_sync.renderDiff)(file.localContent, file.upstreamContent));
+      continue;
+    }
+    return res.choice;
+  }
+}
+async function update(components, options = {}) {
+  const config = readConfig();
+  if (!config) {
+    process.exitCode = 1;
+    return;
+  }
+  const componentsRoot = import_path6.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 diffs = [];
+  for (const name of targets) {
+    diffs.push(await (0, import_sync.computeComponentDiff)(name, componentsRoot, lock, index));
+  }
+  spinner.stop();
+  let updated = 0;
+  let added = 0;
+  let keptLocal = 0;
+  let overwrittenLocal = 0;
+  let conflictsToUpstream = 0;
+  let conflictsSavedAside = 0;
+  let conflictsSkipped = 0;
+  let conflictsMerged = 0;
+  let conflictsMergeDirty = 0;
+  const errored = [];
+  let lockChanged = false;
+  for (const result of diffs) {
+    if (result.error) {
+      errored.push(result.name);
+      console.log(`\u2716 ${result.name}: ${result.error}`);
+      continue;
+    }
+    if (!(0, import_sync.hasChanges)(result)) continue;
+    for (const file of result.files) {
+      const localPath = import_path6.default.join(componentsRoot, result.name, file.path);
+      if (file.status === "unchanged") {
+        if (file.localContent !== void 0 && !(file.path in lock.components[result.name].files)) {
+          lock.components[result.name].files[file.path] = hashContent(file.localContent);
+          lockChanged = true;
+        }
+        continue;
+      }
+      if (file.status === "locally-modified") {
+        if (options.overwriteLocal) {
+          if (!isSafeFileName(file.path)) {
+            console.warn(`\u26A0 Skipping unsafe file path from registry: ${result.name}/${file.path}`);
+            continue;
+          }
+          import_fs5.default.mkdirSync(import_path6.default.dirname(localPath), { recursive: true });
+          import_fs5.default.writeFileSync(localPath, file.upstreamContent ?? "", "utf8");
+          lock.components[result.name].files[file.path] = hashContent(file.upstreamContent ?? "");
+          writeSnapshot(result.name, file.path, file.upstreamContent ?? "");
+          lockChanged = true;
+          overwrittenLocal++;
+          console.log(`  \u2193 ${result.name}/${file.path}  (reverted local edits; upstream unchanged)`);
+        } else {
+          keptLocal++;
+        }
+        continue;
+      }
+      if (file.status === "removed-upstream" || file.status === "missing-locally") {
+        continue;
+      }
+      if (!isSafeFileName(file.path)) {
+        console.warn(`\u26A0 Skipping unsafe file path from registry: ${result.name}/${file.path}`);
+        continue;
+      }
+      if (file.status === "upstream-changed" || file.status === "new-upstream") {
+        import_fs5.default.mkdirSync(import_path6.default.dirname(localPath), { recursive: true });
+        import_fs5.default.writeFileSync(localPath, file.upstreamContent ?? "", "utf8");
+        lock.components[result.name].files[file.path] = hashContent(file.upstreamContent ?? "");
+        writeSnapshot(result.name, file.path, file.upstreamContent ?? "");
+        lockChanged = true;
+        if (file.status === "new-upstream") added++;
+        else updated++;
+        console.log(`  ${file.status === "new-upstream" ? "+" : "\u2191"} ${result.name}/${file.path}`);
+        continue;
+      }
+      if (file.status === "conflict") {
+        let choice;
+        if (options.force) {
+          choice = "upstream";
+        } else if (options.merge) {
+          choice = "merge";
+        } else if (options.yes) {
+          choice = "keep";
+        } else {
+          choice = await resolveConflict(result.name, file);
+        }
+        if (choice === "merge") {
+          const ancestor = file.ancestorContent;
+          if (ancestor === void 0) {
+            conflictsSkipped++;
+            console.log(
+              `  = ${result.name}/${file.path}  (no install snapshot \u2014 cannot 3-way merge; re-add the component to start tracking ancestors)`
+            );
+          } else {
+            const merged = mergeThreeWay({
+              ancestor,
+              local: file.localContent ?? "",
+              upstream: file.upstreamContent ?? ""
+            });
+            import_fs5.default.writeFileSync(localPath, merged.text, "utf8");
+            lock.components[result.name].files[file.path] = hashContent(merged.text);
+            writeSnapshot(result.name, file.path, merged.text);
+            lockChanged = true;
+            if (merged.clean) {
+              conflictsMerged++;
+              console.log(`  \u22C8 ${result.name}/${file.path}  (3-way merge, clean)`);
+            } else {
+              conflictsMergeDirty++;
+              console.log(
+                `  \u26A0 ${result.name}/${file.path}  (3-way merge left conflict markers \u2014 edit the file)`
+              );
+            }
+          }
+        } else if (choice === "upstream") {
+          import_fs5.default.writeFileSync(localPath, file.upstreamContent ?? "", "utf8");
+          lock.components[result.name].files[file.path] = hashContent(file.upstreamContent ?? "");
+          writeSnapshot(result.name, file.path, file.upstreamContent ?? "");
+          lockChanged = true;
+          conflictsToUpstream++;
+          console.log(`  \u2191 ${result.name}/${file.path}  (took upstream, your edits were overwritten)`);
+        } else if (choice === "save-aside") {
+          import_fs5.default.writeFileSync(`${localPath}.upstream`, file.upstreamContent ?? "", "utf8");
+          conflictsSavedAside++;
+          console.log(`  \u21C4 ${result.name}/${file.path}.upstream  (merge by hand \u2014 your file was left untouched)`);
+        } else {
+          conflictsSkipped++;
+          console.log(`  = ${result.name}/${file.path}  (kept your version)`);
+        }
+      }
+    }
+  }
+  if (lockChanged) {
+    writeLockFile(lock);
+  }
+  console.log("");
+  if (updated) console.log(`\u2714 ${updated} file${updated === 1 ? "" : "s"} updated from upstream.`);
+  if (added) console.log(`\u2714 ${added} new file${added === 1 ? "" : "s"} added.`);
+  if (overwrittenLocal) {
+    console.log(
+      `\u2714 ${overwrittenLocal} local edit${overwrittenLocal === 1 ? "" : "s"} overwritten (--overwrite-local).`
+    );
+  }
+  if (keptLocal) {
+    console.log(
+      `\u2014 ${keptLocal} local edit${keptLocal === 1 ? "" : "s"} kept (upstream unchanged). Re-run with --overwrite-local to discard them.`
+    );
+  }
+  if (conflictsMerged) console.log(`\u22C8 ${conflictsMerged} conflict${conflictsMerged === 1 ? "" : "s"} resolved with a 3-way merge.`);
+  if (conflictsMergeDirty) {
+    console.log(
+      `\u26A0 ${conflictsMergeDirty} conflict${conflictsMergeDirty === 1 ? "" : "s"} merged with leftover markers \u2014 edit those files.`
+    );
+    process.exitCode = 1;
+  }
+  if (conflictsToUpstream) console.log(`\u2191 ${conflictsToUpstream} conflict${conflictsToUpstream === 1 ? "" : "s"} resolved by taking upstream.`);
+  if (conflictsSavedAside) console.log(`\u21C4 ${conflictsSavedAside} conflict${conflictsSavedAside === 1 ? "" : "s"} saved as .upstream for manual merge.`);
+  if (conflictsSkipped) console.log(`= ${conflictsSkipped} conflict${conflictsSkipped === 1 ? "" : "s"} skipped (kept local). Re-run without --yes, or with --force, to resolve.`);
+  if (!updated && !added && !overwrittenLocal && !conflictsToUpstream && !conflictsSavedAside && !conflictsSkipped && !conflictsMerged && !conflictsMergeDirty) {
+    console.log("Everything is up to date.");
+  }
+  if (errored.length) {
+    process.exitCode = 1;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  update
+});

package/dist/index.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// 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/index.ts
+function printHelp() {
+  console.log(`Usage: ${CLI_BIN} <command> [options]
+
+Commands:
+  init                 Initialize your project (base-ui.json, styles, icons, Cursor rules, snippets)
+  add [components...]  Add components; omit names to pick from the catalog
+  list                 List all available components (free and pro)
+  diff [components...] Show upstream changes for installed components since you added them
+  update [components...]  Pull in upstream changes, preserving local edits
+  changelog <name>     Print product changelog entries for one component (or cli / mcp)
+  doctor               Check that your project is set up correctly for Ply
+
+Options:
+  -y, --yes            Skip prompts
+  -o, --overwrite      Overwrite components that already exist (add)
+  -f, --force          On conflict, take the upstream version (update)
+      --overwrite-local  On update, also revert files you edited that upstream did not change
+      --merge            On conflict, 3-way merge using the installed snapshot as ancestor
+  -V, --version        Print version
+  -h, --help           Show help
+
+https://ply-ui.com
+Issues: https://github.com/ply-ui-ng/ply/issues
+`);
+}
+function parseArgs(argv) {
+  const flags = {
+    yes: false,
+    overwrite: false,
+    force: false,
+    overwriteLocal: false,
+    merge: false,
+    help: false,
+    version: false
+  };
+  const positionals = [];
+  for (const arg of argv) {
+    switch (arg) {
+      case "-y":
+      case "--yes":
+        flags.yes = true;
+        break;
+      case "-o":
+      case "--overwrite":
+        flags.overwrite = true;
+        break;
+      case "-f":
+      case "--force":
+        flags.force = true;
+        break;
+      case "--overwrite-local":
+        flags.overwriteLocal = true;
+        break;
+      case "--merge":
+        flags.merge = true;
+        break;
+      case "-h":
+      case "--help":
+        flags.help = true;
+        break;
+      case "-V":
+      case "--version":
+        flags.version = true;
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          console.error(`Unknown option: ${arg}`);
+          printHelp();
+          process.exit(1);
+        }
+        positionals.push(arg);
+    }
+  }
+  return { command: positionals[0], positionals: positionals.slice(1), flags };
+}
+async function main() {
+  const { command, positionals, flags } = parseArgs(process.argv.slice(2));
+  if (flags.version && !command) {
+    console.log("1.1.118");
+    return;
+  }
+  if (flags.help || !command) {
+    printHelp();
+    return;
+  }
+  switch (command) {
+    case "init": {
+      const { init } = await import("./commands/init.js");
+      await init({ yes: flags.yes });
+      return;
+    }
+    case "add": {
+      const { add } = await import("./commands/add.js");
+      await add(positionals, { yes: flags.yes, overwrite: flags.overwrite });
+      return;
+    }
+    case "list": {
+      const { list } = await import("./commands/list.js");
+      await list();
+      return;
+    }
+    case "diff": {
+      const { diff } = await import("./commands/diff.js");
+      await diff(positionals);
+      return;
+    }
+    case "update": {
+      const { update } = await import("./commands/update.js");
+      await update(positionals, {
+        yes: flags.yes,
+        force: flags.force,
+        overwriteLocal: flags.overwriteLocal,
+        merge: flags.merge
+      });
+      return;
+    }
+    case "changelog": {
+      const { changelog } = await import("./commands/changelog.js");
+      await changelog(positionals);
+      return;
+    }
+    case "doctor": {
+      const { doctor } = await import("./commands/doctor.js");
+      await doctor();
+      return;
+    }
+    case "--version":
+    case "-V":
+      console.log("1.1.118");
+      return;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exitCode = 1;
+  }
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exitCode = 1;
+});