@gadmin2n/cli 0.0.86 → 0.0.88

package/actions/index.d.ts

@@ -3,6 +3,7 @@ export * from './build.action';
 export * from './generate.action';
 export * from './info.action';
 export * from './new.action';
+export * from './template.action';
 export * from './update.action';
 export * from './start.action';
 export * from './add.action';

package/actions/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./build.action"), exports);
 __exportStar(require("./generate.action"), exports);
 __exportStar(require("./info.action"), exports);
 __exportStar(require("./new.action"), exports);
+__exportStar(require("./template.action"), exports);
 __exportStar(require("./update.action"), exports);
 __exportStar(require("./start.action"), exports);
 __exportStar(require("./add.action"), exports);

package/actions/template.action.d.ts

@@ -0,0 +1,7 @@
+import { Input } from '../commands';
+import { AbstractAction } from './abstract.action';
+export declare class TemplateAction extends AbstractAction {
+    handle(inputs: Input[], options: Input[]): Promise<void>;
+    private handleDiff;
+    private handleUpdate;
+}

package/actions/template.action.js

@@ -0,0 +1,570 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateAction = void 0;
+const chalk = require("chalk");
+const fs = require("fs");
+const path = require("path");
+const inquirer = require("inquirer");
+const child_process_1 = require("child_process");
+const abstract_action_1 = require("./abstract.action");
+const DEFAULT_EXCLUDES = [
+    'node_modules',
+    '.git',
+    'dist',
+    'generated',
+    '.DS_Store',
+    '.env.local',
+    'readme.md'
+];
+/**
+ * Convert a glob pattern to a RegExp.
+ * Supports: * (any chars except /), ** (any path segments), ? (single char)
+ */
+function globToRegex(pattern) {
+    let regexStr = '^';
+    let i = 0;
+    while (i < pattern.length) {
+        const c = pattern[i];
+        if (c === '*') {
+            if (pattern[i + 1] === '*') {
+                // ** matches any path segments
+                if (pattern[i + 2] === '/') {
+                    regexStr += '(?:.+/)?';
+                    i += 3;
+                }
+                else {
+                    regexStr += '.*';
+                    i += 2;
+                }
+            }
+            else {
+                // * matches anything except /
+                regexStr += '[^/]*';
+                i++;
+            }
+        }
+        else if (c === '?') {
+            regexStr += '[^/]';
+            i++;
+        }
+        else if (c === '.' || c === '(' || c === ')' || c === '[' || c === ']' || c === '{' || c === '}' || c === '+' || c === '^' || c === '$' || c === '|' || c === '\\') {
+            regexStr += '\\' + c;
+            i++;
+        }
+        else {
+            regexStr += c;
+            i++;
+        }
+    }
+    regexStr += '$';
+    return new RegExp(regexStr);
+}
+function matchesPattern(filePath, pattern) {
+    // Exact match or directory prefix match
+    if (filePath === pattern)
+        return true;
+    if (filePath.startsWith(pattern + '/'))
+        return true;
+    // Check each path segment for exact match (e.g. "node_modules" matches "a/node_modules/b")
+    const parts = filePath.split('/');
+    if (!pattern.includes('/') && !pattern.includes('*') && !pattern.includes('?')) {
+        if (parts.includes(pattern))
+            return true;
+    }
+    // Glob pattern matching
+    if (pattern.includes('*') || pattern.includes('?')) {
+        const regex = globToRegex(pattern);
+        return regex.test(filePath);
+    }
+    return false;
+}
+function loadTemplateConfig() {
+    const configPaths = [
+        path.join(process.cwd(), 'server/gadmin-cli.json'),
+        path.join(process.cwd(), 'gadmin-cli.json'),
+    ];
+    let templateName;
+    let userExcludes = [];
+    for (const configPath of configPaths) {
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            templateName = config.template;
+            if (Array.isArray(config.templateExcludes)) {
+                userExcludes = config.templateExcludes;
+            }
+            break;
+        }
+    }
+    if (!templateName) {
+        throw new Error('Cannot find "template" field in gadmin-cli.json. ' +
+            'Make sure you are in a gadmin2 project root directory.');
+    }
+    return {
+        templateName,
+        excludes: [...DEFAULT_EXCLUDES, ...userExcludes],
+    };
+}
+function shouldExclude(filePath, excludes) {
+    for (const pattern of excludes) {
+        if (matchesPattern(filePath, pattern))
+            return true;
+    }
+    return false;
+}
+function collectFiles(dir, excludes, base = '') {
+    const results = [];
+    const entries = fs.readdirSync(path.join(dir, base), { withFileTypes: true });
+    for (const entry of entries) {
+        const rel = base ? `${base}/${entry.name}` : entry.name;
+        if (shouldExclude(rel, excludes))
+            continue;
+        if (entry.isDirectory()) {
+            results.push(...collectFiles(dir, excludes, rel));
+        }
+        else if (entry.isFile()) {
+            results.push(rel);
+        }
+    }
+    return results.sort();
+}
+function resolveTemplatePath(templateName) {
+    // Resolve @gadmin2n/schematics package path
+    // Try multiple locations: project's node_modules, CLI's own node_modules
+    let schematicsRoot;
+    const searchPaths = [
+        process.cwd(),
+        path.join(process.cwd(), 'server'),
+        path.resolve(__dirname, '..'), // CLI package root
+    ];
+    for (const searchPath of searchPaths) {
+        try {
+            const pkgPath = require.resolve('@gadmin2n/schematics/package.json', {
+                paths: [searchPath],
+            });
+            schematicsRoot = path.dirname(pkgPath);
+            break;
+        }
+        catch (_a) {
+            // continue trying next path
+        }
+    }
+    if (!schematicsRoot) {
+        throw new Error('Cannot resolve @gadmin2n/schematics package. ' +
+            'Make sure it is installed.');
+    }
+    // Check dist path first (published package), then src path (yalc/dev link)
+    // Also try with name variants (gadmin2n → gadmin2) for backward compatibility
+    const nameVariants = [templateName];
+    if (templateName.startsWith('gadmin2n-')) {
+        nameVariants.push(templateName.replace('gadmin2n-', 'gadmin2-'));
+    }
+    else if (templateName.startsWith('gadmin2-')) {
+        nameVariants.push(templateName.replace('gadmin2-', 'gadmin2n-'));
+    }
+    for (const name of nameVariants) {
+        const distPath = path.join(schematicsRoot, 'dist/lib/application/files', name);
+        const srcPath = path.join(schematicsRoot, 'src/lib/application/files', name);
+        if (fs.existsSync(distPath))
+            return distPath;
+        if (fs.existsSync(srcPath))
+            return srcPath;
+    }
+    throw new Error(`Template directory not found for "${templateName}" in ${schematicsRoot}`);
+}
+function createUnifiedDiff(filePath, instanceContent, templateContent) {
+    const instanceLines = instanceContent.split('\n');
+    const templateLines = templateContent.split('\n');
+    // Simple line-by-line diff output
+    const lines = [];
+    lines.push(chalk.bold(`--- a/${filePath} (instance)`));
+    lines.push(chalk.bold(`+++ b/${filePath} (template)`));
+    // Find differing regions using a simple approach
+    const maxLen = Math.max(instanceLines.length, templateLines.length);
+    const hunks = [];
+    let currentHunk = null;
+    for (let i = 0; i < maxLen; i++) {
+        const a = i < instanceLines.length ? instanceLines[i] : undefined;
+        const b = i < templateLines.length ? templateLines[i] : undefined;
+        if (a !== b) {
+            if (!currentHunk) {
+                currentHunk = { start: i, instanceLines: [], templateLines: [] };
+            }
+            if (a !== undefined)
+                currentHunk.instanceLines.push(a);
+            if (b !== undefined)
+                currentHunk.templateLines.push(b);
+        }
+        else {
+            if (currentHunk) {
+                hunks.push(currentHunk);
+                currentHunk = null;
+            }
+        }
+    }
+    if (currentHunk)
+        hunks.push(currentHunk);
+    // Output hunks with context
+    for (const hunk of hunks.slice(0, 10)) { // Limit to first 10 hunks
+        const contextStart = Math.max(0, hunk.start - 2);
+        lines.push(chalk.cyan(`@@ -${hunk.start + 1},${hunk.instanceLines.length} +${hunk.start + 1},${hunk.templateLines.length} @@`));
+        // Context before
+        for (let i = contextStart; i < hunk.start; i++) {
+            if (i < instanceLines.length) {
+                lines.push(` ${instanceLines[i]}`);
+            }
+        }
+        // Removed lines (instance)
+        for (const line of hunk.instanceLines) {
+            lines.push(chalk.red(`-${line}`));
+        }
+        // Added lines (template)
+        for (const line of hunk.templateLines) {
+            lines.push(chalk.green(`+${line}`));
+        }
+        // Context after
+        const afterStart = hunk.start + Math.max(hunk.instanceLines.length, hunk.templateLines.length);
+        for (let i = afterStart; i < Math.min(afterStart + 2, instanceLines.length); i++) {
+            lines.push(` ${instanceLines[i]}`);
+        }
+    }
+    if (hunks.length > 10) {
+        lines.push(chalk.yellow(`  ... and ${hunks.length - 10} more hunks`));
+    }
+    return lines.join('\n');
+}
+function createConflictContent(instanceContent, templateContent) {
+    return [
+        '<<<<<<< INSTANCE',
+        instanceContent,
+        '=======',
+        templateContent,
+        '>>>>>>> TEMPLATE',
+    ].join('\n');
+}
+/**
+ * Attempt a 3-way merge using git merge-file with an empty base.
+ * Both instance and template are treated as "additions from nothing".
+ * Identical sections pass through cleanly; differing sections produce conflicts.
+ */
+function tryAutoMerge(instanceContent, templateContent) {
+    const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'gadmin-merge-'));
+    const basePath = path.join(tmpDir, 'base');
+    const oursPath = path.join(tmpDir, 'ours');
+    const theirsPath = path.join(tmpDir, 'theirs');
+    try {
+        fs.writeFileSync(basePath, '', 'utf-8');
+        fs.writeFileSync(oursPath, instanceContent, 'utf-8');
+        fs.writeFileSync(theirsPath, templateContent, 'utf-8');
+        try {
+            (0, child_process_1.execSync)(`git merge-file -L "INSTANCE" -L "BASE" -L "TEMPLATE" "${oursPath}" "${basePath}" "${theirsPath}"`, { stdio: 'pipe' });
+            const merged = fs.readFileSync(oursPath, 'utf-8');
+            return { merged, hasConflicts: false };
+        }
+        catch (err) {
+            if (err.status > 0) {
+                const merged = fs.readFileSync(oursPath, 'utf-8');
+                return { merged, hasConflicts: true };
+            }
+            return { merged: createConflictContent(instanceContent, templateContent), hasConflicts: true };
+        }
+    }
+    finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+class TemplateAction extends abstract_action_1.AbstractAction {
+    handle(inputs, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const subcommand = (_a = inputs.find((i) => i.name === 'subcommand')) === null || _a === void 0 ? void 0 : _a.value;
+            if (subcommand === 'diff') {
+                yield this.handleDiff(options);
+            }
+            else if (subcommand === 'update') {
+                yield this.handleUpdate(options);
+            }
+        });
+    }
+    handleDiff(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const noContent = (_a = options.find((o) => o.name === 'no-content')) === null || _a === void 0 ? void 0 : _a.value;
+            let templateDir;
+            let excludes;
+            try {
+                const config = loadTemplateConfig();
+                templateDir = resolveTemplatePath(config.templateName);
+                excludes = config.excludes;
+            }
+            catch (err) {
+                console.error(chalk.red(err.message));
+                process.exit(1);
+            }
+            const instanceDir = process.cwd();
+            console.info(`\n${chalk.gray('Template:')} ${templateDir}`);
+            console.info(`${chalk.gray('Instance:')} ${instanceDir}\n`);
+            const templateFiles = collectFiles(templateDir, excludes);
+            const instanceFiles = collectFiles(instanceDir, excludes);
+            const templateSet = new Set(templateFiles);
+            const instanceSet = new Set(instanceFiles);
+            // Modified: both have, content differs
+            const modified = [];
+            // Only in template (would be added on update)
+            const onlyInTemplate = [];
+            // Only in instance (instance-specific)
+            const onlyInInstance = [];
+            for (const file of templateFiles) {
+                if (instanceSet.has(file)) {
+                    const tContent = fs.readFileSync(path.join(templateDir, file), 'utf-8');
+                    const iContent = fs.readFileSync(path.join(instanceDir, file), 'utf-8');
+                    if (tContent !== iContent) {
+                        modified.push(file);
+                    }
+                }
+                else {
+                    onlyInTemplate.push(file);
+                }
+            }
+            for (const file of instanceFiles) {
+                if (!templateSet.has(file)) {
+                    onlyInInstance.push(file);
+                }
+            }
+            // Summary
+            console.info(chalk.bold('═══════════════════════════════════════════════════'));
+            console.info(chalk.bold('  Template Diff Summary'));
+            console.info(chalk.bold('═══════════════════════════════════════════════════\n'));
+            if (modified.length > 0) {
+                console.info(chalk.yellow(`📝 Modified (${modified.length} files)`));
+                for (const f of modified) {
+                    console.info(`   ${f}`);
+                }
+                console.info();
+            }
+            if (onlyInTemplate.length > 0) {
+                console.info(chalk.green(`➕ Only in template (${onlyInTemplate.length} files)`));
+                for (const f of onlyInTemplate) {
+                    console.info(`   ${f}`);
+                }
+                console.info();
+            }
+            if (onlyInInstance.length > 0) {
+                console.info(chalk.cyan(`📄 Only in instance (${onlyInInstance.length} files)`));
+                for (const f of onlyInInstance) {
+                    console.info(`   ${f}`);
+                }
+                console.info();
+            }
+            if (modified.length === 0 && onlyInTemplate.length === 0 && onlyInInstance.length === 0) {
+                console.info(chalk.green('✅ No differences found. Instance matches template.\n'));
+                return;
+            }
+            // Show diff content for modified files
+            if (!noContent && modified.length > 0) {
+                console.info(chalk.bold('───────────────────────────────────────────────────'));
+                console.info(chalk.bold('  File Diffs (instance vs template)'));
+                console.info(chalk.bold('───────────────────────────────────────────────────\n'));
+                for (const file of modified) {
+                    const tContent = fs.readFileSync(path.join(templateDir, file), 'utf-8');
+                    const iContent = fs.readFileSync(path.join(instanceDir, file), 'utf-8');
+                    const diff = createUnifiedDiff(file, iContent, tContent);
+                    console.info(diff);
+                    console.info();
+                }
+            }
+        });
+    }
+    handleUpdate(options) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const dryRun = (_a = options.find((o) => o.name === 'dry-run')) === null || _a === void 0 ? void 0 : _a.value;
+            const autoYes = (_b = options.find((o) => o.name === 'yes')) === null || _b === void 0 ? void 0 : _b.value;
+            let templateDir;
+            let excludes;
+            try {
+                const config = loadTemplateConfig();
+                templateDir = resolveTemplatePath(config.templateName);
+                excludes = config.excludes;
+            }
+            catch (err) {
+                console.error(chalk.red(err.message));
+                process.exit(1);
+            }
+            const instanceDir = process.cwd();
+            console.info(`\n${chalk.gray('Template:')} ${templateDir}`);
+            console.info(`${chalk.gray('Instance:')} ${instanceDir}\n`);
+            const templateFiles = collectFiles(templateDir, excludes);
+            const instanceFiles = collectFiles(instanceDir, excludes);
+            const instanceSet = new Set(instanceFiles);
+            // Categorize changes (template → instance direction)
+            const toUpdate = []; // exists in both, content differs
+            const toAdd = []; // only in template
+            for (const file of templateFiles) {
+                if (instanceSet.has(file)) {
+                    const tContent = fs.readFileSync(path.join(templateDir, file), 'utf-8');
+                    const iContent = fs.readFileSync(path.join(instanceDir, file), 'utf-8');
+                    if (tContent !== iContent) {
+                        toUpdate.push(file);
+                    }
+                }
+                else {
+                    toAdd.push(file);
+                }
+            }
+            if (toUpdate.length === 0 && toAdd.length === 0) {
+                console.info(chalk.green('✅ Instance is up to date with template.\n'));
+                return;
+            }
+            // Summary
+            console.info(chalk.bold('═══════════════════════════════════════════════════'));
+            console.info(chalk.bold('  Template Update Summary'));
+            console.info(chalk.bold('═══════════════════════════════════════════════════\n'));
+            if (toUpdate.length > 0) {
+                console.info(chalk.yellow(`📝 To update (${toUpdate.length} files)`));
+                for (const f of toUpdate) {
+                    console.info(`   ${f}`);
+                }
+                console.info();
+            }
+            if (toAdd.length > 0) {
+                console.info(chalk.green(`➕ To add (${toAdd.length} files)`));
+                for (const f of toAdd) {
+                    console.info(`   ${f}`);
+                }
+                console.info();
+            }
+            console.info(chalk.gray('───────────────────────────────────────────────────'));
+            console.info(chalk.gray(`  Total: ${toUpdate.length} update | ${toAdd.length} add`));
+            console.info(chalk.gray('───────────────────────────────────────────────────\n'));
+            if (dryRun) {
+                console.info(chalk.gray('(dry-run mode, no changes made)\n'));
+                return;
+            }
+            // Confirm proceed
+            if (!autoYes) {
+                const { confirm } = yield inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: 'Proceed with update?',
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    console.info('Cancelled.\n');
+                    return;
+                }
+            }
+            // Process modified files — per-file strategy selection
+            let skippedCount = 0;
+            let overwrittenCount = 0;
+            let mergedCount = 0;
+            let conflictCount = 0;
+            // Track "apply to all" choice
+            let applyAll = null;
+            for (let i = 0; i < toUpdate.length; i++) {
+                const file = toUpdate[i];
+                const tContent = fs.readFileSync(path.join(templateDir, file), 'utf-8');
+                const iContent = fs.readFileSync(path.join(instanceDir, file), 'utf-8');
+                let strategy = applyAll;
+                if (!strategy && !autoYes) {
+                    // Show brief diff summary
+                    const diff = createUnifiedDiff(file, iContent, tContent);
+                    console.info(`\n${chalk.bold(`[${i + 1}/${toUpdate.length}]`)} ${chalk.yellow(file)}`);
+                    console.info(diff);
+                    console.info();
+                    const { action } = yield inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'action',
+                            message: `How to handle ${file}?`,
+                            choices: [
+                                { name: 'Skip — keep instance as-is', value: 'skip', short: 'skip' },
+                                { name: 'Overwrite — use template version', value: 'overwrite', short: 'overwrite' },
+                                { name: 'Auto merge — attempt git merge', value: 'merge', short: 'merge' },
+                                { name: 'Conflict markers — write both versions for manual resolve', value: 'conflict', short: 'conflict' },
+                                new inquirer.Separator(),
+                                { name: 'Skip ALL remaining', value: 'skip-all', short: 'skip all' },
+                                { name: 'Overwrite ALL remaining', value: 'overwrite-all', short: 'overwrite all' },
+                                { name: 'Conflict markers ALL remaining', value: 'conflict-all', short: 'conflict all' },
+                            ],
+                        },
+                    ]);
+                    if (action.endsWith('-all')) {
+                        applyAll = action.replace('-all', '');
+                        strategy = applyAll;
+                    }
+                    else {
+                        strategy = action;
+                    }
+                }
+                else if (autoYes) {
+                    strategy = 'conflict';
+                }
+                // Execute strategy
+                const destPath = path.join(instanceDir, file);
+                switch (strategy) {
+                    case 'skip':
+                        skippedCount++;
+                        break;
+                    case 'overwrite':
+                        fs.writeFileSync(destPath, tContent, 'utf-8');
+                        overwrittenCount++;
+                        break;
+                    case 'merge': {
+                        const result = tryAutoMerge(iContent, tContent);
+                        fs.writeFileSync(destPath, result.merged, 'utf-8');
+                        if (result.hasConflicts) {
+                            conflictCount++;
+                            console.info(chalk.yellow(`   ⚠️  ${file} — merge has conflicts`));
+                        }
+                        else {
+                            mergedCount++;
+                            console.info(chalk.green(`   ✓  ${file} — merged cleanly`));
+                        }
+                        break;
+                    }
+                    case 'conflict':
+                    default:
+                        fs.writeFileSync(destPath, createConflictContent(iContent, tContent), 'utf-8');
+                        conflictCount++;
+                        break;
+                }
+            }
+            // Process new files (always add)
+            for (const file of toAdd) {
+                const destPath = path.join(instanceDir, file);
+                fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                fs.copyFileSync(path.join(templateDir, file), destPath);
+            }
+            // Final summary
+            console.info(chalk.bold('\n✅ Update complete!\n'));
+            const stats = [];
+            if (overwrittenCount > 0)
+                stats.push(`${overwrittenCount} overwritten`);
+            if (mergedCount > 0)
+                stats.push(`${mergedCount} merged`);
+            if (conflictCount > 0)
+                stats.push(`${conflictCount} with conflicts`);
+            if (skippedCount > 0)
+                stats.push(`${skippedCount} skipped`);
+            if (toAdd.length > 0)
+                stats.push(`${toAdd.length} added`);
+            console.info(`   ${stats.join(' | ')}\n`);
+            if (conflictCount > 0) {
+                console.info(chalk.yellow(`⚠️  ${conflictCount} files have conflict markers. ` +
+                    `Search for "<<<<<<< INSTANCE" to resolve them.\n`));
+            }
+        });
+    }
+}
+exports.TemplateAction = TemplateAction;

package/commands/command.loader.js

@@ -10,6 +10,7 @@ const generate_command_1 = require("./generate.command");
 const info_command_1 = require("./info.command");
 const new_command_1 = require("./new.command");
 const start_command_1 = require("./start.command");
+const template_command_1 = require("./template.command");
 const update_command_1 = require("./update.command");
 class CommandLoader {
     static load(program) {
@@ -18,6 +19,7 @@ class CommandLoader {
         new start_command_1.StartCommand(new actions_1.StartAction()).load(program);
         new info_command_1.InfoCommand(new actions_1.InfoAction()).load(program);
         new update_command_1.UpdateCommand(new actions_1.UpdateAction()).load(program);
+        new template_command_1.TemplateCommand(new actions_1.TemplateAction()).load(program);
         new add_command_1.AddCommand(new actions_1.AddAction()).load(program);
         new generate_command_1.GenerateCommand(new actions_1.GenerateAction()).load(program);
         this.handleInvalidCommand(program);

package/commands/template.command.d.ts

@@ -0,0 +1,5 @@
+import { CommanderStatic } from 'commander';
+import { AbstractCommand } from './abstract.command';
+export declare class TemplateCommand extends AbstractCommand {
+    load(program: CommanderStatic): void;
+}

package/commands/template.command.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateCommand = void 0;
+const abstract_command_1 = require("./abstract.command");
+class TemplateCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('template <subcommand>')
+            .alias('tpl')
+            .description('Compare or sync with the project template.')
+            .option('--no-content', 'Only show file list, skip inline diff content (for diff).')
+            .option('-d, --dry-run', 'Show what would be updated without making changes (for update).')
+            .option('-y, --yes', 'Skip confirmation prompt (for update).')
+            .action((subcommand, command) => __awaiter(this, void 0, void 0, function* () {
+            const inputs = [];
+            inputs.push({ name: 'subcommand', value: subcommand });
+            const options = [];
+            options.push({ name: 'no-content', value: !command.content });
+            options.push({ name: 'dry-run', value: !!command.dryRun });
+            options.push({ name: 'yes', value: !!command.yes });
+            yield this.action.handle(inputs, options);
+        }));
+    }
+}
+exports.TemplateCommand = TemplateCommand;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gadmin2n/cli",
-  "version": "0.0.86",
+  "version": "0.0.88",
   "description": "Gadmin - modern, fast, powerful node.js web framework (@cli)",
   "publishConfig": {
     "access": "public"
@@ -47,7 +47,7 @@
     "@angular-devkit/core": "13.3.2",
     "@angular-devkit/schematics": "13.3.2",
     "@angular-devkit/schematics-cli": "13.3.2",
-    "@gadmin2n/schematics": "^0.0.69",
+    "@gadmin2n/schematics": "^0.0.70",
     "abc": "^0.6.1",
     "chalk": "3.0.0",
     "chokidar": "3.5.3",

package/.circleci/config.yml

@@ -1,62 +0,0 @@
-version: 2
-
-aliases:
-  - &restore-cache
-    restore_cache:
-        key: dependency-cache-{{ checksum "package.json" }}
-  - &install-deps
-    run:
-        name: Install dependencies
-        command: npm ci
-  - &build-packages
-    run:
-        name: Build
-        command: npm run build
-  - &run-unit-tests
-    run:
-        name: Test
-        command: npm run test
-
-jobs:
-  build:
-    working_directory: ~/nest
-    docker:
-      - image: circleci/node:17
-    steps:
-      - checkout
-      - run:
-          name: Update NPM version
-          command: 'sudo npm install -g npm@latest'
-      - restore_cache:
-          key: dependency-cache-{{ checksum "package.json" }}
-      - run:
-          name: Install dependencies
-          command: npm ci
-      - save_cache:
-          key: dependency-cache-{{ checksum "package.json" }}
-          paths:
-            - ./node_modules
-      - run:
-          name: Build
-          command: npm run build    
-
-  unit_tests:
-    working_directory: ~/nest
-    docker:
-      - image: circleci/node:17
-    steps:
-      - checkout
-      - *restore-cache
-      - *install-deps
-      - *build-packages
-      - *run-unit-tests
-
-workflows:
-  version: 2
-  build-and-test:
-    jobs:
-      - build
-      - unit_tests:
-          requires:
-            - build
-      

package/.github/ISSUE_TEMPLATE/Bug_report.yml

@@ -1,106 +0,0 @@
-name: "\U0001F41B Bug Report"
-description: "If something isn't working as expected \U0001F914"
-labels: ["needs triage", "bug"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## :warning: We use GitHub Issues to track bug reports, feature requests and regressions
- 
-        If you are not sure that your issue is a bug, you could:
-
-        - use our [Discord community](https://discord.gg/NestJS)
-        - use [StackOverflow using the tag `nestjs`](https://stackoverflow.com/questions/tagged/nestjs)
-        - If it's just a quick question you can ping [our Twitter](https://twitter.com/nestframework)
-
-        **NOTE:** You don't need to answer questions that you know that aren't relevant.
-
-        ---
-
-  - type: checkboxes
-    attributes:
-      label: "Is there an existing issue for this?"
-      description: "Please search [here](./?q=is%3Aissue) to see if an issue already exists for the bug you encountered"
-      options:
-      - label: "I have searched the existing issues"
-        required: true
-
-  - type: textarea
-    validations:
-      required: true
-    attributes:
-      label: "Current behavior"
-      description: "How the issue manifests?"
-
-  - type: input
-    validations:
-      required: true
-    attributes:
-      label: "Minimum reproduction code"
-      description: "An URL to some git repository or gist that reproduces this issue. [Wtf is a minimum reproduction?](https://jmcdo29.github.io/wtf-is-a-minimum-reproduction)"
-      placeholder: "https://github.com/..."
-
-  - type: textarea
-    attributes:
-      label: "Steps to reproduce"
-      description: |
-        How the issue manifests?
-        You could leave this blank if you alread write this in your reproduction code/repo
-      placeholder: |
-        1. `npm i`
-        2. `npm start:dev`
-        3. See error...
-
-  - type: textarea
-    validations:
-      required: true
-    attributes:
-      label: "Expected behavior"
-      description: "A clear and concise description of what you expected to happend (or code)"
-
-  - type: markdown
-    attributes:
-      value: |
-        ---
-
-  - type: input
-    validations:
-      required: true
-    attributes:
-      label: "Package version"
-      description: |
-        Which version of `@nestjs/cli` are you using?
-        **Tip**: Make sure that all of yours `@nestjs/*` dependencies are in sync!
-      placeholder: "8.1.3"
-
-  - type: input
-    attributes:
-      label: "NestJS version"
-      description: "Which version of `@nestjs/core` are you using?"
-      placeholder: "8.1.3"
-
-  - type: input
-    attributes:
-      label: "Node.js version"
-      description: "Which version of Node.js are you using?"
-      placeholder: "14.17.6"
-
-  - type: checkboxes
-    attributes:
-      label: "In which operating systems have you tested?"
-      options:
-        - label: macOS
-        - label: Windows
-        - label: Linux
-
-  - type: markdown
-    attributes:
-      value: |
-        ---
-
-  - type: textarea
-    attributes:
-      label: "Other"
-      description: |
-        Anything else relevant? eg: Logs, OS version, IDE, package manager, etc.
-        **Tip:** You can attach images, recordings or log files by clicking this area to highlight it and then dragging files in

package/.github/ISSUE_TEMPLATE/Feature_request.yml

@@ -1,52 +0,0 @@
-name: "\U0001F680 Feature Request"
-description: "I have a suggestion \U0001F63B!"
-labels: ["feature"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## :warning: We use GitHub Issues to track bug reports, feature requests and regressions
- 
-        If you are not sure that your issue is a bug, you could:
-
-        - use our [Discord community](https://discord.gg/NestJS)
-        - use [StackOverflow using the tag `nestjs`](https://stackoverflow.com/questions/tagged/nestjs)
-        - If it's just a quick question you can ping [our Twitter](https://twitter.com/nestframework)
-
-        ---
-
-  - type: checkboxes
-    attributes:
-      label: "Is there an existing issue that is already proposing this?"
-      description: "Please search [here](./?q=is%3Aissue) to see if an issue already exists for the feature you are requesting"
-      options:
-      - label: "I have searched the existing issues"
-        required: true
-
-  - type: textarea
-    validations:
-      required: true
-    attributes:
-      label: "Is your feature request related to a problem? Please describe it"
-      description: "A clear and concise description of what the problem is"
-      placeholder: |
-        I have an issue when ...
-
-  - type: textarea
-    validations:
-      required: true
-    attributes:
-      label: "Describe the solution you'd like"
-      description: "A clear and concise description of what you want to happen. Add any considered drawbacks"
-
-  - type: textarea
-    attributes:
-      label: "Teachability, documentation, adoption, migration strategy"
-      description: "If you can, explain how users will be able to use this and possibly write out a version the docs. Maybe a screenshot or design?"
-
-  - type: textarea
-    validations:
-      required: true
-    attributes:
-      label: "What is the motivation / use case for changing the behavior?"
-      description: "Describe the motivation or the concrete use case"

package/.github/ISSUE_TEMPLATE/Regression.yml

@@ -1,78 +0,0 @@
-name: "\U0001F4A5 Regression"
-description: "Report an unexpected behavior while upgrading your Nest application!"
-labels: ["needs triage"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## :warning: We use GitHub Issues to track bug reports, feature requests and regressions
- 
-        If you are not sure that your issue is a bug, you could:
-
-        - use our [Discord community](https://discord.gg/NestJS)
-        - use [StackOverflow using the tag `nestjs`](https://stackoverflow.com/questions/tagged/nestjs)
-        - If it's just a quick question you can ping [our Twitter](https://twitter.com/nestframework)
-
-        **NOTE:** You don't need to answer questions that you know that aren't relevant.
-
-        ---
-
-  - type: checkboxes
-    attributes:
-      label: "Did you read the migration guide?"
-      description: "Check out the [migration guide here](https://docs.nestjs.com/migration-guide)!"
-      options:
-      - label: "I have read the whole migration guide"
-        required: false
-
-  - type: checkboxes
-    attributes:
-      label: "Is there an existing issue that is already proposing this?"
-      description: "Please search [here](./?q=is%3Aissue) to see if an issue already exists for the feature you are requesting"
-      options:
-      - label: "I have searched the existing issues"
-        required: true
-
-  - type: input
-    attributes:
-      label: "Potential Commit/PR that introduced the regression"
-      description: "If you have time to investigate, what PR/date/version introduced this issue"
-      placeholder: "PR #123 or commit 5b3c4a4"
-
-  - type: input
-    attributes:
-      label: "Versions"
-      description: "From which version of `@nestjs/cli` to which version you are upgrading"
-      placeholder: "8.1.0 -> 8.1.3"
-
-  - type: textarea
-    validations:
-      required: true
-    attributes:
-      label: "Describe the regression"
-      description: "A clear and concise description of what the regression is"
-
-  - type: textarea
-    attributes:
-      label: "Minimum reproduction code"
-      description: |
-        Please share a git repo, a gist, or step-by-step instructions. [Wtf is a minimum reproduction?](https://jmcdo29.github.io/wtf-is-a-minimum-reproduction)
-        **Tip:** If you leave a minimum repository, we will understand your issue faster!
-      value: |
-        ```ts
-
-        ```
-
-  - type: textarea
-    validations:
-      required: true
-    attributes:
-      label: "Expected behavior"
-      description: "A clear and concise description of what you expected to happend (or code)"
-
-  - type: textarea
-    attributes:
-      label: "Other"
-      description: |
-        Anything else relevant? eg: Logs, OS version, IDE, package manager, etc.
-        **Tip:** You can attach images, recordings or log files by clicking this area to highlight it and then dragging files in

package/.github/ISSUE_TEMPLATE/config.yml

@@ -1,7 +0,0 @@
-## To encourage contributors to use issue templates, we don't allow blank issues
-blank_issues_enabled: false
-
-contact_links:
-  - name: "\u2753 Discord Community of NestJS"
-    url: "https://discord.gg/NestJS"
-    about: "Please ask support questions or discuss suggestions/enhancements here."

package/.github/PULL_REQUEST_TEMPLATE.md

@@ -1,41 +0,0 @@
-## PR Checklist
-Please check if your PR fulfills the following requirements:
-
-- [ ] The commit message follows our guidelines: https://github.com/nestjs/nest/blob/master/CONTRIBUTING.md
-- [ ] Tests for the changes have been added (for bug fixes / features)
-- [ ] Docs have been added / updated (for bug fixes / features)
-
-
-## PR Type
-What kind of change does this PR introduce?
-
-<!-- Please check the one that applies to this PR using "x". -->
-```
-[ ] Bugfix
-[ ] Feature
-[ ] Code style update (formatting, local variables)
-[ ] Refactoring (no functional changes, no api changes)
-[ ] Build related changes
-[ ] CI related changes
-[ ] Other... Please describe:
-```
-
-## What is the current behavior?
-<!-- Please describe the current behavior that you are modifying, or link to a relevant issue. -->
-
-Issue Number: N/A
-
-
-## What is the new behavior?
-
-
-## Does this PR introduce a breaking change?
-```
-[ ] Yes
-[ ] No
-```
-
-<!-- If this PR contains a breaking change, please describe the impact and migration path for existing applications below. -->
-
-
-## Other information

package/test/lib/compiler/hooks/__snapshots__/tsconfig-paths.hook.spec.ts.snap

@@ -1,68 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`tsconfig paths hooks should remove unused imports 1`] = `
-Map {
-  "dist/foo.js" => "\\"use strict\\";
-Object.defineProperty(exports, \\"__esModule\\", { value: true });
-exports.Foo = void 0;
-class Foo {
-}
-exports.Foo = Foo;
-",
-  "dist/bar.js" => "\\"use strict\\";
-Object.defineProperty(exports, \\"__esModule\\", { value: true });
-exports.Bar = void 0;
-class Bar {
-}
-exports.Bar = Bar;
-",
-  "dist/main.js" => "\\"use strict\\";
-Object.defineProperty(exports, \\"__esModule\\", { value: true });
-",
-}
-`;
-
-exports[`tsconfig paths hooks should replace path of every import using a path alias by its relative path 1`] = `
-Map {
-  "dist/foo.js" => "\\"use strict\\";
-Object.defineProperty(exports, \\"__esModule\\", { value: true });
-exports.Foo = void 0;
-class Foo {
-}
-exports.Foo = Foo;
-",
-  "dist/bar.jsx" => "\\"use strict\\";
-Object.defineProperty(exports, \\"__esModule\\", { value: true });
-exports.Bar = void 0;
-class Bar {
-}
-exports.Bar = Bar;
-",
-  "dist/baz.js" => "\\"use strict\\";
-Object.defineProperty(exports, \\"__esModule\\", { value: true });
-exports.Baz = void 0;
-class Baz {
-}
-exports.Baz = Baz;
-",
-  "dist/qux.jsx" => "\\"use strict\\";
-Object.defineProperty(exports, \\"__esModule\\", { value: true });
-exports.Qux = void 0;
-class Qux {
-}
-exports.Qux = Qux;
-",
-  "dist/main.js" => "\\"use strict\\";
-Object.defineProperty(exports, \\"__esModule\\", { value: true });
-const foo_1 = require(\\"./foo\\");
-const bar_1 = require(\\"./bar\\");
-const baz_1 = require(\\"./baz\\");
-const qux_1 = require(\\"./qux\\");
-// use the imports so they do not get eliminated
-console.log(foo_1.Foo);
-console.log(bar_1.Bar);
-console.log(baz_1.Baz);
-console.log(qux_1.Qux);
-",
-}
-`;

package/test/lib/compiler/hooks/fixtures/aliased-imports/src/bar.tsx

@@ -1 +0,0 @@
-export class Bar {}

package/test/lib/compiler/hooks/fixtures/aliased-imports/src/baz.js

@@ -1 +0,0 @@
-export class Baz {}

package/test/lib/compiler/hooks/fixtures/aliased-imports/src/qux.jsx

@@ -1 +0,0 @@
-export class Qux {}