@dalexto/lexsys-cli 0.0.2

package/dist/index.js

@@ -0,0 +1,3333 @@
+#!/usr/bin/env node
+import prompts from 'prompts';
+import { registryManifest, getInstallLayer, registryItems, validateRegistry, registryStyles, registryVersion, validateRegistryItem, registryUtilities as registryUtilities$1 } from '@dalexto/lexsys-registry';
+import { readFile, access, mkdir, copyFile, writeFile, unlink, readdir, rm } from 'fs/promises';
+import { dirname, join, resolve, relative, basename } from 'path';
+import { createHash } from 'crypto';
+import { constants } from 'fs';
+import { fileURLToPath } from 'url';
+import { execFileSync } from 'child_process';
+
+// src/core/cli-error.ts
+var CliError = class extends Error {
+  suggestion;
+  constructor(message, suggestion) {
+    super(message);
+    this.name = "CliError";
+    this.suggestion = suggestion;
+  }
+};
+var handleCliError = (error) => {
+  if (error instanceof CliError) {
+    console.error(`
+\u2717  ${error.message}`);
+    if (error.suggestion) {
+      console.error(`   ${error.suggestion}`);
+    }
+    console.error(`   Run \`lexsys --help\` to see available commands.
+`);
+  } else if (error instanceof Error) {
+    console.error(`
+\u2717  ${error.message}
+`);
+  } else {
+    console.error(`
+\u2717  An unexpected error occurred.
+`);
+  }
+  process.exit(1);
+};
+var hashContent = (content) => {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+};
+var hashFile = async (path) => {
+  const content = await readFile(path, "utf-8");
+  return hashContent(content);
+};
+var hashesAreEqual = (firstContent, secondContent) => {
+  return hashContent(firstContent) === hashContent(secondContent);
+};
+var isNotFoundError = (error) => {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+};
+var fileExists = async (path) => {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return false;
+    }
+    throw error;
+  }
+};
+var filesAreEqual = async (sourcePath, targetPath) => {
+  const sourceHash = await hashFile(sourcePath);
+  const targetHash = await hashFile(targetPath);
+  return sourceHash === targetHash;
+};
+
+// src/core/context.ts
+var currentWorkingDirectory = process.cwd();
+var setCwd = (cwd2) => {
+  currentWorkingDirectory = cwd2;
+};
+var getCwd = () => {
+  return currentWorkingDirectory;
+};
+
+// src/config/config.ts
+var defaultPathsConfig = {
+  components: "src/components/ui",
+  utilities: "src/lib",
+  styles: "styles"
+};
+var defaultAliasesConfig = {
+  components: "@/components/ui",
+  ui: "@/components/ui",
+  utils: "@/lib/utils",
+  lib: "@/lib",
+  hooks: "@/hooks"
+};
+var defaultTailwindConfig = {
+  version: "v4",
+  css: "src/style.css"
+};
+var defaultConfig = {
+  style: "default",
+  paths: defaultPathsConfig,
+  aliases: defaultAliasesConfig,
+  tailwind: defaultTailwindConfig,
+  installed: {},
+  registryUrl: null
+};
+var getConfigPath = () => {
+  return join(getCwd(), "lexsys.config.json");
+};
+var loadConfig = async () => {
+  const configPath = getConfigPath();
+  if (!await fileExists(configPath)) {
+    return defaultConfig;
+  }
+  const content = await readFile(configPath, "utf-8");
+  const parsed = JSON.parse(content);
+  return {
+    ...defaultConfig,
+    ...parsed,
+    paths: {
+      ...defaultPathsConfig,
+      ...parsed.paths
+    },
+    aliases: {
+      ...defaultAliasesConfig,
+      ...parsed.aliases
+    },
+    tailwind: {
+      ...defaultTailwindConfig,
+      ...parsed.tailwind
+    }
+  };
+};
+var saveConfig = async (config) => {
+  const configPath = getConfigPath();
+  await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+};
+var crossLayerImportPatterns = [
+  /\.\.\/\.\.\/primitives\//g,
+  /\.\.\/\.\.\/blocks\//g,
+  /\.\.\/\.\.\/templates\//g
+];
+var rewriteCrossLayerImports = (content) => {
+  let rewritten = content;
+  for (const pattern of crossLayerImportPatterns) {
+    rewritten = rewritten.replace(pattern, "../");
+  }
+  return rewritten;
+};
+var prepareInstalledFileContent = (content, item) => {
+  const layer = getInstallLayer(item);
+  if (layer !== "block" && layer !== "template") {
+    return content;
+  }
+  return rewriteCrossLayerImports(content);
+};
+var toPosixPath = (value) => {
+  return value.replace(/\\/g, "/");
+};
+var resolveItemInstallTarget = (config, item) => {
+  return toPosixPath(join(config.paths.components, item.canonicalName));
+};
+var createTimestamp = () => {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+};
+var createBackupFile = async (path) => {
+  if (!await fileExists(path)) {
+    return null;
+  }
+  const backupPath = `${path}.${createTimestamp()}.bak`;
+  await mkdir(dirname(backupPath), { recursive: true });
+  await copyFile(path, backupPath);
+  return backupPath;
+};
+
+// src/registry/remote-files.ts
+var fetchRemoteFile = async (url) => {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch file: ${response.status}`);
+  }
+  return response.text();
+};
+
+// src/scaffold/template-validator.ts
+var validateTemplateFiles = async (item) => {
+  for (const file of item.files) {
+    const fullPath = getRegistryTemplatePath(file);
+    if (!await fileExists(fullPath)) {
+      throw new Error(`Template file missing for "${item.name}": ${file}`);
+    }
+  }
+};
+
+// src/install/results.ts
+var createInstallResourceResult = () => {
+  return {
+    created: [],
+    updated: [],
+    skipped: [],
+    conflicted: []
+  };
+};
+var mergeInstallResults = (results) => {
+  return results.reduce(
+    (merged, result) => ({
+      created: [...merged.created, ...result.created],
+      updated: [...merged.updated, ...result.updated],
+      skipped: [...merged.skipped, ...result.skipped],
+      conflicted: [...merged.conflicted, ...result.conflicted]
+    }),
+    createInstallResourceResult()
+  );
+};
+var hasInstallConflicts = (result) => {
+  return result.conflicted.length > 0;
+};
+var printResourceSummary = (label, result) => {
+  const total = result.created.length + result.updated.length + result.skipped.length + result.conflicted.length;
+  if (!total) {
+    console.log(`- ${label}: no changes`);
+    return;
+  }
+  const parts = [
+    result.created.length ? `${result.created.length} created` : void 0,
+    result.updated.length ? `${result.updated.length} updated` : void 0,
+    result.skipped.length ? `${result.skipped.length} skipped` : void 0,
+    result.conflicted.length ? `${result.conflicted.length} conflicted` : void 0
+  ].filter((part) => typeof part === "string");
+  console.log(`- ${label}: ${parts.join(", ")}`);
+};
+
+// src/install/uninstall-results.ts
+var createUninstallResourceResult = () => {
+  return {
+    removed: [],
+    skipped: [],
+    conflicted: [],
+    missing: []
+  };
+};
+var mergeUninstallResults = (results) => {
+  return results.reduce(
+    (merged, result) => ({
+      removed: [...merged.removed, ...result.removed],
+      skipped: [...merged.skipped, ...result.skipped],
+      conflicted: [...merged.conflicted, ...result.conflicted],
+      missing: [...merged.missing, ...result.missing]
+    }),
+    createUninstallResourceResult()
+  );
+};
+var hasUninstallConflicts = (result) => {
+  return result.conflicted.length > 0;
+};
+var printUninstallSummary = (label, result) => {
+  const total = result.removed.length + result.skipped.length + result.conflicted.length + result.missing.length;
+  if (!total) {
+    console.log(`- ${label}: no changes`);
+    return;
+  }
+  const parts = [
+    result.removed.length ? `${result.removed.length} removed` : void 0,
+    result.skipped.length ? `${result.skipped.length} skipped` : void 0,
+    result.missing.length ? `${result.missing.length} missing` : void 0,
+    result.conflicted.length ? `${result.conflicted.length} conflicted` : void 0
+  ].filter((part) => typeof part === "string");
+  console.log(`- ${label}: ${parts.join(", ")}`);
+};
+
+// src/install/installer.ts
+var getRegistryTemplatePath = (templatePath) => {
+  const templateUrl = import.meta.resolve(
+    `@dalexto/lexsys-registry/templates/${templatePath}`
+  );
+  return fileURLToPath(templateUrl);
+};
+var generatedStyleHeader = "/* Generated by @dalexto/lexsys-tokens. Do not edit directly. */";
+var isGeneratedLexsysStyle = (content) => {
+  return content.startsWith(generatedStyleHeader);
+};
+var ensureProjectStructure = async (config) => {
+  await mkdir(join(getCwd(), config.paths.components), { recursive: true });
+  await mkdir(join(getCwd(), config.paths.utilities), { recursive: true });
+  await mkdir(join(getCwd(), config.paths.styles), { recursive: true });
+};
+var installUtilities = async (utilities, config) => {
+  const result = createInstallResourceResult();
+  for (const utility of utilities) {
+    const sourcePath = getRegistryTemplatePath(utility.path);
+    const targetPath = join(getCwd(), config.paths.utilities, utility.target);
+    await mkdir(dirname(targetPath), { recursive: true });
+    if (await fileExists(targetPath)) {
+      const isSameFile = await filesAreEqual(sourcePath, targetPath);
+      if (isSameFile) {
+        console.log(`Skipped identical utility: ${targetPath}`);
+        result.skipped.push(targetPath);
+        continue;
+      }
+      console.log(`Conflict: utility already exists and differs: ${targetPath}`);
+      result.conflicted.push(targetPath);
+      continue;
+    }
+    await copyFile(sourcePath, targetPath);
+    console.log(`Created utility: ${targetPath}`);
+    result.created.push(targetPath);
+  }
+  return result;
+};
+var updateUtilities = async (utilities, config, force) => {
+  const result = createInstallResourceResult();
+  for (const utility of utilities) {
+    const sourcePath = getRegistryTemplatePath(utility.path);
+    const targetPath = join(getCwd(), config.paths.utilities, utility.target);
+    await mkdir(dirname(targetPath), { recursive: true });
+    if (!await fileExists(targetPath)) {
+      await copyFile(sourcePath, targetPath);
+      console.log(`Created utility: ${targetPath}`);
+      result.created.push(targetPath);
+      continue;
+    }
+    const isSameFile = await filesAreEqual(sourcePath, targetPath);
+    if (isSameFile) {
+      console.log(`Skipped identical utility: ${targetPath}`);
+      result.skipped.push(targetPath);
+      continue;
+    }
+    if (force) {
+      const backupPath = await createBackupFile(targetPath);
+      if (backupPath) {
+        console.log(`- backup created: ${backupPath}`);
+      }
+      await copyFile(sourcePath, targetPath);
+      console.log(`Updated utility: ${targetPath}`);
+      result.updated.push(targetPath);
+      continue;
+    }
+    console.log(`Conflict: utility already exists and differs: ${targetPath}`);
+    result.conflicted.push(targetPath);
+  }
+  return result;
+};
+var installStyles = async (styles, config) => {
+  const result = createInstallResourceResult();
+  const installedStyleTargets = [];
+  for (const style of styles) {
+    console.log(`Installing style ${style.name}...`);
+    for (const file of style.files) {
+      const sourcePath = getRegistryTemplatePath(file.path);
+      const targetPath = join(getCwd(), config.paths.styles, file.target);
+      await mkdir(dirname(targetPath), { recursive: true });
+      if (await fileExists(targetPath)) {
+        const isSameFile = await filesAreEqual(sourcePath, targetPath);
+        if (isSameFile) {
+          console.log(`Skipped identical style: ${targetPath}`);
+          result.skipped.push(targetPath);
+          installedStyleTargets.push(file.target);
+          continue;
+        }
+        const sourceContent = await readFile(sourcePath, "utf-8");
+        const targetContent = await readFile(targetPath, "utf-8");
+        if (isGeneratedLexsysStyle(sourceContent) && isGeneratedLexsysStyle(targetContent)) {
+          await writeFile(targetPath, sourceContent, "utf-8");
+          console.log(`Updated generated style: ${targetPath}`);
+          result.updated.push(targetPath);
+          installedStyleTargets.push(file.target);
+          continue;
+        }
+        console.log(`Conflict: style already exists and differs: ${targetPath}`);
+        result.conflicted.push(targetPath);
+        continue;
+      }
+      await copyFile(sourcePath, targetPath);
+      console.log(`Created style: ${targetPath}`);
+      result.created.push(targetPath);
+      installedStyleTargets.push(file.target);
+    }
+  }
+  if (!hasInstallConflicts(result) && installedStyleTargets.length) {
+    const entrypointResult = await installStyleEntrypointImports(
+      installedStyleTargets,
+      config
+    );
+    result.updated.push(...entrypointResult.updated);
+    result.skipped.push(...entrypointResult.skipped);
+  }
+  return result;
+};
+var toCssImportPath = (cssPath, styleTarget, config) => {
+  const importPath = relative(
+    dirname(cssPath),
+    join(config.paths.styles, styleTarget)
+  ).replaceAll("\\", "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+};
+var getStyleImportInsertionIndex = (content) => {
+  const importHeaderMatch = content.match(
+    /^(?:\s*@charset\s+["'][^"']+["'];\s*)?(?:\s*@import\s+[^;]+;\s*)*/u
+  );
+  return importHeaderMatch?.[0].length ?? 0;
+};
+var installStyleEntrypointImports = async (styleTargets, config) => {
+  const cssPath = join(getCwd(), config.tailwind.css);
+  if (!await fileExists(cssPath)) {
+    console.log(
+      `Skipped style wiring: Tailwind CSS entrypoint not found at ${cssPath}`
+    );
+    return {
+      skipped: [cssPath],
+      updated: []
+    };
+  }
+  const content = await readFile(cssPath, "utf-8");
+  const missingImports = styleTargets.map(
+    (styleTarget) => toCssImportPath(config.tailwind.css, styleTarget, config)
+  ).filter(
+    (importPath) => !content.includes(`"${importPath}"`) && !content.includes(`'${importPath}'`)
+  ).map((importPath) => `@import "${importPath}";`);
+  if (!missingImports.length) {
+    console.log(
+      `Skipped style wiring: ${cssPath} already imports Lexsys styles`
+    );
+    return {
+      skipped: [cssPath],
+      updated: []
+    };
+  }
+  const insertionIndex = getStyleImportInsertionIndex(content);
+  const before = content.slice(0, insertionIndex);
+  const after = content.slice(insertionIndex);
+  const separator = before.endsWith("\n") || before.length === 0 ? "" : "\n";
+  const updatedContent = `${before}${separator}${missingImports.join("\n")}
+${after}`;
+  await writeFile(cssPath, updatedContent, "utf-8");
+  console.log(`Updated style entrypoint: ${cssPath}`);
+  return {
+    skipped: [],
+    updated: [cssPath]
+  };
+};
+var readPreparedTemplateContent = async (item, file, remoteContent) => {
+  const rawContent = remoteContent ?? await readFile(getRegistryTemplatePath(file), "utf-8");
+  return prepareInstalledFileContent(rawContent, item);
+};
+var installItemFiles = async (item, config) => {
+  const result = createInstallResourceResult();
+  const installTarget = resolveItemInstallTarget(config, item);
+  console.log(`Installing ${item.canonicalName}...
+`);
+  await validateTemplateFiles(item);
+  for (const file of item.files) {
+    const remoteFile = item.remoteFiles?.find(
+      (registryFile) => registryFile.path === file && registryFile.remoteUrl
+    );
+    const fileName = file.split("/").at(-1);
+    if (!fileName) {
+      throw new Error(`Invalid registry file path: ${file}`);
+    }
+    const targetPath = join(getCwd(), installTarget, fileName);
+    await mkdir(dirname(targetPath), { recursive: true });
+    if (remoteFile?.remoteUrl) {
+      console.log(`Fetching remote file: ${remoteFile.remoteUrl}`);
+      const remoteContent = await fetchRemoteFile(remoteFile.remoteUrl);
+      const preparedContent2 = await readPreparedTemplateContent(
+        item,
+        file,
+        remoteContent
+      );
+      if (await fileExists(targetPath)) {
+        const targetContent = await readFile(targetPath, "utf-8");
+        if (hashesAreEqual(preparedContent2, targetContent)) {
+          console.log(`Skipped identical file: ${targetPath}`);
+          result.skipped.push(targetPath);
+          continue;
+        }
+        console.log(`Conflict: file already exists and differs: ${targetPath}`);
+        result.conflicted.push(targetPath);
+        continue;
+      }
+      await writeFile(targetPath, preparedContent2, "utf-8");
+      console.log(`Created: ${targetPath}`);
+      result.created.push(targetPath);
+      continue;
+    }
+    const preparedContent = await readPreparedTemplateContent(item, file);
+    if (await fileExists(targetPath)) {
+      const targetContent = await readFile(targetPath, "utf-8");
+      if (hashesAreEqual(preparedContent, targetContent)) {
+        console.log(`Skipped identical file: ${targetPath}`);
+        result.skipped.push(targetPath);
+        continue;
+      }
+      console.log(`Conflict: file already exists and differs: ${targetPath}`);
+      result.conflicted.push(targetPath);
+      continue;
+    }
+    await writeFile(targetPath, preparedContent, "utf-8");
+    console.log(`Created: ${targetPath}`);
+    result.created.push(targetPath);
+  }
+  console.log("\nDone.");
+  return result;
+};
+var removeFileIfMatchesTemplate = async (sourcePath, targetPath, result) => {
+  if (!await fileExists(targetPath)) {
+    console.log(`Skipped missing file: ${targetPath}`);
+    result.missing.push(targetPath);
+    return;
+  }
+  const isSameFile = await filesAreEqual(sourcePath, targetPath);
+  if (!isSameFile) {
+    console.log(`Conflict: file differs from registry template: ${targetPath}`);
+    result.conflicted.push(targetPath);
+    return;
+  }
+  await unlink(targetPath);
+  console.log(`Removed: ${targetPath}`);
+  result.removed.push(targetPath);
+};
+var removeGeneratedStyleIfMatchesTemplate = async (sourcePath, targetPath, result) => {
+  if (!await fileExists(targetPath)) {
+    console.log(`Skipped missing style: ${targetPath}`);
+    result.missing.push(targetPath);
+    return;
+  }
+  const sourceContent = await readFile(sourcePath, "utf-8");
+  const targetContent = await readFile(targetPath, "utf-8");
+  if (isGeneratedLexsysStyle(sourceContent) && isGeneratedLexsysStyle(targetContent) && sourceContent === targetContent) {
+    await unlink(targetPath);
+    console.log(`Removed generated style: ${targetPath}`);
+    result.removed.push(targetPath);
+    return;
+  }
+  const isSameFile = await filesAreEqual(sourcePath, targetPath);
+  if (isSameFile) {
+    await unlink(targetPath);
+    console.log(`Removed style: ${targetPath}`);
+    result.removed.push(targetPath);
+    return;
+  }
+  console.log(`Conflict: style differs from registry template: ${targetPath}`);
+  result.conflicted.push(targetPath);
+};
+var tryRemoveEmptyDirectory = async (directoryPath) => {
+  try {
+    const entries = await readdir(directoryPath);
+    if (entries.length === 0) {
+      await rm(directoryPath, { recursive: true });
+      console.log(`Removed empty directory: ${directoryPath}`);
+    }
+  } catch {
+    return;
+  }
+};
+var uninstallItemFiles = async (item, config) => {
+  const result = createUninstallResourceResult();
+  console.log(`Uninstalling ${item.canonicalName}...
+`);
+  await validateTemplateFiles(item);
+  const componentDirectory = join(
+    getCwd(),
+    resolveItemInstallTarget(config, item)
+  );
+  const plannedRemovals = [];
+  for (const file of item.files) {
+    const fileName = file.split("/").at(-1);
+    if (!fileName) {
+      throw new Error(`Invalid registry file path: ${file}`);
+    }
+    const targetPath = join(componentDirectory, fileName);
+    if (!await fileExists(targetPath)) {
+      console.log(`Skipped missing file: ${targetPath}`);
+      result.missing.push(targetPath);
+      continue;
+    }
+    const preparedContent = await readPreparedTemplateContent(item, file);
+    const targetContent = await readFile(targetPath, "utf-8");
+    if (!hashesAreEqual(preparedContent, targetContent)) {
+      console.log(
+        `Conflict: file differs from registry template: ${targetPath}`
+      );
+      result.conflicted.push(targetPath);
+      continue;
+    }
+    plannedRemovals.push(targetPath);
+  }
+  if (result.conflicted.length > 0) {
+    console.log(
+      "Skipped component file removal because one or more files differ from registry templates."
+    );
+    console.log("\nDone.");
+    return result;
+  }
+  for (const targetPath of plannedRemovals) {
+    await unlink(targetPath);
+    console.log(`Removed: ${targetPath}`);
+    result.removed.push(targetPath);
+  }
+  await tryRemoveEmptyDirectory(componentDirectory);
+  console.log("\nDone.");
+  return result;
+};
+var uninstallUtilities = async (utilities, config) => {
+  const result = createUninstallResourceResult();
+  for (const utility of utilities) {
+    const sourcePath = getRegistryTemplatePath(utility.path);
+    const targetPath = join(getCwd(), config.paths.utilities, utility.target);
+    await removeFileIfMatchesTemplate(sourcePath, targetPath, result);
+  }
+  return result;
+};
+var uninstallStyles = async (styles, config) => {
+  const result = createUninstallResourceResult();
+  for (const style of styles) {
+    console.log(`Uninstalling style ${style.name}...`);
+    for (const file of style.files) {
+      const sourcePath = getRegistryTemplatePath(file.path);
+      const targetPath = join(getCwd(), config.paths.styles, file.target);
+      await removeGeneratedStyleIfMatchesTemplate(
+        sourcePath,
+        targetPath,
+        result
+      );
+    }
+  }
+  return result;
+};
+var dependencyNamePattern = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/iu;
+var parseDependencySpec = (spec) => {
+  if (spec.startsWith("@")) {
+    const versionSeparator2 = spec.indexOf("@", 1);
+    if (versionSeparator2 === -1) {
+      return { name: spec };
+    }
+    return {
+      name: spec.slice(0, versionSeparator2),
+      version: spec.slice(versionSeparator2 + 1)
+    };
+  }
+  const versionSeparator = spec.indexOf("@");
+  if (versionSeparator === -1) {
+    return { name: spec };
+  }
+  return {
+    name: spec.slice(0, versionSeparator),
+    version: spec.slice(versionSeparator + 1)
+  };
+};
+var isSafeDependencySpec = (spec) => {
+  const { name, version } = parseDependencySpec(spec);
+  if (!dependencyNamePattern.test(name)) {
+    return false;
+  }
+  if (version === void 0) {
+    return true;
+  }
+  return version.length > 0;
+};
+var assertSafeDependencyNames = (deps) => {
+  const unsafeDependency = deps.find(
+    (dependency) => !isSafeDependencySpec(dependency)
+  );
+  if (unsafeDependency) {
+    throw new Error(`Invalid dependency name: ${unsafeDependency}`);
+  }
+};
+var getPackageManagerInvocation = (packageManager, args2) => {
+  if (process.platform === "win32") {
+    return {
+      command: "cmd.exe",
+      args: ["/d", "/s", "/c", packageManager, ...args2]
+    };
+  }
+  return {
+    command: packageManager,
+    args: args2
+  };
+};
+var detectPackageManager = async (packageJson) => {
+  const declaredPackageManager = typeof packageJson.packageManager === "string" ? packageJson.packageManager : void 0;
+  if (declaredPackageManager?.startsWith("pnpm@")) return "pnpm";
+  if (declaredPackageManager?.startsWith("yarn@")) return "yarn";
+  if (declaredPackageManager?.startsWith("npm@")) return "npm";
+  const hasPackageLock = await fileExists(join(getCwd(), "package-lock.json"));
+  const hasPnpmLock = await fileExists(join(getCwd(), "pnpm-lock.yaml"));
+  const hasYarnLock = await fileExists(join(getCwd(), "yarn.lock"));
+  if (hasPackageLock) return "npm";
+  if (hasPnpmLock) return "pnpm";
+  if (hasYarnLock) return "yarn";
+  return "npm";
+};
+var installDependencies = async (deps, options = {}) => {
+  if (!deps.length) return;
+  let packageJson;
+  try {
+    const content = await readFile(join(getCwd(), "package.json"), "utf-8");
+    packageJson = JSON.parse(content);
+  } catch (error) {
+    if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+    console.log("No package.json found, skipping dependency install.");
+    return;
+  }
+  const dependencies = typeof packageJson.dependencies === "object" && packageJson.dependencies !== null ? packageJson.dependencies : {};
+  const devDependencies = typeof packageJson.devDependencies === "object" && packageJson.devDependencies !== null ? packageJson.devDependencies : {};
+  const existingDeps = {
+    ...dependencies,
+    ...devDependencies
+  };
+  const packageManager = await detectPackageManager(packageJson);
+  const missing = deps.filter((dep) => {
+    const { name } = parseDependencySpec(dep);
+    return !existingDeps[name];
+  });
+  assertSafeDependencyNames(missing);
+  if (!missing.length) {
+    console.log("All dependencies already installed.\n");
+    return;
+  }
+  console.log("Installing dependencies:");
+  missing.forEach((dependency) => console.log(`- ${dependency}`));
+  console.log(`Using package manager: ${packageManager}`);
+  console.log("");
+  const installCommand = packageManager === "pnpm" ? ["pnpm", ["add", ...options.dev ? ["-D"] : [], ...missing]] : packageManager === "yarn" ? ["yarn", ["add", ...options.dev ? ["--dev"] : [], ...missing]] : [
+    "npm",
+    ["install", ...options.dev ? ["--save-dev"] : [], ...missing]
+  ];
+  const [command2, commandArgs] = installCommand;
+  const invocation = getPackageManagerInvocation(command2, commandArgs);
+  execFileSync(invocation.command, invocation.args, {
+    cwd: getCwd(),
+    stdio: "inherit"
+  });
+};
+
+// src/registry/remote.ts
+var isStringArray = (value) => {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+};
+var isRegistryStyle = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const style = value;
+  return typeof style.name === "string" && typeof style.version === "string" && Array.isArray(style.files) && style.files.every((file) => {
+    return typeof file === "object" && file !== null && typeof file.path === "string" && typeof file.target === "string";
+  });
+};
+var isRegistryItem = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const item = value;
+  return typeof item.name === "string" && typeof item.canonicalName === "string" && typeof item.version === "string" && typeof item.type === "string" && typeof item.category === "string" && Array.isArray(item.aliases) && isStringArray(item.files) && isStringArray(item.dependencies) && isStringArray(item.registryDependencies) && isStringArray(item.utilities) && isStringArray(item.styles) && typeof item.target === "string";
+};
+var findInvalidRegistryItemIndex = (items) => {
+  return items.findIndex((item) => {
+    return !isRegistryItem(item);
+  });
+};
+var parseRegistryItems = (items) => {
+  const invalidIndex = findInvalidRegistryItemIndex(items);
+  if (invalidIndex !== -1) {
+    throw new Error(
+      `Remote registry contains invalid registry item at index ${invalidIndex}.`
+    );
+  }
+  return items;
+};
+var parseRegistryStyles = (styles) => {
+  const invalidIndex = styles.findIndex((style) => {
+    return !isRegistryStyle(style);
+  });
+  if (invalidIndex !== -1) {
+    throw new Error(
+      `Remote registry contains invalid style entry at index ${invalidIndex}.`
+    );
+  }
+  return styles;
+};
+var parseRemoteRegistry = (value) => {
+  if (Array.isArray(value)) {
+    return {
+      version: "unknown",
+      items: parseRegistryItems(value)
+    };
+  }
+  if (typeof value !== "object" || value === null) {
+    throw new Error("Remote registry must be a JSON array or manifest object.");
+  }
+  const manifest = value;
+  if (typeof manifest.version !== "string" || !Array.isArray(manifest.items)) {
+    throw new Error("Remote registry manifest must contain version and items.");
+  }
+  const parsed = {
+    version: manifest.version,
+    items: parseRegistryItems(manifest.items)
+  };
+  if (manifest.styles !== void 0) {
+    if (!Array.isArray(manifest.styles)) {
+      throw new Error("Remote registry manifest styles must be an array.");
+    }
+    parsed.styles = parseRegistryStyles(manifest.styles);
+  }
+  return parsed;
+};
+var fetchRemoteRegistry = async (url) => {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Remote registry responded with HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  return parseRemoteRegistry(data);
+};
+
+// src/registry/source.ts
+var getRegistrySource = async () => {
+  const config = await loadConfig();
+  return config.registryUrl ?? "local";
+};
+
+// src/registry/provider.ts
+var cachedRegistry = null;
+var cachedSource = null;
+var cachedManifestVersion = null;
+var fallbackWarningShown = false;
+var getRegistryItems = async (options = {}) => {
+  const fallback = options.fallback ?? true;
+  const source = await getRegistrySource();
+  if (cachedRegistry && cachedSource === source) {
+    return cachedRegistry;
+  }
+  if (source === "local") {
+    validateRegistry(registryItems, {
+      styles: registryStyles
+    });
+    cachedRegistry = registryItems;
+    cachedSource = source;
+    cachedManifestVersion = registryVersion;
+    return registryItems;
+  }
+  try {
+    const remote = await fetchRemoteRegistry(source);
+    validateRegistry(
+      remote.items,
+      remote.styles !== void 0 ? {
+        styles: remote.styles
+      } : {}
+    );
+    cachedRegistry = remote.items;
+    cachedSource = source;
+    cachedManifestVersion = remote.version;
+    return remote.items;
+  } catch (error) {
+    if (!fallback) {
+      throw error;
+    }
+    if (!fallbackWarningShown) {
+      console.log("Remote registry failed. Falling back to local registry.");
+      fallbackWarningShown = true;
+    }
+    cachedRegistry = registryItems;
+    cachedSource = source;
+    cachedManifestVersion = registryVersion;
+    return registryItems;
+  }
+};
+var getRegistryProviderResult = async (options = {}) => {
+  const source = await getRegistrySource();
+  const items = await getRegistryItems(options);
+  validateRegistry(
+    items,
+    items === registryItems ? {
+      styles: registryStyles
+    } : {}
+  );
+  return {
+    items,
+    source,
+    fallbackUsed: source !== "local" && items === registryItems,
+    manifestVersion: cachedManifestVersion ?? registryVersion
+  };
+};
+
+// src/utils/suggestions.ts
+var calculateLevenshteinDistance = (firstValue, secondValue) => {
+  const firstLength = firstValue.length;
+  const secondLength = secondValue.length;
+  const matrix = Array.from(
+    { length: firstLength + 1 },
+    () => Array.from({ length: secondLength + 1 }, () => 0)
+  );
+  for (let firstIndex = 0; firstIndex <= firstLength; firstIndex += 1) {
+    matrix[firstIndex][0] = firstIndex;
+  }
+  for (let secondIndex = 0; secondIndex <= secondLength; secondIndex += 1) {
+    matrix[0][secondIndex] = secondIndex;
+  }
+  for (let firstIndex = 1; firstIndex <= firstLength; firstIndex += 1) {
+    for (let secondIndex = 1; secondIndex <= secondLength; secondIndex += 1) {
+      const cost = firstValue[firstIndex - 1] === secondValue[secondIndex - 1] ? 0 : 1;
+      matrix[firstIndex][secondIndex] = Math.min(
+        matrix[firstIndex - 1][secondIndex] + 1,
+        matrix[firstIndex][secondIndex - 1] + 1,
+        matrix[firstIndex - 1][secondIndex - 1] + cost
+      );
+    }
+  }
+  return matrix[firstLength][secondLength];
+};
+var findClosestValue = (input, values) => {
+  const normalizedInput = input.toLowerCase();
+  const ranked = values.map((value) => ({
+    value,
+    distance: calculateLevenshteinDistance(
+      normalizedInput,
+      value.toLowerCase()
+    )
+  })).sort((first, second) => first.distance - second.distance);
+  const closest = ranked[0];
+  if (!closest || closest.distance > 3) {
+    return void 0;
+  }
+  return closest.value;
+};
+
+// src/registry/resolver.ts
+var registryStyles2 = registryStyles;
+var registryUtilities = registryUtilities$1;
+var normalizeName = (name) => {
+  return name.toLowerCase();
+};
+var findItem = async (name, options = {}) => {
+  const items = await getRegistryItems(options);
+  const normalizedName = normalizeName(name);
+  const item = items.find(
+    (registryItem) => normalizeName(registryItem.name) === normalizedName || normalizeName(registryItem.canonicalName) === normalizedName || registryItem.aliases.some(
+      (alias) => normalizeName(alias) === normalizedName
+    )
+  );
+  if (item) {
+    validateRegistryItem(item);
+  }
+  return item;
+};
+var resolveRegistryItems = async (names, options = {}) => {
+  const items = await getRegistryItems(options);
+  const resolved = /* @__PURE__ */ new Map();
+  const findLocalItem = (name) => {
+    const normalizedName = normalizeName(name);
+    return items.find(
+      (item) => normalizeName(item.name) === normalizedName || normalizeName(item.canonicalName) === normalizedName || item.aliases.some((alias) => normalizeName(alias) === normalizedName)
+    );
+  };
+  const visit = (name) => {
+    const item = findLocalItem(name);
+    if (!item) {
+      const availableNames = items.flatMap((registryItem) => [
+        registryItem.name,
+        registryItem.canonicalName,
+        ...registryItem.aliases
+      ]);
+      const suggestion = findClosestValue(name, availableNames);
+      throw new CliError(
+        suggestion ? `Component "${name}" not found. Did you mean "${suggestion}"?` : `Component "${name}" not found.`
+      );
+    }
+    validateRegistryItem(item);
+    const key = normalizeName(item.canonicalName);
+    if (resolved.has(key)) {
+      return;
+    }
+    resolved.set(key, item);
+    for (const dependency of item.registryDependencies) {
+      visit(dependency);
+    }
+  };
+  for (const name of names) {
+    visit(name);
+  }
+  return Array.from(resolved.values());
+};
+var collectDependencies = (items) => {
+  return Array.from(new Set(items.flatMap((item) => item.dependencies)));
+};
+var collectUtilities = (items) => {
+  return Array.from(new Set(items.flatMap((item) => item.utilities)));
+};
+var collectStyles = (items) => {
+  return Array.from(new Set(items.flatMap((item) => item.styles)));
+};
+var resolveRegistryStyles = (names) => {
+  return names.map((name) => {
+    const style = registryStyles2.find((registryStyle) => {
+      return normalizeName(registryStyle.name) === normalizeName(name);
+    });
+    if (!style) {
+      throw new CliError(`Style "${name}" not found in registry.`);
+    }
+    return style;
+  });
+};
+var resolveRegistryUtilities = (names) => {
+  return names.map((name) => {
+    const utility = registryUtilities.find((registryUtility) => {
+      return normalizeName(registryUtility.name) === normalizeName(name);
+    });
+    if (!utility) {
+      throw new CliError(`Utility "${name}" not found in registry.`);
+    }
+    return utility;
+  });
+};
+
+// src/core/flags.ts
+var hasFlag = (args2, ...flags) => {
+  return flags.some((f) => args2.includes(f));
+};
+var removeFlags = (args2, flags) => {
+  return args2.filter((arg) => !flags.includes(arg));
+};
+var getFlagValue = (args2, ...flags) => {
+  for (const flag of flags) {
+    const index = args2.indexOf(flag);
+    if (index !== -1) return args2[index + 1];
+  }
+  return void 0;
+};
+var removeFlagsWithValues = (args2, flags) => {
+  const result = [];
+  for (let index = 0; index < args2.length; index += 1) {
+    const arg = args2[index];
+    if (flags.includes(arg)) {
+      index += 1;
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
+};
+
+// src/commands/add.ts
+var promptSelectItems = async () => {
+  const response = await prompts({
+    type: "multiselect",
+    name: "items",
+    message: "Select components to add",
+    choices: registryItems.map((item) => ({
+      title: `${item.canonicalName} (${item.category})`,
+      value: item.name
+    }))
+  });
+  if (typeof response !== "object" || response === null) {
+    return [];
+  }
+  const items = response.items;
+  if (!Array.isArray(items)) {
+    return [];
+  }
+  return items.filter((item) => typeof item === "string");
+};
+var runAdd = async (args2) => {
+  const dryRun = hasFlag(args2, "--dry-run", "-d");
+  hasFlag(args2, "--yes", "-y");
+  const noFallback = hasFlag(args2, "--no-fallback");
+  let items = removeFlagsWithValues(args2, ["--cwd", "-C"]);
+  items = removeFlags(items, [
+    "--dry-run",
+    "-d",
+    "--yes",
+    "-y",
+    "--no-fallback"
+  ]);
+  if (!items.length) {
+    items = await promptSelectItems();
+    if (!items.length) {
+      console.log("No components selected.");
+      return;
+    }
+  }
+  let resolvedItems;
+  try {
+    resolvedItems = await resolveRegistryItems(items, {
+      fallback: !noFallback
+    });
+  } catch (error) {
+    console.log("Failed to resolve registry.");
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return;
+  }
+  const dependencies = collectDependencies(resolvedItems);
+  const utilities = collectUtilities(resolvedItems);
+  const styleNames = collectStyles(resolvedItems);
+  let resolvedUtilities;
+  let styles;
+  try {
+    resolvedUtilities = resolveRegistryUtilities(utilities);
+    styles = resolveRegistryStyles(styleNames);
+  } catch (error) {
+    console.log("Failed to resolve registry shared resources.");
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return;
+  }
+  const config = await loadConfig();
+  if (dryRun) {
+    console.log("Dry run: no files or dependencies will be changed.\n");
+    console.log("Components:");
+    for (const item of resolvedItems) {
+      console.log(`- ${item.canonicalName} v${item.version}`);
+    }
+    console.log("\nDependencies:");
+    for (const dependency of dependencies) {
+      console.log(`- ${dependency}`);
+    }
+    console.log("\nUtilities:");
+    for (const utility of utilities) {
+      console.log(`- ${utility}`);
+    }
+    console.log("\nStyles:");
+    for (const styleName of styleNames) {
+      console.log(`- ${styleName}`);
+    }
+    console.log("\nInstall paths:");
+    console.log(`- components: ${config.paths.components}`);
+    console.log(`- utilities: ${config.paths.utilities}`);
+    console.log(`- styles: ${config.paths.styles}`);
+    console.log(`- tailwind css: ${config.tailwind.css}`);
+    return;
+  }
+  await ensureProjectStructure(config);
+  await installDependencies(dependencies);
+  const utilitiesResult = await installUtilities(resolvedUtilities, config);
+  const stylesResult = await installStyles(styles, config);
+  const successfullyInstalled = [];
+  const itemResults = [];
+  for (const item of resolvedItems) {
+    const itemResult = await installItemFiles(item, config);
+    itemResults.push(itemResult);
+    if (hasInstallConflicts(itemResult)) {
+      console.log(
+        `${item.canonicalName} was not marked as installed because conflicts were found.`
+      );
+    } else {
+      successfullyInstalled.push(item);
+    }
+    console.log("");
+  }
+  const installed = {
+    ...config.installed ?? {}
+  };
+  for (const item of successfullyInstalled) {
+    installed[item.name] = item.version;
+  }
+  await saveConfig({
+    ...config,
+    installed
+  });
+  const itemSummary = mergeInstallResults(itemResults);
+  const sharedSummary = mergeInstallResults([utilitiesResult, stylesResult]);
+  console.log("Install summary:");
+  printResourceSummary("components", itemSummary);
+  printResourceSummary("shared resources", sharedSummary);
+  console.log(
+    `- tracked components: ${successfullyInstalled.length}/${resolvedItems.length}`
+  );
+  if (hasInstallConflicts(sharedSummary)) {
+    console.log(
+      "Shared resource conflicts were left untouched. Review them before relying on the installed components."
+    );
+  }
+};
+
+// src/commands/config.ts
+var runConfig = async (options = {}) => {
+  const configPath = getConfigPath();
+  if (options.path) {
+    console.log(configPath);
+    return;
+  }
+  if (options.exists) {
+    const exists = await fileExists(configPath);
+    console.log(exists ? "Config exists." : "Config does not exist.");
+    return;
+  }
+  if (options.clearRegistryUrl) {
+    const config2 = await loadConfig();
+    await saveConfig({
+      ...config2,
+      registryUrl: null
+    });
+    console.log("Registry URL cleared.");
+    return;
+  }
+  if (options.setRegistryUrl !== void 0) {
+    const config2 = await loadConfig();
+    await saveConfig({
+      ...config2,
+      registryUrl: options.setRegistryUrl || null
+    });
+    console.log(
+      options.setRegistryUrl ? `Registry URL set to: ${options.setRegistryUrl}` : "Registry URL cleared."
+    );
+    return;
+  }
+  const config = await loadConfig();
+  console.log(JSON.stringify(config, null, 2));
+};
+var runDoctor = async (options = {}) => {
+  console.log("Lexsys doctor\n");
+  const config = await loadConfig();
+  let registryFailed = false;
+  const checks = [
+    {
+      label: "package.json",
+      path: join(getCwd(), "package.json")
+    },
+    {
+      label: config.paths.components,
+      path: join(getCwd(), config.paths.components)
+    },
+    {
+      label: config.paths.utilities,
+      path: join(getCwd(), config.paths.utilities)
+    },
+    {
+      label: config.paths.styles,
+      path: join(getCwd(), config.paths.styles)
+    },
+    {
+      label: config.tailwind.css,
+      path: join(getCwd(), config.tailwind.css)
+    }
+  ];
+  for (const check of checks) {
+    const exists = await fileExists(check.path);
+    console.log(`${exists ? "\u2713" : "\xD7"} ${check.label}`);
+  }
+  try {
+    const registryResult = await getRegistryProviderResult({
+      fallback: !options.noFallback
+    });
+    console.log("\nRegistry:");
+    console.log(`\u2713 source: ${registryResult.source}`);
+    console.log(`\u2713 fallback: ${registryResult.fallbackUsed ? "yes" : "no"}`);
+    console.log(`\u2713 items: ${registryResult.items.length}`);
+  } catch (error) {
+    registryFailed = true;
+    console.log("\nRegistry:");
+    console.log("\xD7 failed to resolve registry");
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+  if (registryFailed && options.noFallback) {
+    return;
+  }
+  const installed = config.installed ?? {};
+  if (Object.keys(installed).length) {
+    console.log("\nTracked components:");
+    for (const [name, version] of Object.entries(installed)) {
+      const item = await findItem(name);
+      if (!item) {
+        console.log(`\xD7 ${name} v${version} (missing from registry)`);
+        continue;
+      }
+      const componentPath = join(
+        getCwd(),
+        resolveItemInstallTarget(config, item)
+      );
+      const exists = await fileExists(componentPath);
+      const layer = getInstallLayer(item) ?? "unknown";
+      console.log(
+        `${exists ? "\u2713" : "\xD7"} ${item.canonicalName} v${version} (${layer})`
+      );
+    }
+  }
+};
+
+// src/commands/help.ts
+var COMMAND_HELP = {
+  init: `
+Usage
+  lexsys init [framework] [directory]
+  lexsys create [framework] [directory]
+
+Frameworks
+  vite [directory]    Scaffold a Vite React app and initialize Lexsys
+  next [directory]    Scaffold a Next.js App Router app and initialize Lexsys
+
+  Run without arguments for guided setup.
+
+Options
+  --help, -h          Show this help
+
+Examples
+  lexsys create
+  lexsys create vite
+  lexsys create vite my-app
+  lexsys create next my-app
+`,
+  add: `
+Usage
+  lexsys add <component...>
+  lexsys a <component...>
+
+Options
+  --dry-run, -d       Preview files, dependencies, and install paths
+  --yes, -y           Auto-confirm safe prompts
+  --no-fallback       Fail instead of falling back to local registry
+  --cwd, -C <path>    Run from a different project directory
+  --help, -h          Show this help
+
+Examples
+  lexsys add button
+  lexsys add button dialog toast
+  lexsys add button --dry-run
+  lexsys add button --cwd ./apps/web
+`,
+  update: `
+Usage
+  lexsys update [component...]
+  lexsys up [component...]
+
+Options
+  --all, -a           Update all tracked components
+  --styles, -S        Update generated token/theme CSS files
+  --utilities, -u     Update shared utility files
+  --sync              Refresh tracked components even when versions match
+  --dry-run, -d       Preview update without writing files
+  --force, -f         Write conflicted updates after creating backups
+  --yes, -y           Auto-confirm safe prompts
+  --no-fallback       Fail instead of falling back to local registry
+  --cwd, -C <path>    Run from a different project directory
+  --help, -h          Show this help
+
+  Run without arguments for guided update picker.
+
+Examples
+  lexsys up
+  lexsys up button
+  lexsys up --all
+  lexsys up --styles
+  lexsys up --all --sync --utilities --styles
+`,
+  list: `
+Usage
+  lexsys list
+  lexsys ls
+
+Options
+  --json, -j          Print registry items as JSON
+  --no-fallback       Fail instead of falling back to local registry
+  --help, -h          Show this help
+
+Examples
+  lexsys ls
+  lexsys ls --json
+`,
+  status: `
+Usage
+  lexsys status
+  lexsys st
+
+Options
+  --no-fallback       Fail instead of falling back to local registry
+  --help, -h          Show this help
+`,
+  uninstall: `
+Usage
+  lexsys uninstall [component...]
+  lexsys rm [component...]
+
+Options
+  --dry-run, -d       Preview uninstall without removing files
+  --with-deps, -w     Also remove registry-owned shared dependencies
+  --help, -h          Show this help
+
+  Run without arguments for guided uninstall picker.
+
+Examples
+  lexsys rm button
+  lexsys rm button --dry-run
+`,
+  doctor: `
+Usage
+  lexsys doctor
+  lexsys dr
+
+Options
+  --no-fallback       Fail instead of falling back to local registry
+  --help, -h          Show this help
+`,
+  registry: `
+Usage
+  lexsys registry
+  lexsys reg
+
+Options
+  --summary, -s       Print a human-readable registry summary
+  --source            Print effective registry source
+  --local, -l         Read only the bundled local registry
+  --remote, -r        Read only the configured remote registry
+  --no-fallback       Disable local fallback for default resolution
+  --help, -h          Show this help
+
+Examples
+  lexsys reg --summary
+  lexsys reg --remote --source
+`,
+  config: `
+Usage
+  lexsys config
+  lexsys cfg
+
+Options
+  --path, -p                 Print config file path
+  --exists, -e               Check whether config exists
+  --set-registry-url <url>   Set remote registry URL
+  --clear-registry-url       Clear remote registry URL
+  --help, -h                 Show this help
+
+Examples
+  lexsys cfg --path
+  lexsys cfg --set-registry-url https://example.com/registry.json
+`
+};
+var runHelpFor = (command2) => {
+  const help = COMMAND_HELP[command2];
+  if (help) {
+    console.log(help);
+  } else {
+    runHelp();
+  }
+};
+var runHelp = () => {
+  console.log(`
+Lexsys CLI
+
+Usage
+  lexsys <command> [options]
+
+Scaffold
+  init, create              Initialize Lexsys or scaffold a framework starter
+                            Alias: create  |  Run without args for guided setup
+
+Components
+  add <component...>        Install components into your project       [alias: a]
+  update [component...]     Update installed components                [alias: up]
+  uninstall [component...]  Remove installed components                [alias: rm]
+
+Inspect
+  list                      List available registry items              [alias: ls]
+  status                    Show installed component status            [alias: st]
+  doctor                    Check local project setup                  [alias: dr]
+  registry                  Inspect registry source and manifest       [alias: reg]
+  config                    Print or update Lexsys config              [alias: cfg]
+
+Meta
+  version                   Print CLI version                          [-v]
+  help                      Show this help                             [-h]
+
+Global Options
+  --cwd, -C <path>          Run from a different project directory
+  --yes, -y                 Auto-confirm safe prompts where supported
+  --no-fallback             Disable local registry fallback
+  --help, -h                Show help
+  --version, -v             Show CLI version
+
+Run \`lexsys <command> --help\` for command-specific options.
+`);
+};
+var NEXT_VERSION = "15.3.3";
+var gitIgnore = `node_modules
+.next
+out
+dist
+*.local
+.env
+.env.*
+!.env.example
+`;
+var prettierIgnore = `node_modules
+.next
+out
+dist
+coverage
+pnpm-lock.yaml
+package-lock.json
+yarn.lock
+`;
+var prettierConfig = `{
+  "semi": false,
+  "trailingComma": "all"
+}
+`;
+var nextConfig = `import type { NextConfig } from "next"
+
+const nextConfig: NextConfig = {}
+
+export default nextConfig
+`;
+var postcssConfig = `const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+}
+
+export default config
+`;
+var tsConfig = `{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "global.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}
+`;
+var nextEnvDts = `/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+`;
+var globalDts = `declare module "*.css" {
+  const content: Record<string, string>
+  export default content
+}
+`;
+var layoutTsx = `import type { Metadata } from "next"
+import "./globals.css"
+
+export const metadata: Metadata = {
+  title: "Lexsys Next App",
+}
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode
+}>) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  )
+}
+`;
+var pageTsx = `export default function Home() {
+  return (
+    <main>
+      <h1>Lexsys + Next.js</h1>
+    </main>
+  )
+}
+`;
+var globalsCss = `@import "tailwindcss";
+
+:root {
+  font-family:
+    Inter,
+    ui-sans-serif,
+    system-ui,
+    -apple-system,
+    BlinkMacSystemFont,
+    "Segoe UI",
+    sans-serif;
+  color: #111827;
+  background: #ffffff;
+}
+
+body {
+  margin: 0;
+}
+
+main {
+  min-height: 100vh;
+  display: grid;
+  place-items: center;
+}
+`;
+var sanitizePackageName = (name) => {
+  const normalized = name.toLowerCase().replace(/[^a-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "");
+  return normalized || "lexsys-next-app";
+};
+var getPackageManagerFromUserAgent = () => {
+  const userAgent = process.env.npm_config_user_agent;
+  const match = userAgent?.match(/^(npm|pnpm|yarn)\/([^\s]+)/u);
+  if (!match) {
+    return void 0;
+  }
+  return `${match[1]}@${match[2]}`;
+};
+var getPackageJson = (targetDirectory) => {
+  const packageManager = getPackageManagerFromUserAgent();
+  const packageJson = {
+    name: sanitizePackageName(basename(targetDirectory)),
+    private: true,
+    version: "0.0.0",
+    scripts: {
+      dev: "next dev",
+      build: "next build",
+      start: "next start",
+      typecheck: "tsc --noEmit",
+      format: "prettier --write .",
+      "format:check": "prettier --check ."
+    }
+  };
+  if (packageManager) {
+    packageJson.packageManager = packageManager;
+  }
+  return JSON.stringify(packageJson, null, 2) + "\n";
+};
+var getRecordValue = (value) => {
+  return typeof value === "object" && value !== null ? value : {};
+};
+var mergePackageJson = (targetDirectory, existingPackageJson) => {
+  const packageManager = getPackageManagerFromUserAgent();
+  const existingScripts = getRecordValue(existingPackageJson.scripts);
+  const mergedPackageJson = {
+    ...existingPackageJson,
+    name: typeof existingPackageJson.name === "string" ? existingPackageJson.name : sanitizePackageName(basename(targetDirectory)),
+    private: typeof existingPackageJson.private === "boolean" ? existingPackageJson.private : true,
+    version: typeof existingPackageJson.version === "string" ? existingPackageJson.version : "0.0.0",
+    scripts: {
+      dev: "next dev",
+      build: "next build",
+      start: "next start",
+      typecheck: "tsc --noEmit",
+      format: "prettier --write .",
+      "format:check": "prettier --check .",
+      ...existingScripts
+    }
+  };
+  if (packageManager && typeof mergedPackageJson.packageManager !== "string") {
+    mergedPackageJson.packageManager = packageManager;
+  }
+  return JSON.stringify(mergedPackageJson, null, 2) + "\n";
+};
+var writePackageJson = async (targetDirectory) => {
+  const targetPath = join(targetDirectory, "package.json");
+  if (!await fileExists(targetPath)) {
+    await writeFile(targetPath, getPackageJson(targetDirectory), "utf-8");
+    console.log(`Created scaffold file: ${targetPath}`);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(targetPath, "utf-8"));
+  } catch {
+    throw new Error(`Invalid existing package.json: ${targetPath}`);
+  }
+  const content = await readFile(targetPath, "utf-8");
+  const mergedContent = mergePackageJson(targetDirectory, parsed);
+  if (content === mergedContent) {
+    console.log(`Skipped package.json: ${targetPath} already configured`);
+    return;
+  }
+  await writeFile(targetPath, mergedContent, "utf-8");
+  console.log(`Updated package.json: ${targetPath}`);
+};
+var writeScaffoldFile = async (targetPath, content, options = {}) => {
+  if (await fileExists(targetPath)) {
+    const existingContent = await readFile(targetPath, "utf-8");
+    if (existingContent === content) {
+      console.log(`Skipped identical scaffold file: ${targetPath}`);
+      return;
+    }
+    if (options.allowExisting) {
+      console.log(`Skipped existing scaffold file: ${targetPath}`);
+      return;
+    }
+    throw new Error(
+      `Refusing to overwrite existing scaffold file: ${targetPath}`
+    );
+  }
+  await mkdir(dirname(targetPath), { recursive: true });
+  await writeFile(targetPath, content, "utf-8");
+  console.log(`Created scaffold file: ${targetPath}`);
+};
+var scaffoldNextProject = async (targetDirectory) => {
+  await mkdir(targetDirectory, { recursive: true });
+  await writePackageJson(targetDirectory);
+  await writeScaffoldFile(join(targetDirectory, ".gitignore"), gitIgnore, {
+    allowExisting: true
+  });
+  await writeScaffoldFile(
+    join(targetDirectory, ".prettierignore"),
+    prettierIgnore,
+    {
+      allowExisting: true
+    }
+  );
+  await writeScaffoldFile(
+    join(targetDirectory, ".prettierrc"),
+    prettierConfig,
+    {
+      allowExisting: true
+    }
+  );
+  await writeScaffoldFile(join(targetDirectory, "next.config.ts"), nextConfig, {
+    allowExisting: true
+  });
+  await writeScaffoldFile(
+    join(targetDirectory, "postcss.config.mjs"),
+    postcssConfig,
+    {
+      allowExisting: true
+    }
+  );
+  await writeScaffoldFile(join(targetDirectory, "tsconfig.json"), tsConfig, {
+    allowExisting: true
+  });
+  await writeScaffoldFile(join(targetDirectory, "next-env.d.ts"), nextEnvDts, {
+    allowExisting: true
+  });
+  await writeScaffoldFile(join(targetDirectory, "global.d.ts"), globalDts, {
+    allowExisting: true
+  });
+  await writeScaffoldFile(join(targetDirectory, "app", "layout.tsx"), layoutTsx);
+  await writeScaffoldFile(join(targetDirectory, "app", "page.tsx"), pageTsx);
+  await writeScaffoldFile(
+    join(targetDirectory, "app", "globals.css"),
+    globalsCss,
+    {
+      allowExisting: true
+    }
+  );
+};
+var tailwindImport = '@import "tailwindcss";';
+var viteConfigFiles = [
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs"
+];
+var tsConfigFiles = ["tsconfig.app.json", "tsconfig.json"];
+var postcssConfigFiles = ["postcss.config.mjs", "postcss.config.js"];
+var viteSrcAlias = `"@": fileURLToPath(new URL("./src", import.meta.url))`;
+var tsSrcAlias = `"@/*": ["./src/*"]`;
+var ensureTailwindCssImport = async (config) => {
+  const cssPath = join(getCwd(), config.tailwind.css);
+  if (!await fileExists(cssPath)) {
+    await mkdir(dirname(cssPath), { recursive: true });
+    await writeFile(cssPath, `${tailwindImport}
+`, "utf-8");
+    console.log(`Created Tailwind CSS entrypoint: ${cssPath}`);
+    return;
+  }
+  const content = await readFile(cssPath, "utf-8");
+  if (content.includes(tailwindImport)) {
+    console.log(
+      `Skipped Tailwind CSS import: ${cssPath} already imports Tailwind`
+    );
+    return;
+  }
+  await writeFile(cssPath, `${tailwindImport}
+${content}`, "utf-8");
+  console.log(`Updated Tailwind CSS entrypoint: ${cssPath}`);
+};
+var ensureViteTailwindPlugin = async () => {
+  const viteConfigPath = await findViteConfigPath();
+  if (!viteConfigPath) {
+    console.log("Skipped Vite Tailwind plugin: no Vite config found.");
+    return;
+  }
+  const content = await readFile(viteConfigPath, "utf-8");
+  const withImport = ensureTailwindViteImport(content);
+  const updatedContent = ensureTailwindVitePluginUsage(withImport);
+  if (updatedContent === content) {
+    console.log(
+      `Skipped Vite Tailwind plugin: ${viteConfigPath} already configured`
+    );
+    return;
+  }
+  await writeFile(viteConfigPath, updatedContent, "utf-8");
+  console.log(`Updated Vite config: ${viteConfigPath}`);
+};
+var ensureViteSrcAlias = async () => {
+  const viteConfigPath = await findViteConfigPath();
+  if (!viteConfigPath) {
+    console.log("Skipped Vite alias: no Vite config found.");
+    return;
+  }
+  const content = await readFile(viteConfigPath, "utf-8");
+  const withImport = ensureNodeUrlImport(content);
+  const updatedContent = ensureViteResolveAliasUsage(withImport);
+  if (updatedContent === content) {
+    console.log(`Skipped Vite alias: ${viteConfigPath} already configured`);
+    return;
+  }
+  await writeFile(viteConfigPath, updatedContent, "utf-8");
+  console.log(`Updated Vite alias: ${viteConfigPath}`);
+};
+var ensureTypeScriptSrcAlias = async () => {
+  const tsConfigPath = await findTypeScriptConfigPath();
+  if (!tsConfigPath) {
+    const fallbackPath = join(getCwd(), "tsconfig.json");
+    await writeFile(
+      fallbackPath,
+      `{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}
+`,
+      "utf-8"
+    );
+    console.log(`Created TypeScript alias config: ${fallbackPath}`);
+    return;
+  }
+  const content = await readFile(tsConfigPath, "utf-8");
+  const updatedContent = ensureTypeScriptPathsAlias(content);
+  if (updatedContent === content) {
+    console.log(`Skipped TypeScript alias: ${tsConfigPath} already configured`);
+    return;
+  }
+  await writeFile(tsConfigPath, updatedContent, "utf-8");
+  console.log(`Updated TypeScript alias: ${tsConfigPath}`);
+};
+var ensureNextPostCssConfig = async () => {
+  for (const file of postcssConfigFiles) {
+    const configPath = join(getCwd(), file);
+    if (!await fileExists(configPath)) {
+      continue;
+    }
+    const content = await readFile(configPath, "utf-8");
+    if (content.includes("@tailwindcss/postcss")) {
+      console.log(
+        `Skipped PostCSS config: ${configPath} already configures Tailwind`
+      );
+      return;
+    }
+  }
+  const targetPath = join(getCwd(), "postcss.config.mjs");
+  await writeFile(
+    targetPath,
+    `const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+}
+
+export default config
+`,
+    "utf-8"
+  );
+  console.log(`Created PostCSS config: ${targetPath}`);
+};
+var findViteConfigPath = async () => {
+  for (const file of viteConfigFiles) {
+    const path = join(getCwd(), file);
+    if (await fileExists(path)) {
+      return path;
+    }
+  }
+  return void 0;
+};
+var findTypeScriptConfigPath = async () => {
+  for (const file of tsConfigFiles) {
+    const path = join(getCwd(), file);
+    if (await fileExists(path)) {
+      return path;
+    }
+  }
+  return void 0;
+};
+var ensureTailwindViteImport = (content) => {
+  if (content.includes("@tailwindcss/vite")) {
+    return content;
+  }
+  const importMatch = content.match(/^(?:import[^\n]*\n)+/u);
+  if (!importMatch) {
+    return `import tailwindcss from "@tailwindcss/vite"
+${content}`;
+  }
+  return `${content.slice(0, importMatch[0].length)}import tailwindcss from "@tailwindcss/vite"
+${content.slice(importMatch[0].length)}`;
+};
+var ensureTailwindVitePluginUsage = (content) => {
+  if (content.includes("tailwindcss()")) {
+    return content;
+  }
+  const pluginsMatch = content.match(/plugins\s*:\s*\[/u);
+  if (pluginsMatch?.index !== void 0) {
+    const insertionIndex = pluginsMatch.index + pluginsMatch[0].length;
+    return `${content.slice(0, insertionIndex)}tailwindcss(), ${content.slice(insertionIndex)}`;
+  }
+  return content.replace(
+    /defineConfig\(\s*\{/u,
+    "defineConfig({\n  plugins: [tailwindcss()],"
+  );
+};
+var ensureNodeUrlImport = (content) => {
+  if (content.includes('from "node:url"')) {
+    return content;
+  }
+  return `import { fileURLToPath, URL } from "node:url"
+${content}`;
+};
+var ensureViteResolveAliasUsage = (content) => {
+  if (content.includes(viteSrcAlias)) {
+    return content;
+  }
+  if (/"@":\s*fileURLToPath/u.test(content) || content.includes("resolve:")) {
+    return content;
+  }
+  return content.replace(
+    /defineConfig\(\s*\{/u,
+    `defineConfig({
+  resolve: {
+    alias: {
+      ${viteSrcAlias},
+    },
+  },`
+  );
+};
+var ensureTypeScriptPathsAlias = (content) => {
+  if (content.includes(tsSrcAlias)) {
+    return content;
+  }
+  if (/"paths"\s*:\s*\{\s*\}/u.test(content)) {
+    return content.replace(
+      /"paths"\s*:\s*\{\s*\}/u,
+      `"paths": {
+      ${tsSrcAlias}
+    }`
+    );
+  }
+  if (/"paths"\s*:\s*\{/u.test(content)) {
+    return content.replace(
+      /"paths"\s*:\s*\{/u,
+      `"paths": {
+      ${tsSrcAlias},`
+    );
+  }
+  if (/"compilerOptions"\s*:\s*\{\s*\}/u.test(content)) {
+    return content.replace(
+      /"compilerOptions"\s*:\s*\{\s*\}/u,
+      `"compilerOptions": {
+    "paths": {
+      ${tsSrcAlias}
+    }
+  }`
+    );
+  }
+  if (/"compilerOptions"\s*:\s*\{/u.test(content)) {
+    return content.replace(
+      /"compilerOptions"\s*:\s*\{/u,
+      `"compilerOptions": {
+    "paths": {
+      ${tsSrcAlias}
+    },`
+    );
+  }
+  return content;
+};
+var viteConfig = `import { fileURLToPath, URL } from "node:url"
+import { defineConfig } from "vite"
+import react from "@vitejs/plugin-react"
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      "@": fileURLToPath(new URL("./src", import.meta.url)),
+    },
+  },
+})
+`;
+var tsConfig2 = `{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
+`;
+var tsConfigApp = `{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+    "types": ["vite/client"],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}
+`;
+var tsConfigNode = `{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2022",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}
+`;
+var gitIgnore2 = `node_modules
+dist
+dist-ssr
+*.local
+.env
+.env.*
+!.env.example
+`;
+var prettierIgnore2 = `node_modules
+dist
+dist-ssr
+coverage
+pnpm-lock.yaml
+package-lock.json
+yarn.lock
+`;
+var prettierConfig2 = `{
+  "semi": false,
+  "trailingComma": "all"
+}
+`;
+var indexHtml = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Lexsys Vite App</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+var mainTsx = `import React from "react"
+import ReactDOM from "react-dom/client"
+import "./style.css"
+import { App } from "./App"
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)
+`;
+var appTsx = `export const App = () => {
+  return (
+    <main>
+      <h1>Lexsys + Vite</h1>
+    </main>
+  )
+}
+`;
+var styleCss = `@import "tailwindcss";
+
+:root {
+  font-family:
+    Inter,
+    ui-sans-serif,
+    system-ui,
+    -apple-system,
+    BlinkMacSystemFont,
+    "Segoe UI",
+    sans-serif;
+  color: #111827;
+  background: #ffffff;
+}
+
+body {
+  margin: 0;
+}
+
+main {
+  min-height: 100vh;
+  display: grid;
+  place-items: center;
+}
+`;
+var sanitizePackageName2 = (name) => {
+  const normalized = name.toLowerCase().replace(/[^a-z0-9._-]+/gu, "-").replace(/^-+|-+$/gu, "");
+  return normalized || "lexsys-vite-app";
+};
+var getPackageManagerFromUserAgent2 = () => {
+  const userAgent = process.env.npm_config_user_agent;
+  const match = userAgent?.match(/^(npm|pnpm|yarn)\/([^\s]+)/u);
+  if (!match) {
+    return void 0;
+  }
+  return `${match[1]}@${match[2]}`;
+};
+var getPackageJson2 = (targetDirectory) => {
+  const packageManager = getPackageManagerFromUserAgent2();
+  const packageJson = {
+    name: sanitizePackageName2(basename(targetDirectory)),
+    private: true,
+    version: "0.0.0",
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "tsc -b && vite build",
+      typecheck: "tsc -b",
+      format: "prettier --write .",
+      "format:check": "prettier --check .",
+      preview: "vite preview"
+    }
+  };
+  if (packageManager) {
+    packageJson.packageManager = packageManager;
+  }
+  return JSON.stringify(packageJson, null, 2) + "\n";
+};
+var getRecordValue2 = (value) => {
+  return typeof value === "object" && value !== null ? value : {};
+};
+var mergePackageJson2 = (targetDirectory, existingPackageJson) => {
+  const packageManager = getPackageManagerFromUserAgent2();
+  const existingScripts = getRecordValue2(existingPackageJson.scripts);
+  const mergedPackageJson = {
+    ...existingPackageJson,
+    name: typeof existingPackageJson.name === "string" ? existingPackageJson.name : sanitizePackageName2(basename(targetDirectory)),
+    private: typeof existingPackageJson.private === "boolean" ? existingPackageJson.private : true,
+    version: typeof existingPackageJson.version === "string" ? existingPackageJson.version : "0.0.0",
+    type: typeof existingPackageJson.type === "string" ? existingPackageJson.type : "module",
+    scripts: {
+      dev: "vite",
+      build: "tsc -b && vite build",
+      typecheck: "tsc -b",
+      format: "prettier --write .",
+      "format:check": "prettier --check .",
+      preview: "vite preview",
+      ...existingScripts
+    }
+  };
+  if (packageManager && typeof mergedPackageJson.packageManager !== "string") {
+    mergedPackageJson.packageManager = packageManager;
+  }
+  return JSON.stringify(mergedPackageJson, null, 2) + "\n";
+};
+var writePackageJson2 = async (targetDirectory) => {
+  const targetPath = join(targetDirectory, "package.json");
+  if (!await fileExists(targetPath)) {
+    await writeFile(targetPath, getPackageJson2(targetDirectory), "utf-8");
+    console.log(`Created scaffold file: ${targetPath}`);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(targetPath, "utf-8"));
+  } catch {
+    throw new Error(`Invalid existing package.json: ${targetPath}`);
+  }
+  const content = await readFile(targetPath, "utf-8");
+  const mergedContent = mergePackageJson2(targetDirectory, parsed);
+  if (content === mergedContent) {
+    console.log(`Skipped package.json: ${targetPath} already configured`);
+    return;
+  }
+  await writeFile(targetPath, mergedContent, "utf-8");
+  console.log(`Updated package.json: ${targetPath}`);
+};
+var writeScaffoldFile2 = async (targetPath, content, options = {}) => {
+  if (await fileExists(targetPath)) {
+    const existingContent = await readFile(targetPath, "utf-8");
+    if (existingContent === content) {
+      console.log(`Skipped identical scaffold file: ${targetPath}`);
+      return;
+    }
+    if (options.allowExisting) {
+      console.log(`Skipped existing scaffold file: ${targetPath}`);
+      return;
+    }
+    throw new Error(
+      `Refusing to overwrite existing scaffold file: ${targetPath}`
+    );
+  }
+  await mkdir(dirname(targetPath), { recursive: true });
+  await writeFile(targetPath, content, "utf-8");
+  console.log(`Created scaffold file: ${targetPath}`);
+};
+var scaffoldViteProject = async (targetDirectory) => {
+  await mkdir(targetDirectory, { recursive: true });
+  await writePackageJson2(targetDirectory);
+  await writeScaffoldFile2(join(targetDirectory, ".gitignore"), gitIgnore2, {
+    allowExisting: true
+  });
+  await writeScaffoldFile2(
+    join(targetDirectory, ".prettierignore"),
+    prettierIgnore2,
+    {
+      allowExisting: true
+    }
+  );
+  await writeScaffoldFile2(
+    join(targetDirectory, ".prettierrc"),
+    prettierConfig2,
+    {
+      allowExisting: true
+    }
+  );
+  await writeScaffoldFile2(join(targetDirectory, "index.html"), indexHtml);
+  await writeScaffoldFile2(join(targetDirectory, "tsconfig.json"), tsConfig2);
+  await writeScaffoldFile2(
+    join(targetDirectory, "tsconfig.app.json"),
+    tsConfigApp
+  );
+  await writeScaffoldFile2(
+    join(targetDirectory, "tsconfig.node.json"),
+    tsConfigNode
+  );
+  await writeScaffoldFile2(join(targetDirectory, "vite.config.ts"), viteConfig, {
+    allowExisting: true
+  });
+  await writeScaffoldFile2(join(targetDirectory, "src", "main.tsx"), mainTsx);
+  await writeScaffoldFile2(join(targetDirectory, "src", "App.tsx"), appTsx);
+  await writeScaffoldFile2(join(targetDirectory, "src", "style.css"), styleCss, {
+    allowExisting: true
+  });
+};
+
+// src/commands/init.ts
+var tailwindViteDependencies = ["tailwindcss", "@tailwindcss/vite"];
+var tailwindNextDependencies = ["tailwindcss", "@tailwindcss/postcss"];
+var viteDependencies = ["react", "react-dom"];
+var viteDevDependencies = [
+  "@types/react",
+  "@types/react-dom",
+  "@types/node",
+  "@vitejs/plugin-react",
+  "prettier",
+  "typescript",
+  "vite"
+];
+var nextDependencies = ["react", "react-dom", `next@${NEXT_VERSION}`];
+var nextDevDependencies = [
+  "@types/node",
+  "@types/react",
+  "@types/react-dom",
+  "prettier",
+  "typescript"
+];
+var nextConfigFiles = ["next.config.ts", "next.config.mjs", "next.config.js"];
+var packageJsonHasDependency = (packageJson, dependencyName) => {
+  const dependencies = typeof packageJson.dependencies === "object" && packageJson.dependencies !== null ? packageJson.dependencies : {};
+  const devDependencies = typeof packageJson.devDependencies === "object" && packageJson.devDependencies !== null ? packageJson.devDependencies : {};
+  return dependencyName in dependencies || dependencyName in devDependencies;
+};
+var hasNextScaffold = async () => {
+  for (const configFile of nextConfigFiles) {
+    if (await fileExists(resolve(getCwd(), configFile))) {
+      return true;
+    }
+  }
+  const packageJsonPath2 = resolve(getCwd(), "package.json");
+  if (!await fileExists(packageJsonPath2)) {
+    return false;
+  }
+  const packageJson = JSON.parse(
+    await readFile(packageJsonPath2, "utf-8")
+  );
+  return packageJsonHasDependency(packageJson, "next");
+};
+var runLexsysInit = async () => {
+  console.log("Initializing Lexsys...\n");
+  const config = await loadConfig();
+  const usesNext = await hasNextScaffold();
+  if (usesNext && config.tailwind.css === "src/style.css") {
+    config.tailwind.css = "app/globals.css";
+  }
+  await ensureProjectStructure(config);
+  await installDependencies(
+    usesNext ? tailwindNextDependencies : tailwindViteDependencies,
+    { dev: true }
+  );
+  await ensureTailwindCssImport(config);
+  if (usesNext) {
+    await ensureNextPostCssConfig();
+  } else {
+    await ensureViteTailwindPlugin();
+    await ensureViteSrcAlias();
+  }
+  await ensureTypeScriptSrcAlias();
+  await saveConfig(config);
+  console.log("\nDone.");
+};
+var runViteInit = async (args2) => {
+  if (args2.length > 1) {
+    throw new CliError("Usage: lexsys init vite [directory]");
+  }
+  const targetDirectory = resolve(getCwd(), args2[0] ?? ".");
+  setCwd(targetDirectory);
+  console.log(`Initializing Vite project at ${targetDirectory}...
+`);
+  await scaffoldViteProject(targetDirectory);
+  await installDependencies(viteDependencies);
+  await installDependencies(viteDevDependencies, { dev: true });
+  await runLexsysInit();
+};
+var runNextInit = async (args2) => {
+  if (args2.length > 1) {
+    throw new CliError("Usage: lexsys init next [directory]");
+  }
+  const targetDirectory = resolve(getCwd(), args2[0] ?? ".");
+  setCwd(targetDirectory);
+  console.log(`Initializing Next.js project at ${targetDirectory}...
+`);
+  await scaffoldNextProject(targetDirectory);
+  await installDependencies(nextDependencies);
+  await installDependencies(nextDevDependencies, { dev: true });
+  await runLexsysInit();
+};
+var promptFrameworkInit = async () => {
+  const response = await prompts([
+    {
+      type: "select",
+      name: "framework",
+      message: "What would you like to create?",
+      choices: [
+        { title: "Vite React app", value: "vite" },
+        { title: "Next.js App Router app", value: "next" }
+      ]
+    },
+    {
+      type: "text",
+      name: "dir",
+      message: "Project name",
+      initial: "my-app"
+    }
+  ]);
+  if (typeof response !== "object" || response === null) {
+    return;
+  }
+  const framework = "framework" in response && typeof response.framework === "string" ? response.framework : void 0;
+  if (!framework) return;
+  const dir = "dir" in response && typeof response.dir === "string" && response.dir ? [response.dir] : [];
+  if (framework === "vite") {
+    await runViteInit(dir);
+    return;
+  }
+  if (framework === "next") {
+    await runNextInit(dir);
+    return;
+  }
+};
+var hasViteScaffold = async () => {
+  for (const configFile of [
+    "vite.config.ts",
+    "vite.config.js",
+    "vite.config.mts"
+  ]) {
+    if (await fileExists(resolve(getCwd(), configFile))) return true;
+  }
+  return false;
+};
+var runInit = async (args2 = []) => {
+  const positionalArgs = removeFlagsWithValues(args2, ["--cwd"]);
+  const [framework, ...frameworkArgs] = positionalArgs;
+  if (!framework) {
+    if (await hasNextScaffold() || await hasViteScaffold()) {
+      await runLexsysInit();
+      return;
+    }
+    await promptFrameworkInit();
+    return;
+  }
+  if (framework === "vite") {
+    await runViteInit(frameworkArgs);
+    return;
+  }
+  if (framework === "next") {
+    await runNextInit(frameworkArgs);
+    return;
+  }
+  throw new CliError(`Unsupported init target: ${framework}`);
+};
+var layerLabels = {
+  block: "Blocks",
+  primitive: "Primitives",
+  template: "Templates"
+};
+var runList = async (options = {}) => {
+  try {
+    const registryItems3 = await getRegistryItems({
+      fallback: !options.noFallback
+    });
+    if (options.json) {
+      const simplified = registryItems3.map((item) => ({
+        name: item.name,
+        canonicalName: item.canonicalName,
+        version: item.version,
+        category: item.category,
+        layer: getInstallLayer(item)
+      }));
+      console.log(JSON.stringify(simplified, null, 2));
+      return;
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const item of registryItems3) {
+      const layer = getInstallLayer(item) ?? "other";
+      const current = grouped.get(layer) ?? [];
+      current.push(item);
+      grouped.set(layer, current);
+    }
+    console.log("Available Lexsys registry items:\n");
+    for (const layer of ["primitive", "block", "template"]) {
+      const items = grouped.get(layer);
+      if (!items?.length) {
+        continue;
+      }
+      console.log(`${layerLabels[layer] ?? layer}:`);
+      for (const item of items) {
+        console.log(
+          `- ${item.canonicalName} v${item.version} (${item.category})`
+        );
+      }
+      console.log("");
+    }
+  } catch (error) {
+    console.log("Failed to resolve registry.");
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+};
+var localRegistryResult = {
+  items: registryItems,
+  source: "local",
+  fallbackUsed: false,
+  manifestVersion: registryManifest.version
+};
+var printRegistrySummary = (result) => {
+  console.log("Lexsys registry summary\n");
+  console.log(`Registry source: ${result.source}`);
+  console.log(`Fallback used: ${result.fallbackUsed ? "yes" : "no"}`);
+  console.log(`Items: ${result.items.length}`);
+  for (const item of result.items) {
+    const remoteFileCount = item.remoteFiles?.length ?? 0;
+    console.log(
+      `- ${item.canonicalName} v${item.version} (${item.type}/${item.category}, remote files: ${remoteFileCount})`
+    );
+  }
+};
+var printRegistryJson = (result) => {
+  console.log(
+    JSON.stringify(
+      {
+        version: result.manifestVersion,
+        source: result.source,
+        fallbackUsed: result.fallbackUsed,
+        items: result.items
+      },
+      null,
+      2
+    )
+  );
+};
+var getRemoteRegistryResult = async (source) => {
+  const remote = await fetchRemoteRegistry(source);
+  validateRegistry(
+    remote.items,
+    remote.styles !== void 0 ? {
+      styles: remote.styles
+    } : {}
+  );
+  return {
+    items: remote.items,
+    source,
+    fallbackUsed: false,
+    manifestVersion: remote.version
+  };
+};
+var runRegistry = async (options = {}) => {
+  const fallback = !options.noFallback;
+  try {
+    if (options.local) {
+      if (options.source) {
+        console.log(localRegistryResult.source);
+        return;
+      }
+      if (options.summary) {
+        printRegistrySummary(localRegistryResult);
+        return;
+      }
+      console.log(JSON.stringify(registryManifest, null, 2));
+      return;
+    }
+    if (options.remote) {
+      const source = await getRegistrySource();
+      if (source === "local") {
+        console.log("No remote registry URL configured.");
+        return;
+      }
+      const result2 = await getRemoteRegistryResult(source);
+      if (options.source) {
+        console.log(result2.source);
+        return;
+      }
+      if (options.summary) {
+        printRegistrySummary(result2);
+        return;
+      }
+      printRegistryJson(result2);
+      return;
+    }
+    const result = await getRegistryProviderResult({ fallback });
+    if (options.source) {
+      if (result.fallbackUsed) {
+        console.log(`${result.source} (fallback: local)`);
+        return;
+      }
+      console.log(result.source);
+      return;
+    }
+    if (options.summary) {
+      printRegistrySummary(result);
+      return;
+    }
+    printRegistryJson(result);
+  } catch (error) {
+    console.log("Failed to resolve registry.");
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+};
+
+// src/commands/status.ts
+var runStatus = async (options = {}) => {
+  const config = await loadConfig();
+  const installed = config.installed ?? {};
+  if (!Object.keys(installed).length) {
+    console.log("No Lexsys components are currently tracked.");
+    return;
+  }
+  try {
+    await getRegistryProviderResult({
+      fallback: !options.noFallback
+    });
+  } catch (error) {
+    console.log("Failed to resolve registry.");
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return;
+  }
+  console.log("Installed Lexsys components:\n");
+  for (const [name, installedVersion] of Object.entries(installed)) {
+    const item = await findItem(name);
+    if (!item) {
+      console.log(`- ${name} v${installedVersion} (missing from registry)`);
+      continue;
+    }
+    const status = item.version === installedVersion ? "up to date" : `update available: v${installedVersion} \u2192 v${item.version}`;
+    console.log(`- ${item.canonicalName} v${installedVersion} (${status})`);
+  }
+};
+
+// src/registry/closure.ts
+var computeRegistryClosure = (rootNames, items) => {
+  const closure = /* @__PURE__ */ new Set();
+  const visit = (name) => {
+    const item = items.find(
+      (registryItem) => registryItem.name.toLowerCase() === name.toLowerCase()
+    );
+    if (!item || closure.has(item.name)) {
+      return;
+    }
+    closure.add(item.name);
+    for (const dependency of item.registryDependencies) {
+      visit(dependency);
+    }
+  };
+  for (const name of rootNames) {
+    visit(name);
+  }
+  return closure;
+};
+var findOrphanInstalledItems = (removedTargetNames, remainingInstalled, items) => {
+  const remainingNames = Object.keys(remainingInstalled);
+  const removedDependencyNames = /* @__PURE__ */ new Set();
+  for (const removedName of removedTargetNames) {
+    const closure = computeRegistryClosure([removedName], items);
+    for (const name of closure) {
+      const isRemovedTarget = removedTargetNames.some((targetName) => {
+        return targetName.toLowerCase() === name.toLowerCase();
+      });
+      if (!isRemovedTarget) {
+        removedDependencyNames.add(name);
+      }
+    }
+  }
+  return remainingNames.map(
+    (name) => items.find(
+      (registryItem) => registryItem.name.toLowerCase() === name.toLowerCase()
+    )
+  ).filter((item) => Boolean(item)).filter((item) => removedDependencyNames.has(item.name));
+};
+
+// src/commands/uninstall.ts
+var normalizeInstalledKey = (name) => {
+  return name.toLowerCase();
+};
+var resolveInstalledItems = async (installed) => {
+  const names = Object.keys(installed);
+  if (!names.length) {
+    return [];
+  }
+  return resolveRegistryItems(names);
+};
+var collectOrphanedSharedResources = (removedItems, remainingItems) => {
+  const removedUtilities = collectUtilities(removedItems);
+  const removedStyles = collectStyles(removedItems);
+  const remainingUtilities = new Set(collectUtilities(remainingItems));
+  const remainingStyles = new Set(collectStyles(remainingItems));
+  return {
+    utilities: removedUtilities.filter((utility) => {
+      return !remainingUtilities.has(utility);
+    }),
+    styles: removedStyles.filter((style) => {
+      return !remainingStyles.has(style);
+    })
+  };
+};
+var removeInstalledKey = (installed, itemName) => {
+  const installedKey = Object.keys(installed).find((key) => {
+    return normalizeInstalledKey(key) === normalizeInstalledKey(itemName);
+  });
+  if (installedKey) {
+    delete installed[installedKey];
+  }
+};
+var runUninstall = async (args2) => {
+  const dryRun = hasFlag(args2, "--dry-run", "-d");
+  const withDeps = hasFlag(args2, "--with-deps", "-w");
+  const noFallback = hasFlag(args2, "--no-fallback");
+  const targetArgs = removeFlagsWithValues(
+    removeFlags(args2, [
+      "--dry-run",
+      "-d",
+      "--with-deps",
+      "-w",
+      "--no-fallback"
+    ]),
+    ["--cwd", "-C"]
+  );
+  if (!targetArgs.length) {
+    const preConfig = await loadConfig();
+    const installedNames = Object.keys(preConfig.installed ?? {});
+    if (installedNames.length === 0) {
+      console.log("No components installed.");
+      return;
+    }
+    const response = await prompts({
+      type: "multiselect",
+      name: "components",
+      message: "Select components to uninstall",
+      choices: installedNames.map((name) => ({ title: name, value: name })),
+      min: 1
+    });
+    const selected = response.components;
+    if (!Array.isArray(selected) || !selected.length) return;
+    targetArgs.push(
+      ...selected.filter((c) => typeof c === "string")
+    );
+  }
+  const config = await loadConfig();
+  const installed = config.installed ?? {};
+  const resolvedTargets = [];
+  const notTracked = [];
+  for (const name of targetArgs) {
+    const item = await findItem(name, { fallback: !noFallback });
+    if (!item) {
+      console.log(`Component "${name}" not found in registry.`);
+      continue;
+    }
+    const installedKey = Object.keys(installed).find((key) => {
+      return normalizeInstalledKey(key) === normalizeInstalledKey(item.name);
+    });
+    if (!installedKey) {
+      notTracked.push(name);
+      console.log(`Component "${name}" is not tracked as installed.`);
+      continue;
+    }
+    resolvedTargets.push(item);
+  }
+  if (!resolvedTargets.length) {
+    if (!notTracked.length) {
+      console.log("No installed components matched the request.");
+    }
+    return;
+  }
+  const remainingInstalled = { ...installed };
+  for (const item of resolvedTargets) {
+    removeInstalledKey(remainingInstalled, item.name);
+  }
+  const allItems = await getRegistryItems({ fallback: !noFallback });
+  const orphanItems = withDeps ? findOrphanInstalledItems(
+    resolvedTargets.map((item) => item.name),
+    remainingInstalled,
+    allItems
+  ) : findOrphanInstalledItems(
+    resolvedTargets.map((item) => item.name),
+    remainingInstalled,
+    allItems
+  );
+  const orphanHints = withDeps ? [] : orphanItems;
+  const allRemovalTargets = [
+    ...resolvedTargets,
+    ...withDeps ? orphanItems : []
+  ].filter((item, index, array) => {
+    return array.findIndex((entry) => entry.name === item.name) === index;
+  });
+  if (dryRun) {
+    console.log("Dry run: no files will be removed.\n");
+    console.log("Components:");
+    for (const item of resolvedTargets) {
+      console.log(
+        `- ${item.canonicalName} v${installed[item.name] ?? "unknown"}`
+      );
+    }
+    if (withDeps && orphanItems.length) {
+      console.log("\nOrphan registry items (--with-deps):");
+      for (const item of orphanItems) {
+        console.log(`- ${item.canonicalName}`);
+      }
+    }
+    if (!withDeps && orphanHints.length) {
+      console.log(
+        "\nPossible orphan registry items (use --with-deps to remove):"
+      );
+      for (const item of orphanHints) {
+        console.log(`- ${item.canonicalName}`);
+      }
+    }
+    const postOrphanRemaining = { ...remainingInstalled };
+    for (const item of withDeps ? orphanItems : []) {
+      removeInstalledKey(postOrphanRemaining, item.name);
+    }
+    const dryRunOrphans = collectOrphanedSharedResources(
+      allRemovalTargets,
+      await resolveInstalledItems(postOrphanRemaining)
+    );
+    console.log(
+      "\nDependencies (npm packages are never removed automatically):"
+    );
+    for (const dependency of collectDependencies(resolvedTargets)) {
+      console.log(`- ${dependency}`);
+    }
+    console.log("\nShared resources eligible for removal:");
+    for (const utility of dryRunOrphans.utilities) {
+      console.log(`- utility: ${utility}`);
+    }
+    for (const style of dryRunOrphans.styles) {
+      console.log(`- style: ${style}`);
+    }
+    return;
+  }
+  const itemResults = [];
+  const successfullyUninstalled = [];
+  for (const item of allRemovalTargets) {
+    const itemResult = await uninstallItemFiles(item, config);
+    itemResults.push(itemResult);
+    if (hasUninstallConflicts(itemResult)) {
+      console.log(
+        `${item.canonicalName} remains tracked because modified files were left in place.`
+      );
+    } else {
+      successfullyUninstalled.push(item);
+    }
+    console.log("");
+  }
+  const postUninstallInstalled = { ...installed };
+  for (const item of successfullyUninstalled) {
+    removeInstalledKey(postUninstallInstalled, item.name);
+  }
+  const remainingItems = await resolveInstalledItems(postUninstallInstalled);
+  const orphanedResources = collectOrphanedSharedResources(
+    successfullyUninstalled,
+    remainingItems
+  );
+  let resolvedUtilities = [];
+  let resolvedStyles = [];
+  if (orphanedResources.utilities.length || orphanedResources.styles.length) {
+    try {
+      resolvedUtilities = resolveRegistryUtilities(orphanedResources.utilities);
+      resolvedStyles = resolveRegistryStyles(orphanedResources.styles);
+    } catch (error) {
+      console.log("Failed to resolve registry shared resources.");
+      console.log(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const utilitiesResult = await uninstallUtilities(resolvedUtilities, config);
+  const stylesResult = await uninstallStyles(resolvedStyles, config);
+  const updatedInstalled = {
+    ...installed
+  };
+  for (const item of successfullyUninstalled) {
+    removeInstalledKey(updatedInstalled, item.name);
+  }
+  await saveConfig({
+    ...config,
+    installed: updatedInstalled
+  });
+  const itemSummary = mergeUninstallResults(itemResults);
+  const sharedSummary = mergeUninstallResults([utilitiesResult, stylesResult]);
+  console.log("Uninstall summary:");
+  printUninstallSummary("components", itemSummary);
+  printUninstallSummary("shared resources", sharedSummary);
+  console.log(
+    `- untracked components: ${successfullyUninstalled.length}/${allRemovalTargets.length}`
+  );
+  if (hasUninstallConflicts(mergeUninstallResults([itemSummary, sharedSummary]))) {
+    console.log(
+      "Some files were left in place because they differ from registry templates."
+    );
+  }
+};
+
+// src/utils/version.ts
+var compareVersions = (a, b) => {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  const length = Math.max(pa.length, pb.length);
+  for (let i = 0; i < length; i++) {
+    const va = pa[i] ?? 0;
+    const vb = pb[i] ?? 0;
+    if (va > vb) return 1;
+    if (va < vb) return -1;
+  }
+  return 0;
+};
+var isUpdateAvailable = (installed, latest) => {
+  return compareVersions(latest, installed) === 1;
+};
+
+// src/install/update-engine.ts
+var checkItemFiles = async (name) => {
+  const item = await findItem(name);
+  const config = await loadConfig();
+  if (!item) {
+    console.log(`Component "${name}" no longer exists in the registry.`);
+    return;
+  }
+  const installTarget = resolveItemInstallTarget(config, item);
+  console.log(`File check for ${item.canonicalName}:`);
+  for (const file of item.files) {
+    const fileName = file.split("/").at(-1);
+    if (!fileName) {
+      console.log(`- invalid registry file path: ${file}`);
+      continue;
+    }
+    const targetPath = join(getCwd(), installTarget, fileName);
+    if (!await fileExists(targetPath)) {
+      console.log(`- missing: ${targetPath}`);
+      continue;
+    }
+    const preparedContent = prepareInstalledFileContent(
+      await readFile(getRegistryTemplatePath(file), "utf-8"),
+      item
+    );
+    const targetContent = await readFile(targetPath, "utf-8");
+    if (hashesAreEqual(preparedContent, targetContent)) {
+      console.log(`- identical: ${targetPath}`);
+      continue;
+    }
+    console.log(`- conflict: ${targetPath}`);
+  }
+};
+var applySafeItemUpdate = async (name, force) => {
+  const item = await findItem(name);
+  const config = await loadConfig();
+  if (!item) {
+    console.log(`Component "${name}" no longer exists in the registry.`);
+    return false;
+  }
+  const installTarget = resolveItemInstallTarget(config, item);
+  let hasConflict = false;
+  console.log(`Applying update for ${item.canonicalName}:`);
+  for (const file of item.files) {
+    const sourcePath = getRegistryTemplatePath(file);
+    const fileName = file.split("/").at(-1);
+    if (!fileName) {
+      console.log(`- invalid registry file path: ${file}`);
+      hasConflict = true;
+      continue;
+    }
+    const targetPath = join(getCwd(), installTarget, fileName);
+    const preparedContent = prepareInstalledFileContent(
+      await readFile(sourcePath, "utf-8"),
+      item
+    );
+    await mkdir(dirname(targetPath), { recursive: true });
+    if (!await fileExists(targetPath)) {
+      await writeFile(targetPath, preparedContent, "utf-8");
+      console.log(`- restored missing file: ${targetPath}`);
+      continue;
+    }
+    const targetContent = await readFile(targetPath, "utf-8");
+    if (hashesAreEqual(preparedContent, targetContent)) {
+      console.log(`- identical: ${targetPath}`);
+      continue;
+    }
+    if (force) {
+      const backupPath = await createBackupFile(targetPath);
+      if (backupPath) {
+        console.log(`- backup created: ${backupPath}`);
+      }
+      await writeFile(targetPath, preparedContent, "utf-8");
+      console.log(`- force updated file: ${targetPath}`);
+      continue;
+    }
+    hasConflict = true;
+    console.log(`- conflict (user modified): ${targetPath}`);
+  }
+  if (hasConflict) {
+    console.log(
+      "Update finished with conflicts. Installed version was not changed."
+    );
+    return false;
+  }
+  console.log(
+    `\u2714 ${item.canonicalName} updated successfully to v${item.version}`
+  );
+  return true;
+};
+var checkItemUpdate = async (name, installedVersion, dryRun, force, sync = false) => {
+  const item = await findItem(name);
+  if (!item) {
+    console.log(`Component "${name}" no longer exists in the registry.`);
+    return false;
+  }
+  const versionUpdateAvailable = isUpdateAvailable(
+    installedVersion,
+    item.version
+  );
+  if (!sync && !versionUpdateAvailable) {
+    console.log(`${item.canonicalName} is up to date (v${installedVersion}).`);
+    return false;
+  }
+  if (sync && !versionUpdateAvailable) {
+    console.log(
+      `${item.canonicalName} template sync (installed v${installedVersion}, registry v${item.version})`
+    );
+  } else {
+    console.log(
+      `${item.canonicalName} can be updated: v${installedVersion} \u2192 v${item.version}`
+    );
+  }
+  if (dryRun) {
+    console.log("\nChanged file candidates:");
+    for (const file of item.files) {
+      console.log(`~ ${file}`);
+    }
+    console.log("\nDry run: no files will be changed.");
+    console.log("Update plan:");
+    if (force) {
+      console.log(
+        "- Force mode requested: conflicted files require backup before overwrite"
+      );
+      console.log(
+        "- Dry run: backups would be created before forced overwrites"
+      );
+    }
+    console.log(`- Check installed files for ${item.canonicalName}`);
+    console.log("- Compare existing files with registry templates");
+    console.log("- Report conflicts before writing changes");
+    console.log("- Never overwrite user-modified files silently");
+    await checkItemFiles(name);
+    return false;
+  }
+  return await applySafeItemUpdate(name, force);
+};
+
+// src/commands/update.ts
+var styleUpdateNames = ["theme"];
+var resolveInstalledKey = async (name, installed) => {
+  if (installed[name]) {
+    return name;
+  }
+  const item = await findItem(name);
+  if (!item) {
+    return void 0;
+  }
+  return installed[item.name] ? item.name : void 0;
+};
+var runStylesUpdate = async (config, dryRun) => {
+  const styles = resolveRegistryStyles(styleUpdateNames);
+  if (dryRun) {
+    console.log("Dry run: no style files will be changed.\n");
+    console.log("Styles:");
+    for (const style of styles) {
+      console.log(`- ${style.name} v${style.version}`);
+      for (const file of style.files) {
+        console.log(`  ~ ${config.paths.styles}/${file.target}`);
+      }
+    }
+    console.log(`
+Tailwind CSS entrypoint: ${config.tailwind.css}`);
+    return;
+  }
+  const result = await installStyles(styles, config);
+  console.log("Style update summary:");
+  printResourceSummary("styles", result);
+  if (hasInstallConflicts(result)) {
+    console.log(
+      "Style conflicts were left untouched. Review them before relying on the generated theme output."
+    );
+  }
+};
+var runUtilitiesUpdate = async (config, installed, dryRun, force) => {
+  const installedItems = (await Promise.all(
+    Object.keys(installed).map(async (name) => findItem(name))
+  )).filter((item) => Boolean(item));
+  const utilityNames = collectUtilities(installedItems);
+  if (!utilityNames.length) {
+    console.log("No shared utilities are tracked for installed components.");
+    return;
+  }
+  const utilities = resolveRegistryUtilities(utilityNames);
+  if (dryRun) {
+    console.log("Dry run: no utility files will be changed.\n");
+    console.log("Utilities:");
+    for (const utility of utilities) {
+      console.log(`- ${utility.name}`);
+      console.log(`  ~ ${config.paths.utilities}/${utility.target}`);
+    }
+    return;
+  }
+  const result = await updateUtilities(utilities, config, force);
+  console.log("Utility update summary:");
+  printResourceSummary("utilities", result);
+  if (hasInstallConflicts(result)) {
+    console.log(
+      "Utility conflicts were left untouched. Re-run with --force to overwrite after creating backups."
+    );
+  }
+};
+var runComponentUpdates = async (config, installed, targetNames, dryRun, force, sync) => {
+  let changed = false;
+  if (!Object.keys(installed).length) {
+    console.log("No Lexsys components are currently tracked.");
+    return false;
+  }
+  console.log("Checking installed Lexsys components:\n");
+  for (const name of targetNames) {
+    const version = installed[name];
+    if (!version) {
+      continue;
+    }
+    const didUpdate = await checkItemUpdate(name, version, dryRun, force, sync);
+    const item = await findItem(name);
+    if (didUpdate && item) {
+      installed[name] = item.version;
+      changed = true;
+    }
+  }
+  return changed;
+};
+var runUpdate = async (args2) => {
+  const dryRun = hasFlag(args2, "--dry-run", "-d");
+  const force = hasFlag(args2, "--force", "-f");
+  const yes = hasFlag(args2, "--yes", "-y");
+  const noFallback = hasFlag(args2, "--no-fallback");
+  const sync = hasFlag(args2, "--sync");
+  const stylesFlag = hasFlag(args2, "--styles", "-S");
+  const utilitiesFlag = hasFlag(args2, "--utilities", "-u");
+  const updateAll = hasFlag(args2, "--all", "-a");
+  const targetArgs = removeFlags(removeFlagsWithValues(args2, ["--cwd", "-C"]), [
+    "--dry-run",
+    "-d",
+    "--force",
+    "-f",
+    "--yes",
+    "-y",
+    "--no-fallback",
+    "--styles",
+    "-S",
+    "--sync",
+    "--utilities",
+    "-u",
+    "--all",
+    "-a"
+  ]);
+  const config = await loadConfig();
+  const installed = { ...config.installed ?? {} };
+  try {
+    await getRegistryProviderResult({
+      fallback: !noFallback
+    });
+  } catch (error) {
+    console.log("Failed to resolve registry.");
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return;
+  }
+  if (yes) {
+    console.log("Auto-confirm mode is enabled.");
+  }
+  if (!updateAll && !stylesFlag && !utilitiesFlag && targetArgs.length === 0) {
+    const installedNames = Object.keys(installed);
+    if (installedNames.length === 0) {
+      console.log(
+        "No components installed. Run `lexsys add <component>` first."
+      );
+      return;
+    }
+    const response = await prompts({
+      type: "multiselect",
+      name: "components",
+      message: "Select components to update",
+      choices: installedNames.map((name) => ({ title: name, value: name })),
+      min: 1
+    });
+    const selected = response.components;
+    if (!Array.isArray(selected) || !selected.length) return;
+    targetArgs.push(
+      ...selected.filter((c) => typeof c === "string")
+    );
+  }
+  const shouldUpdateComponents = updateAll || targetArgs.length > 0;
+  const resourcesOnly = (stylesFlag || utilitiesFlag) && !shouldUpdateComponents;
+  if (resourcesOnly) {
+    if (stylesFlag) {
+      await runStylesUpdate(config, dryRun);
+    }
+    if (utilitiesFlag) {
+      await runUtilitiesUpdate(config, installed, dryRun, force);
+    }
+    return;
+  }
+  if (stylesFlag) {
+    await runStylesUpdate(config, dryRun);
+  }
+  if (utilitiesFlag) {
+    await runUtilitiesUpdate(config, installed, dryRun, force);
+  }
+  if (!shouldUpdateComponents) {
+    return;
+  }
+  let changed = false;
+  if (updateAll) {
+    changed = await runComponentUpdates(
+      config,
+      installed,
+      Object.keys(installed),
+      dryRun,
+      force,
+      sync
+    );
+  } else {
+    for (const name of targetArgs) {
+      const installedKey = await resolveInstalledKey(name, installed);
+      if (!installedKey) {
+        console.log(`Component "${name}" is not tracked as installed.`);
+        continue;
+      }
+      const didUpdateOne = await runComponentUpdates(
+        config,
+        installed,
+        [installedKey],
+        dryRun,
+        force,
+        sync
+      );
+      if (didUpdateOne) {
+        changed = true;
+      }
+    }
+  }
+  if (changed) {
+    await saveConfig({
+      ...config,
+      installed
+    });
+  }
+};
+var cliDistDir = dirname(fileURLToPath(import.meta.url));
+var packageJsonPath = join(cliDistDir, "..", "package.json");
+var runVersion = async () => {
+  const content = await readFile(packageJsonPath, "utf-8");
+  const packageJson = JSON.parse(content);
+  console.log(`lexsys ${packageJson.version ?? "unknown"}`);
+};
+
+// src/index.ts
+var [, , command, ...args] = process.argv;
+var cwd = getFlagValue(args, "--cwd", "-C");
+if (cwd) {
+  setCwd(cwd);
+}
+try {
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    runHelp();
+    process.exit(0);
+  }
+  if (command === "version" || command === "--version" || command === "-v") {
+    await runVersion();
+    process.exit(0);
+  }
+  if (command === "list" || command === "ls") {
+    if (hasFlag(args, "--help", "-h")) {
+      runHelpFor("list");
+      process.exit(0);
+    }
+    await runList({
+      json: hasFlag(args, "--json", "-j"),
+      noFallback: args.includes("--no-fallback")
+    });
+    process.exit(0);
+  }
+  if (command === "doctor" || command === "dr") {
+    if (hasFlag(args, "--help", "-h")) {
+      runHelpFor("doctor");
+      process.exit(0);
+    }
+    await runDoctor({
+      noFallback: args.includes("--no-fallback")
+    });
+    process.exit(0);
+  }
+  if (command === "init" || command === "create") {
+    if (hasFlag(args, "--help", "-h")) {
+      runHelpFor("init");
+      process.exit(0);
+    }
+    await runInit(args);
+    process.exit(0);
+  }
+  if (command === "add" || command === "a") {
+    if (hasFlag(args, "--help", "-h")) {
+      runHelpFor("add");
+      process.exit(0);
+    }
+    await runAdd(args);
+    process.exit(0);
+  }
+  if (command === "update" || command === "up") {
+    if (hasFlag(args, "--help", "-h")) {
+      runHelpFor("update");
+      process.exit(0);
+    }
+    await runUpdate(args);
+    process.exit(0);
+  }
+  if (command === "status" || command === "st") {
+    if (hasFlag(args, "--help", "-h")) {
+      runHelpFor("status");
+      process.exit(0);
+    }
+    await runStatus({
+      noFallback: args.includes("--no-fallback")
+    });
+    process.exit(0);
+  }
+  if (command === "registry" || command === "reg") {
+    if (hasFlag(args, "--help", "-h")) {
+      runHelpFor("registry");
+      process.exit(0);
+    }
+    await runRegistry({
+      summary: hasFlag(args, "--summary", "-s"),
+      source: args.includes("--source"),
+      local: hasFlag(args, "--local", "-l"),
+      remote: hasFlag(args, "--remote", "-r"),
+      noFallback: args.includes("--no-fallback")
+    });
+    process.exit(0);
+  }
+  if (command === "config" || command === "cfg") {
+    if (hasFlag(args, "--help", "-h")) {
+      runHelpFor("config");
+      process.exit(0);
+    }
+    await runConfig({
+      path: args.includes("--path") || args.includes("-p"),
+      exists: args.includes("--exists") || args.includes("-e"),
+      setRegistryUrl: getFlagValue(args, "--set-registry-url"),
+      clearRegistryUrl: args.includes("--clear-registry-url")
+    });
+    process.exit(0);
+  }
+  if (command === "uninstall" || command === "rm") {
+    if (hasFlag(args, "--help", "-h")) {
+      runHelpFor("uninstall");
+      process.exit(0);
+    }
+    await runUninstall(args);
+    process.exit(0);
+  }
+  throw new CliError(`Unknown command: ${command}`);
+} catch (error) {
+  handleCliError(error);
+}
+runHelp();
+process.exit(1);