@gilav21/shadcn-angular 0.0.19 → 0.0.21

package/dist/commands/add.js

@@ -1,6 +1,6 @@
 import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import prompts from 'prompts';
 import chalk from 'chalk';
 import ora from 'ora';
@@ -10,22 +10,25 @@ import { installPackages } from '../utils/package-manager.js';
 import { writeShortcutRegistryIndex } from '../utils/shortcut-registry.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-// Base URL for the component registry (GitHub raw content)
-const REGISTRY_BASE_URL = 'https://raw.githubusercontent.com/gilav21/shadcn-angular/master/packages/components/ui';
-const LIB_REGISTRY_BASE_URL = 'https://raw.githubusercontent.com/gilav21/shadcn-angular/master/packages/components/lib';
-// Components source directory (relative to CLI dist folder) for local dev
-function getLocalComponentsDir() {
-    // From dist/commands/add.js -> packages/components/ui
-    const fromDist = path.resolve(__dirname, '../../../components/ui');
-    if (fs.existsSync(fromDist)) {
-        return fromDist;
-    }
-    // Fallback: from src/commands/add.ts -> packages/components/ui
-    const fromSrc = path.resolve(__dirname, '../../../components/ui');
-    if (fs.existsSync(fromSrc)) {
-        return fromSrc;
+// ---------------------------------------------------------------------------
+// Path & URL helpers
+// ---------------------------------------------------------------------------
+function validateBranch(branch) {
+    if (!/^[\w.\-/]+$/.test(branch)) {
+        throw new Error(`Invalid branch name: ${branch}`);
     }
-    return null;
+}
+function getRegistryBaseUrl(branch) {
+    validateBranch(branch);
+    return `https://raw.githubusercontent.com/gilav21/shadcn-angular/${branch}/packages/components/ui`;
+}
+function getLibRegistryBaseUrl(branch) {
+    validateBranch(branch);
+    return `https://raw.githubusercontent.com/gilav21/shadcn-angular/${branch}/packages/components/lib`;
+}
+function getLocalComponentsDir() {
+    const localPath = path.resolve(__dirname, '../../../components/ui');
+    return fs.existsSync(localPath) ? localPath : null;
 }
 function getLocalLibDir() {
     const fromDist = path.resolve(__dirname, '../../../components/lib');
@@ -47,17 +50,21 @@ function aliasToProjectPath(aliasOrPath) {
         ? path.join('src', aliasOrPath.slice(2))
         : aliasOrPath;
 }
+function normalizeContent(str) {
+    return str.replaceAll('\r\n', '\n').trim();
+}
+// ---------------------------------------------------------------------------
+// Remote content fetching
+// ---------------------------------------------------------------------------
 async function fetchComponentContent(file, options) {
     const localDir = getLocalComponentsDir();
-    // 1. Prefer local if available and not forced remote
     if (localDir && !options.remote) {
         const localPath = path.join(localDir, file);
         if (await fs.pathExists(localPath)) {
             return fs.readFile(localPath, 'utf-8');
         }
     }
-    // 2. Fetch from remote registry
-    const url = `${REGISTRY_BASE_URL}/${file}`;
+    const url = `${getRegistryBaseUrl(options.branch)}/${file}`;
     try {
         const response = await fetch(url);
         if (!response.ok) {
@@ -80,43 +87,26 @@ async function fetchLibContent(file, options) {
             return fs.readFile(localPath, 'utf-8');
         }
     }
-    const url = `${LIB_REGISTRY_BASE_URL}/${file}`;
+    const url = `${getLibRegistryBaseUrl(options.branch)}/${file}`;
     const response = await fetch(url);
     if (!response.ok) {
         throw new Error(`Failed to fetch library file from ${url}: ${response.statusText}`);
     }
     return response.text();
 }
-function collectInstalledShortcutEntries(targetDir) {
-    const entries = [];
-    for (const definition of Object.values(registry)) {
-        if (!definition.shortcutDefinitions?.length) {
-            continue;
-        }
-        for (const shortcutDefinition of definition.shortcutDefinitions) {
-            const sourcePath = path.join(targetDir, shortcutDefinition.sourceFile);
-            if (fs.existsSync(sourcePath)) {
-                entries.push(shortcutDefinition);
-            }
-        }
-    }
-    return entries;
+async function fetchAndTransform(file, options, utilsAlias) {
+    let content = await fetchComponentContent(file, options);
+    content = content.replaceAll(/(\.\.\/)+lib\//, utilsAlias + '/');
+    return content;
 }
-export async function add(components, options) {
-    const cwd = process.cwd();
-    // Load config
-    const config = await getConfig(cwd);
-    if (!config) {
-        console.log(chalk.red('Error: components.json not found.'));
-        console.log(chalk.dim('Run `npx @gilav21/shadcn-angular init` first.'));
-        process.exit(1);
-    }
-    // Get components to add
-    let componentsToAdd = [];
+// ---------------------------------------------------------------------------
+// Component selection & dependency resolution
+// ---------------------------------------------------------------------------
+async function selectComponents(components, options) {
     if (options.all) {
-        componentsToAdd = Object.keys(registry);
+        return Object.keys(registry);
     }
-    else if (components.length === 0) {
+    if (components.length === 0) {
         const { selected } = await prompts({
             type: 'multiselect',
             name: 'selected',
@@ -127,146 +117,307 @@ export async function add(components, options) {
             })),
             hint: '- Space to select, Enter to confirm',
         });
-        componentsToAdd = selected;
-    }
-    else {
-        componentsToAdd = components;
-    }
-    if (!componentsToAdd || componentsToAdd.length === 0) {
-        console.log(chalk.dim('No components selected.'));
-        return;
+        return selected;
     }
-    // Validate components exist
-    const invalidComponents = componentsToAdd.filter(c => !registry[c]);
-    if (invalidComponents.length > 0) {
-        console.log(chalk.red(`Invalid component(s): ${invalidComponents.join(', ')}`));
+    return components;
+}
+function validateComponents(names) {
+    const invalid = names.filter(c => !registry[c]);
+    if (invalid.length > 0) {
+        console.log(chalk.red(`Invalid component(s): ${invalid.join(', ')}`));
         console.log(chalk.dim('Available components: ' + Object.keys(registry).join(', ')));
         process.exit(1);
     }
-    // Resolve dependencies
-    const allComponents = new Set();
-    const resolveDeps = (name) => {
-        if (allComponents.has(name))
+}
+export function resolveDependencies(names) {
+    const all = new Set();
+    const walk = (name) => {
+        if (all.has(name))
             return;
-        allComponents.add(name);
+        all.add(name);
+        registry[name].dependencies?.forEach(dep => walk(dep));
+    };
+    names.forEach(walk);
+    return all;
+}
+export async function promptOptionalDependencies(resolved, options) {
+    const seen = new Set();
+    const choices = [];
+    for (const name of resolved) {
         const component = registry[name];
-        if (component.dependencies) {
-            component.dependencies.forEach(dep => resolveDeps(dep));
+        if (!component.optionalDependencies)
+            continue;
+        for (const opt of component.optionalDependencies) {
+            if (resolved.has(opt.name) || seen.has(opt.name))
+                continue;
+            seen.add(opt.name);
+            choices.push({ name: opt.name, description: opt.description, requestedBy: name });
         }
-    };
-    componentsToAdd.forEach(c => resolveDeps(c));
-    const uiBasePath = options.path ?? aliasToProjectPath(config.aliases.ui || 'src/components/ui');
-    const targetDir = resolveProjectPath(cwd, uiBasePath);
-    // Check for existing files and diff
-    const componentsToInstall = [];
-    const componentsToSkip = [];
-    const conflictingComponents = [];
+    }
+    if (choices.length === 0)
+        return [];
+    if (options.yes)
+        return [];
+    if (options.all)
+        return choices.map(c => c.name);
+    const { selected } = await prompts({
+        type: 'multiselect',
+        name: 'selected',
+        message: 'Optional companion components available:',
+        choices: choices.map(c => ({
+            title: c.name + ' ' + chalk.dim('- ' + c.description + ' (for ' + c.requestedBy + ')'),
+            value: c.name,
+        })),
+        hint: '- Space to select, Enter to confirm (or press Enter to skip)',
+    });
+    return selected || [];
+}
+// ---------------------------------------------------------------------------
+// Conflict detection
+// ---------------------------------------------------------------------------
+async function checkFileConflict(file, targetDir, options, utilsAlias, contentCache) {
+    const targetPath = path.join(targetDir, file);
+    if (!await fs.pathExists(targetPath)) {
+        return 'missing';
+    }
+    const localContent = await fs.readFile(targetPath, 'utf-8');
+    try {
+        const remoteContent = await fetchAndTransform(file, options, utilsAlias);
+        contentCache.set(file, remoteContent);
+        return normalizeContent(localContent) === normalizeContent(remoteContent)
+            ? 'identical'
+            : 'changed';
+    }
+    catch {
+        return 'changed';
+    }
+}
+async function checkPeerFiles(component, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate) {
+    if (!component.peerFiles)
+        return false;
+    let hasChanges = false;
+    for (const file of component.peerFiles) {
+        const status = await checkFileConflict(file, targetDir, options, utilsAlias, contentCache);
+        if (status === 'changed') {
+            hasChanges = true;
+            peerFilesToUpdate.add(file);
+        }
+    }
+    return hasChanges;
+}
+async function classifyComponent(name, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate) {
+    const component = registry[name];
+    let hasChanges = false;
+    let isFullyPresent = true;
+    for (const file of component.files) {
+        const status = await checkFileConflict(file, targetDir, options, utilsAlias, contentCache);
+        if (status === 'missing')
+            isFullyPresent = false;
+        if (status === 'changed')
+            hasChanges = true;
+    }
+    const peerChanged = await checkPeerFiles(component, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate);
+    if (peerChanged)
+        hasChanges = true;
+    if (isFullyPresent && !hasChanges)
+        return 'skip';
+    if (hasChanges)
+        return 'conflict';
+    return 'install';
+}
+async function detectConflicts(allComponents, targetDir, options, utilsAlias) {
+    const toInstall = [];
+    const toSkip = [];
+    const conflicting = [];
+    const peerFilesToUpdate = new Set();
     const contentCache = new Map();
-    const checkSpinner = ora('Checking for conflicts...').start();
     for (const name of allComponents) {
-        const component = registry[name];
-        let hasChanges = false;
-        let isFullyPresent = true;
-        for (const file of component.files) {
-            const targetPath = path.join(targetDir, file);
-            if (await fs.pathExists(targetPath)) {
-                const localContent = await fs.readFile(targetPath, 'utf-8');
-                try {
-                    let remoteContent = await fetchComponentContent(file, options);
-                    // Transform all lib/ imports for comparison
-                    remoteContent = remoteContent.replace(/(\.\.\/)+lib\//g, config.aliases.utils + '/');
-                    const normalize = (str) => str.replace(/\r\n/g, '\n').trim();
-                    if (normalize(localContent) !== normalize(remoteContent)) {
-                        hasChanges = true;
-                    }
-                    contentCache.set(file, remoteContent); // Cache for installation
-                }
-                catch (error) {
-                    // unexpected error fetching remote
-                    console.warn(`Could not fetch remote content for comparison: ${file}`);
-                    hasChanges = true; // Assume changed/unknown
-                }
-            }
-            else {
-                isFullyPresent = false;
-            }
+        const result = await classifyComponent(name, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate);
+        if (result === 'skip')
+            toSkip.push(name);
+        else if (result === 'conflict')
+            conflicting.push(name);
+        else
+            toInstall.push(name);
+    }
+    return { toInstall, toSkip, conflicting, peerFilesToUpdate, contentCache };
+}
+// ---------------------------------------------------------------------------
+// Overwrite prompt
+// ---------------------------------------------------------------------------
+async function promptOverwrite(conflicting, options) {
+    if (conflicting.length === 0)
+        return [];
+    if (options.overwrite)
+        return conflicting;
+    if (options.yes)
+        return [];
+    console.log(chalk.yellow(`\n${conflicting.length} component(s) have local changes or are different from remote.`));
+    const { selected } = await prompts({
+        type: 'multiselect',
+        name: 'selected',
+        message: 'Select components to OVERWRITE (Unselected will be skipped):',
+        choices: conflicting.map(name => ({ title: name, value: name })),
+        hint: '- Space to select, Enter to confirm',
+    });
+    return selected || [];
+}
+// ---------------------------------------------------------------------------
+// File writing
+// ---------------------------------------------------------------------------
+async function writeComponentFiles(component, targetDir, options, utilsAlias, contentCache, spinner) {
+    let success = true;
+    for (const file of component.files) {
+        const targetPath = path.join(targetDir, file);
+        try {
+            const content = contentCache.get(file)
+                ?? await fetchAndTransform(file, options, utilsAlias);
+            await fs.ensureDir(path.dirname(targetPath));
+            await fs.writeFile(targetPath, content);
         }
-        if (isFullyPresent && !hasChanges) {
-            componentsToSkip.push(name);
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            spinner.warn(`Could not add ${file}: ${message}`);
+            success = false;
         }
-        else if (hasChanges) {
-            conflictingComponents.push(name);
+    }
+    return success;
+}
+async function writePeerFiles(component, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate, spinner) {
+    if (!component.peerFiles)
+        return;
+    for (const file of component.peerFiles) {
+        if (!peerFilesToUpdate.has(file))
+            continue;
+        const targetPath = path.join(targetDir, file);
+        try {
+            const content = contentCache.get(file)
+                ?? await fetchAndTransform(file, options, utilsAlias);
+            await fs.writeFile(targetPath, content);
+            spinner.text = `Updated peer file ${file}`;
         }
-        else {
-            componentsToInstall.push(name);
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            spinner.warn(`Could not update peer file ${file}: ${message}`);
         }
     }
-    checkSpinner.stop();
-    let componentsToOverwrite = [];
-    if (conflictingComponents.length > 0) {
-        if (options.overwrite) {
-            componentsToOverwrite = conflictingComponents;
+}
+async function installLibFiles(allComponents, cwd, libDir, options) {
+    const required = new Set();
+    for (const name of allComponents) {
+        registry[name].libFiles?.forEach(f => required.add(f));
+    }
+    if (required.size === 0)
+        return;
+    await fs.ensureDir(libDir);
+    for (const libFile of required) {
+        const targetPath = path.join(libDir, libFile);
+        if (!await fs.pathExists(targetPath) || options.overwrite) {
+            try {
+                const content = await fetchLibContent(libFile, options);
+                await fs.writeFile(targetPath, content);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                console.warn(chalk.yellow(`Could not install lib file ${libFile}: ${message}`));
+            }
         }
-        else if (options.yes) {
-            componentsToOverwrite = []; // Skip conflicts in non-interactive mode unless --overwrite
+    }
+}
+async function installNpmDependencies(finalComponents, cwd) {
+    const deps = new Set();
+    for (const name of finalComponents) {
+        registry[name].npmDependencies?.forEach(dep => deps.add(dep));
+    }
+    if (deps.size === 0)
+        return;
+    const spinner = ora('Installing dependencies...').start();
+    try {
+        await installPackages(Array.from(deps), { cwd });
+        spinner.succeed('Dependencies installed.');
+    }
+    catch (e) {
+        spinner.fail('Failed to install dependencies.');
+        console.error(e);
+    }
+}
+async function ensureShortcutService(targetDir, cwd, config, options) {
+    const entries = collectInstalledShortcutEntries(targetDir);
+    if (entries.length > 0) {
+        const libDir = resolveProjectPath(cwd, aliasToProjectPath(config.aliases.utils));
+        const servicePath = path.join(libDir, 'shortcut-binding.service.ts');
+        if (!await fs.pathExists(servicePath)) {
+            const content = await fetchLibContent('shortcut-binding.service.ts', options);
+            await fs.ensureDir(libDir);
+            await fs.writeFile(servicePath, content);
         }
-        else {
-            console.log(chalk.yellow(`\n${conflictingComponents.length} component(s) have local changes or are different from remote.`));
-            const { selected } = await prompts({
-                type: 'multiselect',
-                name: 'selected',
-                message: 'Select components to OVERWRITE (Unselected will be skipped):',
-                choices: conflictingComponents.map(name => ({
-                    title: name,
-                    value: name,
-                })),
-                hint: '- Space to select, Enter to confirm',
-            });
-            componentsToOverwrite = selected || [];
+    }
+    await writeShortcutRegistryIndex(cwd, config, entries);
+}
+function collectInstalledShortcutEntries(targetDir) {
+    const entries = [];
+    for (const definition of Object.values(registry)) {
+        if (!definition.shortcutDefinitions?.length)
+            continue;
+        for (const sd of definition.shortcutDefinitions) {
+            if (fs.existsSync(path.join(targetDir, sd.sourceFile))) {
+                entries.push(sd);
+            }
         }
     }
-    // Final list of components to process
-    // We process:
-    // 1. componentsToInstall (Brand new or partial)
-    // 2. componentsToOverwrite (User selected)
-    // We SKIP:
-    // 1. componentsToSkip (Identical)
-    // 2. conflictingComponents NOT in componentsToOverwrite
-    const finalComponents = [...componentsToInstall, ...componentsToOverwrite];
-    if (finalComponents.length === 0 && componentsToSkip.length > 0) {
-        console.log(chalk.green(`\nAll components are up to date! (${componentsToSkip.length} skipped)`));
+    return entries;
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+export async function add(components, options) {
+    const cwd = process.cwd();
+    const config = await getConfig(cwd);
+    if (!config) {
+        console.log(chalk.red('Error: components.json not found.'));
+        console.log(chalk.dim('Run `npx @gilav21/shadcn-angular init` first.'));
+        process.exit(1);
+    }
+    const componentsToAdd = await selectComponents(components, options);
+    if (!componentsToAdd || componentsToAdd.length === 0) {
+        console.log(chalk.dim('No components selected.'));
         return;
     }
+    validateComponents(componentsToAdd);
+    const resolvedComponents = resolveDependencies(componentsToAdd);
+    const optionalChoices = await promptOptionalDependencies(resolvedComponents, options);
+    const allComponents = optionalChoices.length > 0
+        ? resolveDependencies([...resolvedComponents, ...optionalChoices])
+        : resolvedComponents;
+    const uiBasePath = options.path ?? aliasToProjectPath(config.aliases.ui || 'src/components/ui');
+    const targetDir = resolveProjectPath(cwd, uiBasePath);
+    const utilsAlias = config.aliases.utils;
+    // Detect conflicts
+    const checkSpinner = ora('Checking for conflicts...').start();
+    const { toInstall, toSkip, conflicting, peerFilesToUpdate, contentCache } = await detectConflicts(allComponents, targetDir, options, utilsAlias);
+    checkSpinner.stop();
+    // Prompt user for overwrite decisions
+    const toOverwrite = await promptOverwrite(conflicting, options);
+    const finalComponents = [...toInstall, ...toOverwrite];
     if (finalComponents.length === 0) {
-        console.log(chalk.dim('\nNo components to install.'));
+        if (toSkip.length > 0) {
+            console.log(chalk.green(`\nAll components are up to date! (${toSkip.length} skipped)`));
+        }
+        else {
+            console.log(chalk.dim('\nNo components to install.'));
+        }
         return;
     }
+    // Install component files
     const spinner = ora('Installing components...').start();
     let successCount = 0;
     try {
         await fs.ensureDir(targetDir);
         for (const name of finalComponents) {
             const component = registry[name];
-            let componentSuccess = true;
-            for (const file of component.files) {
-                const targetPath = path.join(targetDir, file);
-                try {
-                    let content = contentCache.get(file);
-                    if (!content) {
-                        content = await fetchComponentContent(file, options);
-                        // Transform all lib/ imports if not already transformed (cached is transformed)
-                        content = content.replace(/(\.\.\/)+lib\//g, config.aliases.utils + '/');
-                    }
-                    await fs.ensureDir(path.dirname(targetPath));
-                    await fs.writeFile(targetPath, content);
-                    // spinner.text = `Added ${file}`; // Too verbose?
-                }
-                catch (err) {
-                    spinner.warn(`Could not add ${file}: ${err.message}`);
-                    componentSuccess = false;
-                }
-            }
-            if (componentSuccess) {
+            const ok = await writeComponentFiles(component, targetDir, options, utilsAlias, contentCache, spinner);
+            await writePeerFiles(component, targetDir, options, utilsAlias, contentCache, peerFilesToUpdate, spinner);
+            if (ok) {
                 successCount++;
                 spinner.text = `Added ${name}`;
             }
@@ -274,75 +425,19 @@ export async function add(components, options) {
         if (successCount > 0) {
             spinner.succeed(chalk.green(`Success! Added ${successCount} component(s)`));
             console.log('\n' + chalk.dim('Components added:'));
-            finalComponents.forEach(name => {
-                console.log(chalk.dim('  - ') + chalk.cyan(name));
-            });
+            finalComponents.forEach(name => console.log(chalk.dim('  - ') + chalk.cyan(name)));
         }
         else {
             spinner.info('No new components installed.');
         }
-        // Install required lib utility files
-        if (finalComponents.length > 0) {
-            const requiredLibFiles = new Set();
-            for (const name of allComponents) {
-                const component = registry[name];
-                if (component.libFiles) {
-                    component.libFiles.forEach(f => requiredLibFiles.add(f));
-                }
-            }
-            if (requiredLibFiles.size > 0) {
-                const libDir = resolveProjectPath(cwd, aliasToProjectPath(config.aliases.utils));
-                await fs.ensureDir(libDir);
-                for (const libFile of requiredLibFiles) {
-                    const libTargetPath = path.join(libDir, libFile);
-                    if (!await fs.pathExists(libTargetPath) || options.overwrite) {
-                        try {
-                            const libContent = await fetchLibContent(libFile, options);
-                            await fs.writeFile(libTargetPath, libContent);
-                        }
-                        catch (err) {
-                            console.warn(chalk.yellow(`Could not install lib file ${libFile}: ${err.message}`));
-                        }
-                    }
-                }
-            }
-        }
-        if (finalComponents.length > 0) {
-            const npmDependencies = new Set();
-            for (const name of finalComponents) {
-                const component = registry[name];
-                if (component.npmDependencies) {
-                    component.npmDependencies.forEach(dep => npmDependencies.add(dep));
-                }
-            }
-            if (npmDependencies.size > 0) {
-                const depSpinner = ora('Installing dependencies...').start();
-                try {
-                    await installPackages(Array.from(npmDependencies), { cwd });
-                    depSpinner.succeed('Dependencies installed.');
-                }
-                catch (e) {
-                    depSpinner.fail('Failed to install dependencies.');
-                    console.error(e);
-                }
-            }
-        }
-        const shortcutEntries = collectInstalledShortcutEntries(targetDir);
-        if (shortcutEntries.length > 0) {
-            const libDir2 = resolveProjectPath(cwd, aliasToProjectPath(config.aliases.utils));
-            const shortcutServicePath = path.join(libDir2, 'shortcut-binding.service.ts');
-            if (!await fs.pathExists(shortcutServicePath)) {
-                const shortcutServiceContent = await fetchLibContent('shortcut-binding.service.ts', options);
-                await fs.ensureDir(libDir2);
-                await fs.writeFile(shortcutServicePath, shortcutServiceContent);
-            }
-        }
-        await writeShortcutRegistryIndex(cwd, config, shortcutEntries);
-        if (componentsToSkip.length > 0) {
+        // Post-install: lib files, npm deps, shortcuts
+        const libDir = resolveProjectPath(cwd, aliasToProjectPath(utilsAlias));
+        await installLibFiles(allComponents, cwd, libDir, options);
+        await installNpmDependencies(finalComponents, cwd);
+        await ensureShortcutService(targetDir, cwd, config, options);
+        if (toSkip.length > 0) {
             console.log('\n' + chalk.dim('Components skipped (up to date):'));
-            componentsToSkip.forEach(name => {
-                console.log(chalk.dim('  - ') + chalk.gray(name));
-            });
+            toSkip.forEach(name => console.log(chalk.dim('  - ') + chalk.gray(name)));
         }
         console.log('');
     }

package/dist/commands/add.spec.d.ts

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