@shokirovr16/frontend-library 0.1.2

package/src/commands/status.js

@@ -0,0 +1,96 @@
+import pc from 'picocolors';
+import semver from 'semver';
+import { configExists, loadConfig } from '../lib/config.js';
+import { readRegistry } from '../lib/registry.js';
+
+const { green, yellow, red } = pc;
+
+function coerceVersion(version) {
+  const coerced = semver.coerce(String(version ?? ''));
+  return coerced?.version ?? '0.0.0';
+}
+
+function isUpdateAvailable(installedVersion, latestVersion) {
+  const installed = coerceVersion(installedVersion);
+  const latest = coerceVersion(latestVersion);
+  return semver.gt(latest, installed);
+}
+
+export default async function statusCommand(options = {}) {
+  if (!(await configExists())) {
+    console.error(red('cmfrt.json is missing. Run cmfrt init first.'));
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    const config = await loadConfig();
+    const registry = await readRegistry();
+    const installed = config.installed ?? {};
+
+    const items = Object.entries(installed).map(([name, entry]) => {
+      const installedVersion = entry?.version ?? '0.0.0';
+      const registryEntry = registry?.[name];
+
+      if (!registryEntry) {
+        return {
+          name,
+          installed: installedVersion,
+          latest: null,
+          status: 'missing',
+        };
+      }
+
+      const latestVersion = registryEntry?.version ?? '0.0.0';
+      const status = isUpdateAvailable(installedVersion, latestVersion) ? 'update' : 'latest';
+
+      return {
+        name,
+        installed: installedVersion,
+        latest: latestVersion,
+        status,
+      };
+    });
+
+    const updatesCount = items.filter((item) => item.status === 'update').length;
+    const missingCount = items.filter((item) => item.status === 'missing').length;
+
+    const filteredItems = options.onlyUpdates
+      ? items.filter((item) => item.status === 'update')
+      : items;
+
+    if (options.json) {
+      const payload = {
+        installedCount: items.length,
+        updatesCount,
+        missingCount,
+        items: filteredItems.map(({ name, installed: installedVersion, latest, status }) => ({
+          name,
+          installed: installedVersion,
+          latest,
+          status,
+        })),
+      };
+
+      console.log(JSON.stringify(payload, null, 2));
+      return;
+    }
+
+    for (const item of filteredItems) {
+      if (item.status === 'missing') {
+        console.log(red(`${item.name} ${item.installed} (missing in registry)`));
+      } else if (item.status === 'update') {
+        console.log(yellow(`${item.name} ${item.installed} -> ${item.latest} (update available)`));
+      } else {
+        console.log(green(`${item.name} ${item.installed} (latest)`));
+      }
+    }
+
+    console.log(
+      `Summary: ${items.length} installed, ${updatesCount} updates available, ${missingCount} missing`
+    );
+  } catch (error) {
+    console.error(red(error?.message ?? 'Failed to load cmfrt status.'));
+    process.exitCode = 1;
+  }
+}

package/src/commands/theme.js

@@ -0,0 +1,47 @@
+import pc from 'picocolors';
+import { configExists, loadConfig, writeConfig } from '../lib/config.js';
+import { applyThemeMode, getAvailableModes, resolveMode } from '../lib/theme.js';
+
+const { green, yellow, red } = pc;
+
+export default async function themeCommand(options = {}) {
+  if (!(await configExists())) {
+    console.error(red('cmfrt.json is missing. Run cmfrt init first.'));
+    process.exitCode = 1;
+    return;
+  }
+
+  const config = await loadConfig();
+  const modes = await getAvailableModes(config);
+
+  if (options.list) {
+    if (!modes.length) {
+      console.log(yellow('No modes found.'));
+      return;
+    }
+    for (const mode of modes) {
+      console.log(`${mode.name}`);
+    }
+    return;
+  }
+
+  if (options.set) {
+    const selected = resolveMode(modes, options.set);
+    if (!selected) {
+      console.error(red('Mode not found. Use `cmfrt theme --list` to see available modes.'));
+      process.exitCode = 1;
+      return;
+    }
+
+    const result = await applyThemeMode(selected.safe);
+    if (result.updated) {
+      await writeConfig({ ...config, themeMode: selected.name });
+      console.log(green(`Theme mode set: ${selected.name}`));
+    } else {
+      console.log(yellow('Theme mode unchanged.'));
+    }
+    return;
+  }
+
+  console.log(yellow('Use `cmfrt theme --list` or `cmfrt theme --set <mode>`'));
+}

package/src/commands/uninstall.js

@@ -0,0 +1,198 @@
+import path from 'path';
+import pc from 'picocolors';
+import prompts from 'prompts';
+import { execa } from 'execa';
+import { configExists, loadConfig, writeConfig } from '../lib/config.js';
+import { readRegistry } from '../lib/registry.js';
+import { pathExists, removePath } from '../lib/fs.js';
+import { componentsDir, projectRoot } from '../lib/paths.js';
+import { resolveTargetRoot } from '../lib/targets.js';
+
+const { green, yellow, red, cyan } = pc;
+
+async function confirmRemoval(message) {
+  const response = await prompts({
+    type: 'confirm',
+    name: 'confirm',
+    message,
+    initial: false,
+  });
+
+  return Boolean(response.confirm);
+}
+
+function resolveComponentsRoot(config) {
+  return config.componentsPath
+    ? path.resolve(projectRoot(), config.componentsPath)
+    : componentsDir();
+}
+
+function shouldSkipUtils(targetPath, config) {
+  if (!config.utilsPath) return false;
+  const utilsPath = path.resolve(projectRoot(), config.utilsPath);
+  return path.resolve(targetPath) === utilsPath;
+}
+
+async function removeInstalledFiles(componentName, installedEntry, config, registry) {
+  const registryEntry = registry?.[componentName];
+  const root = registryEntry
+    ? resolveTargetRoot(registryEntry, config)
+    : resolveComponentsRoot(config);
+
+  for (const file of installedEntry.files ?? []) {
+    const destination = path.resolve(root, file);
+
+    if (shouldSkipUtils(destination, config)) {
+      continue;
+    }
+
+    if (await pathExists(destination)) {
+      await removePath(destination);
+      const relativePath = path.relative(projectRoot(), destination) || destination;
+      console.log(`Deleted: ${relativePath}`);
+    }
+  }
+}
+
+async function pruneDependencies(removedNames, updatedInstalled, registry) {
+  for (const componentName of removedNames) {
+    const entry = registry?.[componentName];
+    if (!entry) {
+      console.log(yellow(`Registry entry for "${componentName}" not found. Skipping prune.`));
+      continue;
+    }
+
+    const dependencies = Array.isArray(entry.dependencies) ? entry.dependencies : [];
+    const otherInstalled = Object.keys(updatedInstalled);
+
+    for (const dependency of dependencies) {
+      let usedElsewhere = false;
+
+      for (const otherName of otherInstalled) {
+        const otherEntry = registry?.[otherName];
+        if (!otherEntry) {
+          usedElsewhere = true;
+          break;
+        }
+        const otherDeps = Array.isArray(otherEntry.dependencies) ? otherEntry.dependencies : [];
+        if (otherDeps.includes(dependency)) {
+          usedElsewhere = true;
+          break;
+        }
+      }
+
+      if (usedElsewhere) {
+        continue;
+      }
+
+      try {
+        console.log(cyan(`Uninstalling: ${dependency}`));
+        await execa('npm', ['uninstall', dependency]);
+        console.log(`Uninstalled: ${dependency}`);
+      } catch (error) {
+        console.error(red(`Failed to uninstall ${dependency}.`));
+        process.exitCode = 1;
+      }
+    }
+  }
+}
+
+export default async function uninstallCommand(componentName, options = {}) {
+  if (!(await configExists())) {
+    console.error(red('cmfrt.json is missing. Run cmfrt init first.'));
+    process.exitCode = 1;
+    return;
+  }
+
+  const config = await loadConfig();
+  const installed = config.installed ?? {};
+  const installedNames = Object.keys(installed);
+
+  if (options.all) {
+    if (!installedNames.length) {
+      console.log(yellow('No installed components to remove.'));
+      return;
+    }
+
+    if (!options.yes) {
+      const confirmed = await confirmRemoval('Remove all installed components and styles?');
+      if (!confirmed) {
+        console.log(yellow('Aborted.'));
+        return;
+      }
+    }
+
+    let registry = null;
+    try {
+      registry = await readRegistry();
+    } catch {
+      registry = null;
+    }
+
+    console.log('Removing all installed components...');
+    for (const name of installedNames) {
+      await removeInstalledFiles(name, installed[name], config, registry);
+    }
+
+    const updatedConfig = { ...config, installed: {} };
+    await writeConfig(updatedConfig);
+
+    if (options.prune) {
+      if (!registry) {
+        console.error(red('Failed to load registry for pruning dependencies.'));
+        process.exitCode = 1;
+      } else {
+        await pruneDependencies(installedNames, {}, registry);
+      }
+    }
+
+    console.log(green('All components removed successfully.'));
+    return;
+  }
+
+  if (!componentName) {
+    console.error(red('Please provide a component name or use --all.'));
+    process.exitCode = 1;
+    return;
+  }
+
+  const installedEntry = installed?.[componentName];
+  if (!installedEntry) {
+    console.log(yellow(`Component "${componentName}" is not installed.`));
+    return;
+  }
+
+  if (!options.yes) {
+    const confirmed = await confirmRemoval(`Are you sure you want to remove ${componentName}?`);
+    if (!confirmed) {
+      console.log(yellow('Aborted.'));
+      return;
+    }
+  }
+
+  let registry = null;
+  try {
+    registry = await readRegistry();
+  } catch {
+    registry = null;
+  }
+
+  console.log(`Removing: ${componentName}`);
+  await removeInstalledFiles(componentName, installedEntry, config, registry);
+
+  const updatedInstalled = { ...installed };
+  delete updatedInstalled[componentName];
+  const updatedConfig = { ...config, installed: updatedInstalled };
+  await writeConfig(updatedConfig);
+
+  if (options.prune) {
+    if (!registry) {
+      console.error(red('Failed to load registry for pruning dependencies.'));
+      process.exitCode = 1;
+    } else {
+      await pruneDependencies([componentName], updatedInstalled, registry);
+    }
+  }
+
+  console.log(green('Component removed successfully.'));
+}

package/src/commands/update.js

@@ -0,0 +1,151 @@
+import path from 'path';
+import pc from 'picocolors';
+import { copyFile, ensureDirectory, pathExists } from '../lib/fs.js';
+import { configExists, loadConfig, writeConfig } from '../lib/config.js';
+import { readRegistry } from '../lib/registry.js';
+import { templatePath } from '../lib/paths.js';
+import { resolveTargetRoot } from '../lib/targets.js';
+import { ensureStylesInstalled } from '../lib/styles.js';
+
+const { cyan, green, yellow, red } = pc;
+
+function parseVersion(version) {
+  if (!version) return [0, 0, 0];
+  return String(version)
+    .split('.')
+    .map((part) => Number.parseInt(part, 10))
+    .map((num) => (Number.isNaN(num) ? 0 : num));
+}
+
+function compareSemver(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  const length = Math.max(left.length, right.length, 3);
+  for (let i = 0; i < length; i += 1) {
+    const l = left[i] ?? 0;
+    const r = right[i] ?? 0;
+    if (l > r) return 1;
+    if (l < r) return -1;
+  }
+  return 0;
+}
+
+async function updateComponent(name, entry, config) {
+  if (!entry) {
+    console.log(yellow(`Component "${name}" is not found in the registry.`));
+    return { updated: false, config };
+  }
+
+  const componentsRoot = resolveTargetRoot(entry, config);
+  let installed = config.installed?.[name];
+  if (!installed) {
+    const detectedFiles = [];
+    for (const file of entry.files ?? []) {
+      const destination = path.resolve(componentsRoot, file.target);
+      if (await pathExists(destination)) {
+        detectedFiles.push(path.relative(componentsRoot, destination));
+      }
+    }
+
+    if (detectedFiles.length > 0) {
+      installed = {
+        version: '0.0.0',
+        files: detectedFiles,
+        installedAt: null,
+      };
+      console.log(yellow(`Component "${name}" was not tracked; treating existing files as installed.`));
+    } else {
+      console.log(yellow(`Component "${name}" is not installed.`));
+      return { updated: false, config };
+    }
+  }
+
+  const installedVersion = installed.version ?? '0.0.0';
+  const registryVersion = entry.version ?? '0.0.0';
+
+  if (compareSemver(installedVersion, registryVersion) >= 0) {
+    console.log(green(`${name} is already up to date.`));
+    return { updated: false, config };
+  }
+
+  console.log(cyan(`Updating component ${name}...`));
+
+  const updatedFiles = new Set(installed.files ?? []);
+
+  for (const file of entry.files ?? []) {
+    const source = templatePath(file.source);
+    const destination = path.resolve(componentsRoot, file.target);
+    await ensureDirectory(path.dirname(destination));
+
+    await copyFile(source, destination, { overwrite: true });
+    updatedFiles.add(path.relative(componentsRoot, destination));
+  }
+
+  const updatedConfig = {
+    ...config,
+    installed: {
+      ...config.installed,
+      [name]: {
+        ...installed,
+        version: registryVersion,
+        files: Array.from(updatedFiles),
+        installedAt: installed.installedAt ?? new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+    },
+  };
+
+  return { updated: true, config: updatedConfig };
+}
+
+export default async function updateCommand(componentName, options = {}) {
+  if (!(await configExists())) {
+    console.error(red('cmfrt.json is missing. Run cmfrt init first.'));
+    return;
+  }
+
+  const config = await loadConfig();
+  const registry = await readRegistry();
+  let currentConfig = config;
+  let didUpdate = false;
+
+  const stylesResult = await ensureStylesInstalled(registry, currentConfig);
+  currentConfig = stylesResult.config;
+  if (stylesResult.updated) {
+    didUpdate = true;
+  }
+
+  if (options.all) {
+    const installedNames = Object.keys(config.installed ?? {});
+
+    for (const name of installedNames) {
+      if (name === 'styles') continue;
+      const result = await updateComponent(name, registry[name], currentConfig);
+      currentConfig = result.config;
+      if (result.updated) {
+        didUpdate = true;
+      }
+    }
+
+    if (didUpdate) {
+      await writeConfig(currentConfig);
+    }
+
+    return;
+  }
+
+  if (!componentName) {
+    console.error(red('Please provide a component name or use --all.'));
+    return;
+  }
+
+  const result = await updateComponent(componentName, registry[componentName], currentConfig);
+  currentConfig = result.config;
+  if (result.updated) {
+    didUpdate = true;
+  }
+  if (didUpdate) {
+    await writeConfig(currentConfig);
+  }
+
+}

package/src/lib/config.js

@@ -0,0 +1,55 @@
+import { pathExists, readJson, writeJson } from './fs.js';
+import { configFilePath } from './paths.js';
+
+const defaultConfig = {
+  componentsPath: 'src/components/ui',
+  stylesPath: 'src/styles',
+  utilsPath: 'src/lib/utils.js',
+  themeMode: null,
+  installed: {},
+};
+
+export const createDefaultConfig = () => ({ ...defaultConfig });
+
+export const configExists = () => pathExists(configFilePath());
+
+export async function loadConfig() {
+  const path = configFilePath();
+  if (!(await pathExists(path))) {
+    throw new Error('cmfrt.json is missing. Run cmfrt init first.');
+  }
+  const raw = await readJson(path);
+  const normalized = { ...defaultConfig, ...raw };
+  let needsWrite = false;
+
+  if (!normalized.installed) {
+    if (Array.isArray(raw.components)) {
+      const installed = {};
+      for (const name of raw.components) {
+        installed[name] = {
+          version: '0.0.0',
+          files: [],
+          installedAt: null,
+        };
+      }
+      normalized.installed = installed;
+    } else {
+      normalized.installed = {};
+    }
+    needsWrite = true;
+  }
+
+  const { components, ...cleaned } = normalized;
+
+  if (components) {
+    needsWrite = true;
+  }
+
+  if (needsWrite) {
+    await writeJson(path, cleaned, { spaces: 2 });
+  }
+
+  return cleaned;
+}
+
+export const writeConfig = (config) => writeJson(configFilePath(), config);

package/src/lib/fs.js

@@ -0,0 +1,13 @@
+import fs from 'fs-extra';
+
+export const readJson = (filePath) => fs.readJson(filePath);
+export const writeJson = (filePath, data, options = {}) => fs.writeJson(filePath, data, { spaces: 2, ...options });
+export const ensureDirectory = (dirPath) => fs.ensureDir(dirPath);
+export const copyFile = (source, destination, options = {}) => {
+  const { overwrite = true, ...rest } = options;
+  return fs.copy(source, destination, { overwrite, ...rest });
+};
+export const pathExists = (target) => fs.pathExists(target);
+export const readFile = (filePath, options = {}) => fs.readFile(filePath, options);
+export const writeFile = (filePath, data, options = {}) => fs.writeFile(filePath, data, options);
+export const removePath = (target) => fs.remove(target);

package/src/lib/packageManager.js

@@ -0,0 +1,30 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+
+const packageManagerMap = [
+  { lockFile: 'pnpm-lock.yaml', manager: 'pnpm' },
+  { lockFile: 'yarn.lock', manager: 'yarn' },
+  { lockFile: 'package-lock.json', manager: 'npm' },
+];
+
+export async function detectPackageManager(cwd = process.cwd()) {
+  for (const entry of packageManagerMap) {
+    if (await fs.pathExists(path.resolve(cwd, entry.lockFile))) {
+      return entry.manager;
+    }
+  }
+  return 'npm';
+}
+
+export async function installDependencies(dependencies, cwd = process.cwd()) {
+  if (!dependencies || dependencies.length === 0) {
+    return;
+  }
+
+  const manager = await detectPackageManager(cwd);
+  const baseCommand = manager === 'yarn' || manager === 'pnpm' ? 'add' : 'install';
+  const args = [baseCommand, ...dependencies];
+
+  await execa(manager, args, { cwd, stdio: 'inherit' });
+}

package/src/lib/paths.js

@@ -0,0 +1,14 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const cliRoot = path.resolve(__dirname, '../../');
+const templatesRoot = path.resolve(cliRoot, 'templates');
+
+export const projectRoot = () => process.cwd();
+export const configFilePath = () => path.resolve(projectRoot(), 'cmfrt.json');
+export const componentsDir = () => path.resolve(projectRoot(), 'src/components/ui');
+export const libDir = () => path.resolve(projectRoot(), 'src/lib');
+export const templatesDir = () => templatesRoot;
+export const templatePath = (...segments) => path.resolve(templatesRoot, ...segments);

package/src/lib/registry.js

@@ -0,0 +1,11 @@
+import { readJson } from './fs.js';
+import { templatePath } from './paths.js';
+
+const registryPath = templatePath('registry.json');
+
+export const readRegistry = () => readJson(registryPath);
+
+export async function getComponentEntry(name) {
+  const registry = await readRegistry();
+  return registry[name];
+}