@jatinmourya/ng-init 1.0.0

package/src/utils/installer.js

@@ -0,0 +1,247 @@
+import { execa } from 'execa';
+import ora from 'ora';
+import chalk from 'chalk';
+import { platform } from 'os';
+
+/**
+ * Install Node.js using winget (Windows)
+ */
+export async function installNodeWithWinget(version = 'LTS') {
+    const spinner = ora('Installing Node.js with winget...').start();
+    
+    try {
+        const packageId = version === 'LTS' ? 'OpenJS.NodeJS.LTS' : 'OpenJS.NodeJS';
+        await execa('winget', ['install', packageId], { stdio: 'inherit' });
+        
+        spinner.succeed('Node.js installed successfully');
+        return true;
+    } catch (error) {
+        spinner.fail('Failed to install Node.js');
+        console.error(chalk.red(error.message));
+        return false;
+    }
+}
+
+/**
+ * Get nvm installation instructions based on OS
+ */
+export function getNvmInstallInstructions() {
+    const os = platform();
+    
+    if (os === 'win32') {
+        return {
+            os: 'Windows',
+            method: 'Download and install',
+            url: 'https://github.com/coreybutler/nvm-windows/releases',
+            command: null,
+            description: 'Download the nvm-setup.zip file from the releases page and run the installer.'
+        };
+    } else if (os === 'darwin') {
+        return {
+            os: 'macOS',
+            method: 'Using curl',
+            url: 'https://github.com/nvm-sh/nvm',
+            command: 'curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash',
+            description: 'Run the curl command in your terminal to install nvm.'
+        };
+    } else {
+        return {
+            os: 'Linux',
+            method: 'Using curl or wget',
+            url: 'https://github.com/nvm-sh/nvm',
+            command: 'curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash',
+            alternativeCommand: 'wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash',
+            description: 'Run either the curl or wget command in your terminal to install nvm.'
+        };
+    }
+}
+
+/**
+ * Display nvm installation guide
+ */
+export function displayNvmInstallGuide() {
+    const instructions = getNvmInstallInstructions();
+    
+    console.log(chalk.bold.yellow('\n📚 nvm Installation Guide\n'));
+    console.log(chalk.gray('━'.repeat(50)));
+    console.log(chalk.white('Operating System: ') + chalk.cyan(instructions.os));
+    console.log(chalk.white('Method:           ') + chalk.cyan(instructions.method));
+    console.log(chalk.white('URL:              ') + chalk.blue(instructions.url));
+    
+    if (instructions.command) {
+        console.log(chalk.white('\nCommand:'));
+        console.log(chalk.green(`  ${instructions.command}`));
+        
+        if (instructions.alternativeCommand) {
+            console.log(chalk.white('\nAlternative:'));
+            console.log(chalk.green(`  ${instructions.alternativeCommand}`));
+        }
+    }
+    
+    console.log(chalk.white('\nDescription:'));
+    console.log(chalk.gray(`  ${instructions.description}`));
+    console.log(chalk.gray('━'.repeat(50)) + '\n');
+    
+    console.log(chalk.yellow('💡 Benefits of using nvm:'));
+    console.log(chalk.gray('  • Manage multiple Node.js versions'));
+    console.log(chalk.gray('  • Switch between versions easily'));
+    console.log(chalk.gray('  • No admin/sudo required for installations'));
+    console.log(chalk.gray('  • Project-specific Node versions\n'));
+}
+
+/**
+ * Install npm package globally
+ */
+export async function installGlobalPackage(packageName, version = 'latest') {
+    const spinner = ora(`Installing ${packageName}@${version}...`).start();
+    
+    try {
+        const packageSpec = version === 'latest' ? packageName : `${packageName}@${version}`;
+        await execa('npm', ['install', '-g', packageSpec], { stdio: 'inherit' });
+        
+        spinner.succeed(`${packageName} installed successfully`);
+        return true;
+    } catch (error) {
+        spinner.fail(`Failed to install ${packageName}`);
+        console.error(chalk.red(error.message));
+        return false;
+    }
+}
+
+/**
+ * Install npm packages in project
+ */
+export async function installPackages(packages, projectPath, dev = false) {
+    const spinner = ora(`Installing ${packages.length} package(s)...`).start();
+    
+    try {
+        const args = ['install'];
+        if (dev) args.push('--save-dev');
+        args.push(...packages);
+        
+        await execa('npm', args, { 
+            cwd: projectPath,
+            stdio: 'inherit'
+        });
+        
+        spinner.succeed('Packages installed successfully');
+        return true;
+    } catch (error) {
+        spinner.warn('Failed with strict dependencies, retrying with --legacy-peer-deps...');
+        
+        // Retry with --legacy-peer-deps flag
+        try {
+            const args = ['install', '--legacy-peer-deps'];
+            if (dev) args.push('--save-dev');
+            args.push(...packages);
+            
+            await execa('npm', args, { 
+                cwd: projectPath,
+                stdio: 'inherit'
+            });
+            
+            spinner.succeed('Packages installed successfully with --legacy-peer-deps');
+            console.log(chalk.yellow('⚠️  Note: Installed with --legacy-peer-deps flag due to peer dependency conflicts'));
+            return true;
+        } catch (retryError) {
+            spinner.fail('Failed to install packages');
+            console.error(chalk.red(retryError.message));
+            console.log(chalk.yellow('\n💡 Tip: You can try installing manually with:'));
+            console.log(chalk.cyan(`   cd ${projectPath}`));
+            console.log(chalk.cyan(`   npm install ${packages.join(' ')} --force`));
+            return false;
+        }
+    }
+}
+
+/**
+ * Initialize npm project
+ */
+export async function initNpmProject(projectPath) {
+    try {
+        await execa('npm', ['init', '-y'], { 
+            cwd: projectPath,
+            stdio: 'inherit'
+        });
+        return true;
+    } catch (error) {
+        console.error(chalk.red('Failed to initialize npm project'));
+        return false;
+    }
+}
+
+/**
+ * Run npm install in project
+ */
+export async function runNpmInstall(projectPath) {
+    const spinner = ora('Installing dependencies...').start();
+    
+    try {
+        await execa('npm', ['install'], { 
+            cwd: projectPath,
+            stdio: 'inherit'
+        });
+        
+        spinner.succeed('Dependencies installed successfully');
+        return true;
+    } catch (error) {
+        spinner.warn('Failed with strict dependencies, retrying with --legacy-peer-deps...');
+        
+        // Retry with --legacy-peer-deps flag
+        try {
+            await execa('npm', ['install', '--legacy-peer-deps'], { 
+                cwd: projectPath,
+                stdio: 'inherit'
+            });
+            
+            spinner.succeed('Dependencies installed successfully with --legacy-peer-deps');
+            console.log(chalk.yellow('⚠️  Note: Installed with --legacy-peer-deps flag due to peer dependency conflicts'));
+            return true;
+        } catch (retryError) {
+            spinner.fail('Failed to install dependencies');
+            console.error(chalk.red(retryError.message));
+            console.log(chalk.yellow('\n💡 Tip: You can try installing manually with:'));
+            console.log(chalk.cyan(`   cd ${projectPath}`));
+            console.log(chalk.cyan(`   npm install --force`));
+            return false;
+        }
+    }
+}
+
+/**
+ * Install Angular CLI globally
+ */
+export async function installAngularCli(version = 'latest') {
+    return installGlobalPackage('@angular/cli', version);
+}
+
+/**
+ * Create Angular project using CLI
+ */
+export async function createAngularProject(projectName, angularVersion, options = {}) {
+    const spinner = ora(`Creating Angular project: ${projectName}...`).start();
+    
+    try {
+        const args = ['new', projectName];
+        
+        // Add options
+        if (options.skipInstall) args.push('--skip-install');
+        if (options.routing !== undefined) args.push(`--routing=${options.routing}`);
+        if (options.style) args.push(`--style=${options.style}`);
+        if (options.strict !== undefined) args.push(`--strict=${options.strict}`);
+        if (options.standalone !== undefined) args.push(`--standalone=${options.standalone}`);
+        
+        const cliCommand = angularVersion ? `@angular/cli@${angularVersion}` : '@angular/cli';
+        
+        await execa('npx', [cliCommand, ...args], { 
+            stdio: 'inherit'
+        });
+        
+        spinner.succeed(`Angular project ${projectName} created successfully`);
+        return true;
+    } catch (error) {
+        spinner.fail('Failed to create Angular project');
+        console.error(chalk.red(error.message));
+        return false;
+    }
+}

package/src/utils/npm-search.js

@@ -0,0 +1,354 @@
+import axios from 'axios';
+import debounce from 'lodash.debounce';
+
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+const NPM_SEARCH_URL = 'https://registry.npmjs.org/-/v1/search';
+const NPM_DOWNLOADS_URL = 'https://api.npmjs.org/downloads/point/last-week';
+
+/**
+ * Search npm packages
+ */
+export async function searchNpmPackages(query, size = 10) {
+    try {
+        const response = await axios.get(NPM_SEARCH_URL, {
+            params: {
+                text: query,
+                size: size
+            },
+            timeout: 5000
+        });
+
+        return response.data.objects.map(obj => ({
+            name: obj.package.name,
+            version: obj.package.version,
+            description: obj.package.description || 'No description',
+            author: obj.package.publisher?.username || 'Unknown',
+            date: obj.package.date,
+            verified: obj.package.publisher?.verified || false
+        }));
+    } catch (error) {
+        console.error('Error searching npm packages:', error.message);
+        return [];
+    }
+}
+
+/**
+ * Get package details from npm registry
+ */
+export async function getPackageDetails(packageName) {
+    try {
+        const response = await axios.get(`${NPM_REGISTRY_URL}/${packageName}`, {
+            timeout: 5000
+        });
+
+        const latestVersion = response.data['dist-tags']?.latest;
+        const versions = Object.keys(response.data.versions || {});
+
+        return {
+            name: response.data.name,
+            description: response.data.description || 'No description',
+            latestVersion: latestVersion,
+            versions: versions,
+            homepage: response.data.homepage,
+            repository: response.data.repository,
+            license: response.data.license,
+            keywords: response.data.keywords || []
+        };
+    } catch (error) {
+        if (error.response?.status === 404) {
+            return null;
+        }
+        throw error;
+    }
+}
+
+/**
+ * Get package download statistics
+ */
+export async function getPackageDownloads(packageName) {
+    try {
+        const response = await axios.get(`${NPM_DOWNLOADS_URL}/${packageName}`, {
+            timeout: 5000
+        });
+
+        return response.data.downloads;
+    } catch (error) {
+        return 0;
+    }
+}
+
+/**
+ * Validate if a package exists on npm
+ */
+export async function validatePackage(packageName) {
+    const details = await getPackageDetails(packageName);
+    return details !== null;
+}
+
+/**
+ * Get enhanced package info (details + downloads)
+ */
+export async function getEnhancedPackageInfo(packageName) {
+    try {
+        const [details, downloads] = await Promise.all([
+            getPackageDetails(packageName),
+            getPackageDownloads(packageName)
+        ]);
+
+        if (!details) {
+            return null;
+        }
+
+        return {
+            ...details,
+            weeklyDownloads: downloads
+        };
+    } catch (error) {
+        console.error(`Error getting package info for ${packageName}:`, error.message);
+        return null;
+    }
+}
+
+/**
+ * Format download count for display
+ */
+export function formatDownloads(downloads) {
+    if (downloads >= 1000000) {
+        return `${(downloads / 1000000).toFixed(1)}M`;
+    } else if (downloads >= 1000) {
+        return `${(downloads / 1000).toFixed(1)}K`;
+    }
+    return downloads.toString();
+}
+
+/**
+ * Debounced search function for autocomplete
+ */
+export const debouncedSearch = debounce(async (query, callback) => {
+    if (!query || query.length < 2) {
+        callback([]);
+        return;
+    }
+
+    const results = await searchNpmPackages(query, 10);
+    callback(results);
+}, 300);
+
+/**
+ * Get all versions of Angular CLI
+ */
+export async function getAngularVersions() {
+    try {
+        const response = await axios.get(`${NPM_REGISTRY_URL}/@angular/cli`, {
+            timeout: 10000
+        });
+
+        const versions = Object.keys(response.data.versions || {})
+            .filter(v => !v.includes('rc') && !v.includes('beta') && !v.includes('next'))
+            .sort((a, b) => {
+                // Sort in descending order (newest first)
+                const aParts = a.split('.').map(Number);
+                const bParts = b.split('.').map(Number);
+                
+                for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+                    const aVal = aParts[i] || 0;
+                    const bVal = bParts[i] || 0;
+                    if (aVal !== bVal) return bVal - aVal;
+                }
+                return 0;
+            });
+
+        const distTags = response.data['dist-tags'] || {};
+        
+        return {
+            versions: versions,
+            latest: distTags.latest,
+            lts: distTags.lts
+        };
+    } catch (error) {
+        console.error('Error fetching Angular versions:', error.message);
+        return { versions: [], latest: null, lts: null };
+    }
+}
+
+/**
+ * Get unique major versions from all Angular versions
+ */
+export function getMajorVersions(versions) {
+    const majorVersions = new Set();
+    
+    versions.forEach(version => {
+        const major = version.split('.')[0];
+        majorVersions.add(major);
+    });
+    
+    return Array.from(majorVersions).sort((a, b) => Number(b) - Number(a));
+}
+
+/**
+ * Get minor versions for a specific major version
+ */
+export function getMinorVersionsForMajor(versions, major) {
+    const minorVersions = new Set();
+    
+    versions
+        .filter(v => v.startsWith(`${major}.`))
+        .forEach(version => {
+            const parts = version.split('.');
+            const minorVersion = `${parts[0]}.${parts[1]}`;
+            minorVersions.add(minorVersion);
+        });
+    
+    return Array.from(minorVersions).sort((a, b) => {
+        const aParts = a.split('.').map(Number);
+        const bParts = b.split('.').map(Number);
+        for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+            const aVal = aParts[i] || 0;
+            const bVal = bParts[i] || 0;
+            if (aVal !== bVal) return bVal - aVal;
+        }
+        return 0;
+    });
+}
+
+/**
+ * Get patch versions for a specific major.minor version
+ */
+export function getPatchVersionsForMinor(versions, majorMinor) {
+    return versions
+        .filter(v => v.startsWith(`${majorMinor}.`))
+        .sort((a, b) => {
+            const aParts = a.split('.').map(Number);
+            const bParts = b.split('.').map(Number);
+            for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+                const aVal = aParts[i] || 0;
+                const bVal = bParts[i] || 0;
+                if (aVal !== bVal) return bVal - aVal;
+            }
+            return 0;
+        });
+}
+
+/**
+ * Get all versions of a specific npm package
+ */
+export async function getPackageVersions(packageName) {
+    try {
+        const response = await axios.get(`${NPM_REGISTRY_URL}/${packageName}`, {
+            timeout: 10000
+        });
+
+        const versions = Object.keys(response.data.versions || {})
+            .filter(v => !v.includes('rc') && !v.includes('beta') && !v.includes('next') && !v.includes('alpha'))
+            .sort((a, b) => {
+                // Sort in descending order (newest first)
+                const aParts = a.split('.').map(Number);
+                const bParts = b.split('.').map(Number);
+                
+                for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+                    const aVal = aParts[i] || 0;
+                    const bVal = bParts[i] || 0;
+                    if (aVal !== bVal) return bVal - aVal;
+                }
+                return 0;
+            });
+
+        const distTags = response.data['dist-tags'] || {};
+        
+        return {
+            versions: versions,
+            latest: distTags.latest,
+            lts: distTags.lts
+        };
+    } catch (error) {
+        console.error(`Error fetching versions for ${packageName}:`, error.message);
+        return { versions: [], latest: null, lts: null };
+    }
+}
+
+/**
+ * Get Node.js version requirements for Angular version
+ */
+export async function getNodeRequirementsForAngular(angularVersion) {
+    try {
+        const response = await axios.get(`${NPM_REGISTRY_URL}/@angular/cli/${angularVersion}`, {
+            timeout: 5000
+        });
+
+        const engines = response.data.engines || {};
+        const nodeRequirement = engines.node || '^18.13.0 || ^20.9.0';
+        
+        return nodeRequirement;
+    } catch (error) {
+        // Default Node requirements if we can't fetch
+        const majorVersion = parseInt(angularVersion.split('.')[0]);
+        
+        if (majorVersion >= 17) return '^18.13.0 || ^20.9.0';
+        if (majorVersion >= 16) return '^16.14.0 || ^18.10.0';
+        if (majorVersion >= 15) return '^14.20.0 || ^16.13.0 || ^18.10.0';
+        if (majorVersion >= 14) return '^14.15.0 || ^16.10.0';
+        
+        return '^14.0.0 || ^16.0.0 || ^18.0.0';
+    }
+}
+
+/**
+ * Get peer dependencies for a specific package version
+ */
+export async function getPackagePeerDependencies(packageName, version) {
+    try {
+        const response = await axios.get(`${NPM_REGISTRY_URL}/${packageName}/${version}`, {
+            timeout: 5000
+        });
+
+        return response.data.peerDependencies || {};
+    } catch (error) {
+        console.error(`Error fetching peer dependencies for ${packageName}@${version}:`, error.message);
+        return {};
+    }
+}
+
+/**
+ * Find compatible versions of a package for given Angular version
+ */
+export async function findCompatiblePackageVersions(packageName, angularVersion, maxResults = 5) {
+    try {
+        const packageData = await getPackageVersions(packageName);
+        const angularMajor = angularVersion.split('.')[0];
+        const compatibleVersions = [];
+
+        // Check versions from newest to oldest
+        for (const version of packageData.versions) {
+            if (compatibleVersions.length >= maxResults) break;
+
+            const peerDeps = await getPackagePeerDependencies(packageName, version);
+            
+            // Check if this version is compatible with the Angular version
+            if (peerDeps['@angular/core'] || peerDeps['@angular/common']) {
+                const angularDep = peerDeps['@angular/core'] || peerDeps['@angular/common'];
+                
+                // Simple check: see if the Angular major version is mentioned in the peer dependency
+                if (angularDep.includes(`^${angularMajor}.`) || 
+                    angularDep.includes(`~${angularMajor}.`) || 
+                    angularDep.includes(`>=${angularMajor}.`) ||
+                    angularDep.includes(`${angularMajor}.x`)) {
+                    compatibleVersions.push({
+                        version: version,
+                        peerDependency: angularDep
+                    });
+                }
+            } else {
+                // Package doesn't have Angular peer dependencies, it's likely compatible
+                compatibleVersions.push({
+                    version: version,
+                    peerDependency: 'No Angular peer dependency'
+                });
+            }
+        }
+
+        return compatibleVersions;
+    } catch (error) {
+        console.error(`Error finding compatible versions for ${packageName}:`, error.message);
+        return [];
+    }
+}