@hed-hog/cli 0.0.27 → 0.0.30

package/dist/src/modules/developer/developer.service.js

@@ -38,7 +38,407 @@ let DeveloperService = class DeveloperService {
             console.log('\n', ...args);
         }
     }
+    suppressWarnings() {
+        const originalEmitWarning = process.emitWarning;
+        process.emitWarning = () => { };
+        return () => {
+            process.emitWarning = originalEmitWarning;
+        };
+    }
+    async syncPublish(path, verbose = false) {
+        const restoreWarnings = this.suppressWarnings();
+        this.verbose = verbose;
+        path = await this.getRootPath(path);
+        const spinner = ora('Syncing and publishing libraries...').start();
+        const startTime = Date.now();
+        try {
+            const librariesPath = pathModule.join(path, 'libraries');
+            if (!(0, fs_1.existsSync)(librariesPath)) {
+                spinner.fail('Libraries directory not found.');
+                console.log(chalk.yellow('\nNo libraries directory found. Please create some libraries first.'));
+                return;
+            }
+            spinner.text = 'Scanning libraries...';
+            const libraries = [];
+            const libraryDirs = (0, fs_1.readdirSync)(librariesPath, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => pathModule.join(librariesPath, entry.name));
+            for (const libDir of libraryDirs) {
+                const packageJsonPath = pathModule.join(libDir, 'package.json');
+                if (!(0, fs_1.existsSync)(packageJsonPath)) {
+                    this.log(chalk.yellow(`Skipping ${libDir} - no package.json found`));
+                    continue;
+                }
+                const packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonPath, 'utf8'));
+                if (!packageJson.name || !packageJson.version) {
+                    this.log(chalk.yellow(`Skipping ${pathModule.basename(libDir)} - missing name or version in package.json`));
+                    continue;
+                }
+                libraries.push({
+                    path: packageJsonPath,
+                    name: packageJson.name,
+                    version: packageJson.version,
+                    directory: libDir,
+                    packageJsonPath,
+                });
+            }
+            if (libraries.length === 0) {
+                spinner.fail('No valid libraries found.');
+                console.log(chalk.yellow('\nNo valid libraries found in the libraries directory.'));
+                return;
+            }
+            spinner.succeed(`Found ${libraries.length} libraries.`);
+            // Display found libraries
+            console.log(chalk.green.bold('\n📦 Found Libraries:\n'));
+            for (const lib of libraries) {
+                console.log(`  ${chalk.cyan(lib.name)} - ${chalk.gray(`v${lib.version}`)}`);
+            }
+            // Find highest version
+            spinner.start('Calculating new version...');
+            let highestVersion = libraries[0].version;
+            for (const lib of libraries) {
+                if (this.compareVersions(lib.version, highestVersion) > 0) {
+                    highestVersion = lib.version;
+                }
+            }
+            const newVersion = this.incrementPatchVersion(highestVersion);
+            spinner.succeed(`Version calculated: ${chalk.gray(`v${highestVersion}`)} → ${chalk.green(`v${newVersion}`)}`);
+            console.log(chalk.blue(`\n🎯 Current highest version: v${highestVersion}`));
+            console.log(chalk.green(`✨ New synchronized version: v${newVersion}\n`));
+            // Update all package.json files
+            spinner.start('Updating package.json files...');
+            for (const lib of libraries) {
+                const packageJson = JSON.parse(await (0, promises_1.readFile)(lib.packageJsonPath, 'utf8'));
+                packageJson.version = newVersion;
+                await (0, promises_1.writeFile)(lib.packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+                this.log(chalk.gray(`  ✅ ${lib.name} updated to v${newVersion}`));
+            }
+            spinner.succeed(`All libraries synchronized to version ${chalk.green(`v${newVersion}`)}`);
+            // Build and publish all libraries
+            console.log(chalk.green.bold('\n🔨 Building and Publishing Libraries:\n'));
+            let successCount = 0;
+            let failCount = 0;
+            const failedLibraries = [];
+            for (const lib of libraries) {
+                spinner.start(`Processing ${chalk.cyan(lib.name)}...`);
+                try {
+                    // Install dependencies
+                    spinner.text = `${chalk.cyan(lib.name)}: Installing dependencies...`;
+                    await this.runner.executeCommand(runner_service_1.ProgramName.PNPM, ['install'], { cwd: lib.directory }, true);
+                    // Build
+                    spinner.text = `${chalk.cyan(lib.name)}: Building...`;
+                    await this.runner.executeCommand(runner_service_1.ProgramName.PNPM, ['run', 'build'], { cwd: lib.directory }, true);
+                    // Publish
+                    spinner.text = `${chalk.cyan(lib.name)}: Publishing to npm...`;
+                    await this.runner.executeCommand(runner_service_1.ProgramName.PNPM, ['publish', '--access', 'public', '--no-git-checks'], { cwd: lib.directory }, true);
+                    successCount++;
+                    spinner.succeed(`${chalk.cyan(lib.name)} ${chalk.green('✓')} Built and published successfully`);
+                }
+                catch (error) {
+                    failCount++;
+                    failedLibraries.push(lib.name);
+                    spinner.fail(`${chalk.cyan(lib.name)} ${chalk.red('✗')} Failed`);
+                    this.log(chalk.red(`Error: ${error.message}`));
+                }
+            }
+            // Summary
+            const endTime = Date.now();
+            const duration = ((endTime - startTime) / 1000).toFixed(2);
+            console.log(chalk.gray('\n' + '═'.repeat(60)));
+            console.log(chalk.green.bold('\n📊 Deployment Summary:\n'));
+            console.log(chalk.green(`  ✅ Successfully published: ${successCount}/${libraries.length}`));
+            if (failCount > 0) {
+                console.log(chalk.red(`  ❌ Failed: ${failCount}/${libraries.length}`));
+                console.log(chalk.red('\n  Failed libraries:'));
+                for (const name of failedLibraries) {
+                    console.log(chalk.red(`    • ${name}`));
+                }
+            }
+            console.log(chalk.blue(`  ⏱️  Total time: ${duration}s`));
+            console.log(chalk.gray('\n' + '═'.repeat(60) + '\n'));
+            if (failCount > 0) {
+                throw new Error(`${failCount} library(ies) failed to publish`);
+            }
+            await this.showLibraryVersions(path, verbose);
+        }
+        catch (error) {
+            spinner.fail('Failed to sync and publish libraries.');
+            console.error(chalk.red('Error syncing and publishing libraries:'), error);
+            throw error;
+        }
+        finally {
+            restoreWarnings();
+            spinner.stop();
+        }
+    }
+    async showLibraryVersions(path, verbose = false) {
+        const restoreWarnings = this.suppressWarnings();
+        this.verbose = verbose;
+        path = await this.getRootPath(path);
+        const spinner = ora('Checking library versions...').start();
+        try {
+            const librariesPath = pathModule.join(path, 'libraries');
+            if (!(0, fs_1.existsSync)(librariesPath)) {
+                spinner.fail('Libraries directory not found.');
+                console.log(chalk.yellow('\nNo libraries directory found. Please create some libraries first.'));
+                return;
+            }
+            spinner.text = 'Scanning libraries...';
+            // Get all library directories
+            const libraryDirs = (0, fs_1.readdirSync)(librariesPath, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => pathModule.join(librariesPath, entry.name));
+            if (libraryDirs.length === 0) {
+                spinner.fail('No libraries found.');
+                console.log(chalk.yellow('\nNo libraries found in the libraries directory.'));
+                return;
+            }
+            spinner.succeed(`Found ${libraryDirs.length} libraries.`);
+            spinner.start('Checking package versions...');
+            const results = [];
+            for (const libDir of libraryDirs) {
+                const packageJsonPath = pathModule.join(libDir, 'package.json');
+                if (!(0, fs_1.existsSync)(packageJsonPath)) {
+                    this.log(chalk.yellow(`Skipping ${libDir} - no package.json found`));
+                    continue;
+                }
+                const packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonPath, 'utf8'));
+                const libraryFolder = pathModule.basename(libDir);
+                const packageName = packageJson.name;
+                const currentVersion = packageJson.version;
+                if (!packageName || !currentVersion) {
+                    this.log(chalk.yellow(`Skipping ${libraryFolder} - missing name or version in package.json`));
+                    continue;
+                }
+                spinner.text = `Checking ${packageName}...`;
+                try {
+                    // Get latest version from npm
+                    const result = await this.runner.executeCommand(runner_service_1.ProgramName.NPM, ['view', packageName, 'version'], {}, true);
+                    const latestVersion = result.stdout.trim();
+                    const status = currentVersion === latestVersion ? 'ok' : 'outdated';
+                    results.push({
+                        libraryFolder,
+                        packageName,
+                        currentVersion,
+                        latestVersion,
+                        status,
+                    });
+                }
+                catch (error) {
+                    // Check if package is not published
+                    if (error.message &&
+                        (error.message.includes('404') ||
+                            error.message.includes('E404') ||
+                            error.message.includes('Not Found'))) {
+                        results.push({
+                            libraryFolder,
+                            packageName,
+                            currentVersion,
+                            latestVersion: 'N/A',
+                            status: 'unpublished',
+                        });
+                    }
+                    else {
+                        results.push({
+                            libraryFolder,
+                            packageName,
+                            currentVersion,
+                            latestVersion: 'N/A',
+                            status: 'error',
+                        });
+                    }
+                }
+            }
+            spinner.succeed('Version check completed.');
+            // Display results in a table
+            console.log(chalk.green.bold('\n📦 Library Package Versions:\n'));
+            if (results.length === 0) {
+                console.log(chalk.yellow('No packages found in libraries.'));
+                return;
+            }
+            console.log(chalk.gray('─'.repeat(100)));
+            // Table header
+            const folderHeader = 'Folder'.padEnd(20);
+            const nameHeader = 'Package Name'.padEnd(40);
+            const currentHeader = 'Current'.padEnd(15);
+            const latestHeader = 'Latest'.padEnd(15);
+            const statusHeader = 'Status';
+            console.log(chalk.white.bold(`${folderHeader} ${nameHeader} ${currentHeader} ${latestHeader} ${statusHeader}`));
+            console.log(chalk.gray('─'.repeat(100)));
+            // Table rows
+            for (const pkg of results) {
+                const folder = pkg.libraryFolder.padEnd(20);
+                const name = pkg.packageName.padEnd(40);
+                const current = pkg.currentVersion.padEnd(15);
+                const latest = pkg.latestVersion.padEnd(15);
+                let statusText = '';
+                if (pkg.status === 'ok') {
+                    statusText = chalk.green('✓ Up to date');
+                }
+                else if (pkg.status === 'outdated') {
+                    statusText = chalk.yellow('⚠ Update available');
+                }
+                else if (pkg.status === 'unpublished') {
+                    statusText = chalk.blue('ℹ Not published');
+                }
+                else {
+                    statusText = chalk.red('✗ Error');
+                }
+                console.log(`${folder} ${name} ${current} ${latest} ${statusText}`);
+            }
+            // Summary
+            const outdatedCount = results.filter((r) => r.status === 'outdated').length;
+            const okCount = results.filter((r) => r.status === 'ok').length;
+            const unpublishedCount = results.filter((r) => r.status === 'unpublished').length;
+            const errorCount = results.filter((r) => r.status === 'error').length;
+            console.log(chalk.gray('\n' + '─'.repeat(100)));
+            console.log(chalk.white.bold('\nSummary:'));
+            console.log(chalk.green(`  ✓ Up to date: ${okCount}`));
+            console.log(chalk.yellow(`  ⚠ Updates available: ${outdatedCount}`));
+            console.log(chalk.blue(`  ℹ Not published: ${unpublishedCount}`));
+            if (errorCount > 0) {
+                console.log(chalk.red(`  ✗ Errors: ${errorCount}`));
+            }
+            console.log('');
+        }
+        catch (error) {
+            spinner.fail('Failed to check library versions.');
+            console.error(chalk.red('Error checking library versions:'), error);
+            throw error;
+        }
+        finally {
+            restoreWarnings();
+            spinner.stop();
+        }
+    }
+    async updateBootstrapFiles(path, verbose = false) {
+        const restoreWarnings = this.suppressWarnings();
+        this.verbose = verbose;
+        const spinner = ora('Updating bootstrap files...').start();
+        try {
+            path = await this.getRootPath(path);
+            const templatePath = pathModule.join(pathModule.dirname(path), 'template');
+            this.log(chalk.blue(`Source path: ${path}`));
+            this.log(chalk.blue(`Template path: ${templatePath}`));
+            // Clean template directory but keep .git
+            spinner.start('Cleaning template directory...');
+            if ((0, fs_1.existsSync)(templatePath)) {
+                const gitPath = pathModule.join(templatePath, '.git');
+                const hasGit = (0, fs_1.existsSync)(gitPath);
+                // Remove all items except .git directory
+                const entries = (0, fs_1.readdirSync)(templatePath, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name === '.git') {
+                        this.log(chalk.gray('Skipping .git directory'));
+                        continue;
+                    }
+                    const fullPath = pathModule.join(templatePath, entry.name);
+                    await this.fileSystem.remove(fullPath);
+                    this.log(chalk.gray(`Removed: ${entry.name}`));
+                }
+                this.log(chalk.gray('Cleaned template directory (preserved .git)'));
+            }
+            else {
+                await (0, promises_1.mkdir)(templatePath, { recursive: true });
+                this.log(chalk.blue('Template directory created.'));
+            }
+            spinner.succeed('Template directory cleaned.');
+            // Get all files tracked by git (respects .gitignore)
+            spinner.start('Getting list of files from repository...');
+            const result = await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['ls-files'], { cwd: path }, true);
+            const allFiles = result.stdout
+                .trim()
+                .split('\n')
+                .filter((f) => f.length > 0);
+            spinner.succeed(`Found ${allFiles.length} files in repository.`);
+            spinner.start('Filtering files...');
+            // Filter files from apps folder - only keep api and admin
+            const allowedAppsFolders = ['api', 'admin'];
+            const ignoredAppsFolders = new Set();
+            const files = allFiles.filter((file) => {
+                // Check if file is in apps directory
+                if (file.startsWith('apps/') || file.startsWith('apps\\')) {
+                    const parts = file.split(/[/\\]/);
+                    if (parts.length > 1) {
+                        const appFolder = parts[1];
+                        if (!allowedAppsFolders.includes(appFolder)) {
+                            ignoredAppsFolders.add(appFolder);
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            });
+            spinner.succeed('Files filtered.');
+            // Display ignored folders
+            if (ignoredAppsFolders.size > 0) {
+                spinner.info(chalk.blue(`Ignored apps folders: ${Array.from(ignoredAppsFolders).join(', ')}`));
+                spinner.start('Copying files...');
+            }
+            this.log(chalk.blue(`Found ${files.length} files to copy (${allFiles.length - files.length} files ignored)`));
+            // Copy each file maintaining directory structure
+            spinner.start('Copying files...');
+            let copiedCount = 0;
+            for (const file of files) {
+                const sourcePath = pathModule.join(path, file);
+                const destPath = pathModule.join(templatePath, file);
+                // Create directory if it doesn't exist
+                const destDir = pathModule.dirname(destPath);
+                if (!(0, fs_1.existsSync)(destDir)) {
+                    await (0, promises_1.mkdir)(destDir, { recursive: true });
+                }
+                // Copy file
+                await this.fileSystem.copyFile(sourcePath, destPath);
+                copiedCount++;
+                if (verbose && copiedCount % 100 === 0) {
+                    spinner.text = `Copying files... (${copiedCount}/${files.length})`;
+                }
+            }
+            // Commit and push changes to git
+            spinner.start('Committing changes to git...');
+            try {
+                await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['add', '.'], { cwd: templatePath }, true);
+                // Check if there are changes to commit
+                const statusResult = await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['status', '--porcelain'], { cwd: templatePath }, true);
+                if (statusResult.stdout.trim().length > 0) {
+                    const now = new Date();
+                    const dateStr = now.toLocaleDateString('en-US', {
+                        year: 'numeric',
+                        month: 'short',
+                        day: 'numeric',
+                    });
+                    const timeStr = now.toLocaleTimeString('en-US', {
+                        hour: '2-digit',
+                        minute: '2-digit',
+                    });
+                    const commitMessage = `chore: update bootstrap files - ${dateStr} at ${timeStr}`;
+                    await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['commit', '-m', commitMessage], { cwd: templatePath }, true);
+                    spinner.text = 'Pushing changes to remote repository...';
+                    await this.runner.executeCommand(runner_service_1.ProgramName.GIT, ['push'], { cwd: templatePath }, true);
+                    spinner.succeed(`Bootstrap files updated successfully. ${copiedCount} files copied and pushed to ${templatePath}`);
+                }
+                else {
+                    spinner.succeed(`Bootstrap files updated successfully. ${copiedCount} files copied (no changes to commit)`);
+                }
+            }
+            catch (gitError) {
+                spinner.warn(`Bootstrap files copied (${copiedCount} files) but git operations failed. You may need to commit manually.`);
+                this.log(chalk.yellow('Git error:'), gitError.message);
+            }
+            this.log(chalk.green(`Successfully copied ${copiedCount} files to template directory.`));
+        }
+        catch (error) {
+            spinner.fail('Failed to update bootstrap files.');
+            console.error(chalk.red('Error updating bootstrap files:'), error);
+            throw error;
+        }
+        finally {
+            restoreWarnings();
+            spinner.stop();
+        }
+    }
     async route(path, verbose = false) {
+        const restoreWarnings = this.suppressWarnings();
         this.verbose = verbose;
         const spinner = ora('Analyzing NestJS routes...').start();
         try {
@@ -94,6 +494,7 @@ let DeveloperService = class DeveloperService {
             throw error;
         }
         finally {
+            restoreWarnings();
             spinner.stop();
         }
     }
@@ -214,6 +615,32 @@ let DeveloperService = class DeveloperService {
         };
         return colors[method] || chalk.white;
     }
+    parseVersion(version) {
+        const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+        if (!match) {
+            throw new Error(`Invalid version format: ${version}`);
+        }
+        return {
+            major: parseInt(match[1], 10),
+            minor: parseInt(match[2], 10),
+            patch: parseInt(match[3], 10),
+        };
+    }
+    compareVersions(v1, v2) {
+        const parsed1 = this.parseVersion(v1);
+        const parsed2 = this.parseVersion(v2);
+        if (parsed1.major !== parsed2.major) {
+            return parsed1.major - parsed2.major;
+        }
+        if (parsed1.minor !== parsed2.minor) {
+            return parsed1.minor - parsed2.minor;
+        }
+        return parsed1.patch - parsed2.patch;
+    }
+    incrementPatchVersion(version) {
+        const parsed = this.parseVersion(version);
+        return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+    }
     async createLibrary(path, libraryName, force = false, verbose = false, skipInstall = false) {
         this.verbose = verbose;
         this.log(chalk.blue('Starting library creation...'));
@@ -388,6 +815,7 @@ let DeveloperService = class DeveloperService {
             .replace(/-/g, '_');
     }
     async resetDevelopmentEnvironment(cwd, verbose = false) {
+        const restoreWarnings = this.suppressWarnings();
         this.verbose = verbose;
         const spinner = ora('Resetting development environment...').start();
         try {
@@ -404,6 +832,7 @@ let DeveloperService = class DeveloperService {
             throw error;
         }
         finally {
+            restoreWarnings();
             spinner.stop();
         }
     }
@@ -553,6 +982,7 @@ let DeveloperService = class DeveloperService {
         }
     }
     async backupDatabase(cwd, verbose = false) {
+        const restoreWarnings = this.suppressWarnings();
         this.verbose = verbose;
         this.log('Backing up database...');
         const spinner = ora('Backing up database...').start();
@@ -624,10 +1054,12 @@ let DeveloperService = class DeveloperService {
             throw error;
         }
         finally {
+            restoreWarnings();
             spinner.stop();
         }
     }
     async initDatabase(cwd, verbose = false) {
+        const restoreWarnings = this.suppressWarnings();
         this.verbose = verbose;
         this.log('Initializing database...');
         const spinner = ora('Initializing database...').start();
@@ -687,10 +1119,12 @@ let DeveloperService = class DeveloperService {
             throw error;
         }
         finally {
+            restoreWarnings();
             spinner.stop();
         }
     }
     async restoreDatabase(cwd, verbose = false) {
+        const restoreWarnings = this.suppressWarnings();
         this.verbose = verbose;
         this.log('Restoring database from backup...');
         const spinner = ora('Restoring database from backup...').start();
@@ -886,9 +1320,49 @@ let DeveloperService = class DeveloperService {
             throw error;
         }
         finally {
+            restoreWarnings();
             spinner.stop();
         }
     }
+    async listHedHogPackages() {
+        const restoreWarnings = this.suppressWarnings();
+        const spinner = ora('Fetching @hed-hog packages...').start();
+        try {
+            // Fetch packages from npm registry
+            const response = await fetch('https://registry.npmjs.org/-/v1/search?text=scope:hed-hog&size=250');
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            const packages = data.objects;
+            spinner.succeed(chalk.green(`Found ${packages.length} package(s) in @hed-hog:`));
+            if (packages.length === 0) {
+                console.log(chalk.yellow('\nNo packages found.'));
+                return;
+            }
+            console.log('');
+            // Sort packages alphabetically by name
+            packages.sort((a, b) => a.package.name.localeCompare(b.package.name));
+            // Display packages in a formatted table
+            packages.forEach((pkg) => {
+                const name = chalk.cyan(pkg.package.name);
+                const version = chalk.gray(`v${pkg.package.version}`);
+                const description = pkg.package.description || chalk.gray('No description');
+                console.log(`${name} ${version}`);
+                console.log(`  ${description}`);
+                console.log('');
+            });
+            console.log(chalk.gray(`Total: ${packages.length} package(s)`));
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch packages.');
+            console.error(chalk.red('Error:'), error.message);
+            throw error;
+        }
+        finally {
+            restoreWarnings();
+        }
+    }
 };
 exports.DeveloperService = DeveloperService;
 exports.DeveloperService = DeveloperService = __decorate([