@gadmin2n/cli 0.0.85 → 0.0.87

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,386 @@
+"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 abstract_action_1 = require("./abstract.action");
+const EXCLUDES = [
+    'node_modules',
+    '.git',
+    'dist',
+    'generated',
+    '.DS_Store',
+    '.env.local',
+    'readme.md'
+];
+function shouldExclude(filePath) {
+    const parts = filePath.split('/');
+    for (const pattern of EXCLUDES) {
+        if (parts.includes(pattern))
+            return true;
+        if (filePath === pattern)
+            return true;
+    }
+    return false;
+}
+function collectFiles(dir, 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))
+            continue;
+        if (entry.isDirectory()) {
+            results.push(...collectFiles(dir, rel));
+        }
+        else if (entry.isFile()) {
+            results.push(rel);
+        }
+    }
+    return results.sort();
+}
+function resolveTemplatePath() {
+    // Try to read gadmin-cli.json from current project
+    const configPaths = [
+        path.join(process.cwd(), 'server/gadmin-cli.json'),
+        path.join(process.cwd(), 'gadmin-cli.json'),
+    ];
+    let templateName;
+    for (const configPath of configPaths) {
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            templateName = config.template;
+            break;
+        }
+    }
+    if (!templateName) {
+        throw new Error('Cannot find "template" field in gadmin-cli.json. ' +
+            'Make sure you are in a gadmin2 project root directory.');
+    }
+    // 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');
+}
+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;
+            try {
+                templateDir = resolveTemplatePath();
+            }
+            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);
+            const instanceFiles = collectFiles(instanceDir);
+            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;
+            try {
+                templateDir = resolveTemplatePath();
+            }
+            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);
+            const instanceFiles = collectFiles(instanceDir);
+            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) — conflict markers will be added`));
+                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
+            if (!autoYes) {
+                const { confirm } = yield inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: 'Proceed with update?',
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    console.info('Cancelled.\n');
+                    return;
+                }
+            }
+            // Execute
+            let conflictCount = 0;
+            for (const file of toUpdate) {
+                const tContent = fs.readFileSync(path.join(templateDir, file), 'utf-8');
+                const iContent = fs.readFileSync(path.join(instanceDir, file), 'utf-8');
+                const conflictContent = createConflictContent(iContent, tContent);
+                fs.writeFileSync(path.join(instanceDir, file), conflictContent, 'utf-8');
+                conflictCount++;
+            }
+            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);
+            }
+            console.info(chalk.bold('\n✅ Update complete!\n'));
+            if (conflictCount > 0) {
+                console.info(chalk.yellow(`⚠️  ${conflictCount} files have conflict markers. ` +
+                    `Search for "<<<<<<< INSTANCE" to resolve them.\n`));
+            }
+            if (toAdd.length > 0) {
+                console.info(chalk.green(`   ${toAdd.length} files added.\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.85",
+  "version": "0.0.87",
   "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.68",
+    "@gadmin2n/schematics": "^0.0.70",
     "abc": "^0.6.1",
     "chalk": "3.0.0",
     "chokidar": "3.5.3",