@gadmin2n/cli 0.0.110 → 0.0.112

package/actions/new.action.js

@@ -25,6 +25,10 @@ const schematics_1 = require("../lib/schematics");
 const ui_1 = require("../lib/ui");
 const formatting_1 = require("../lib/utils/formatting");
 const abstract_action_1 = require("./abstract.action");
+const schematics_root_1 = require("../lib/schematics-root");
+const base_store_1 = require("../lib/template-merge/base-store");
+const types_1 = require("../lib/template-merge/types");
+const executable_paths_1 = require("../lib/executable-paths");
 class NewAction extends abstract_action_1.AbstractAction {
     handle(inputs, options) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -42,6 +46,32 @@ class NewAction extends abstract_action_1.AbstractAction {
                 yield applyEnvConfig(projectDirectory, options).catch((err) => {
                     console.error(chalk.yellow(`[warn] Failed to apply env config: ${err && err.message ? err.message : err}`));
                 });
+                // Pin the 3-way merge base at project init time. Recording the exact
+                // schematics version that scaffolded this project means the FIRST
+                // `gadmin2 update` can immediately do a real 3-way merge — no
+                // bootstrap-then-rerun dance. Failure is non-fatal: if meta can't be
+                // written here, `gadmin2 update` still has its bootstrap fallback.
+                try {
+                    const projectAbsDir = (0, path_1.join)(process.cwd(), projectDirectory);
+                    const schematicsVersion = (0, schematics_root_1.getSchematicsVersion)();
+                    (0, base_store_1.writeMeta)(projectAbsDir, {
+                        schematicsVersion,
+                        schemaVersion: types_1.CURRENT_META_SCHEMA_VERSION,
+                    });
+                    (0, base_store_1.writeReadme)(projectAbsDir);
+                }
+                catch (err) {
+                    console.warn(chalk.yellow(`[warn] Failed to write .gadmin/.meta.json (first \`gadmin2 update\` will bootstrap instead): ${err && err.message ? err.message : err}`));
+                }
+                // @angular-devkit/schematics drops the source mode bits when writing
+                // generated files, so executable scripts (compose-ctl.sh, etc.) come
+                // out as 0644. Re-apply +x for known entry points.
+                try {
+                    (0, executable_paths_1.ensureExecutableBits)((0, path_1.join)(process.cwd(), projectDirectory));
+                }
+                catch (_a) {
+                    // best-effort, never fatal
+                }
             }
             if (!shouldSkipInstall) {
                 console.info('Begin to install server dependence ...');

package/actions/update.action.js

@@ -19,6 +19,8 @@ const child_process_1 = require("child_process");
 const abstract_action_1 = require("./abstract.action");
 const self_update_action_1 = require("./self-update.action");
 const version_check_1 = require("../lib/version-check");
+const schematics_root_1 = require("../lib/schematics-root");
+const executable_paths_1 = require("../lib/executable-paths");
 const merge3way_1 = require("../lib/template-merge/merge3way");
 const binary_detect_1 = require("../lib/template-merge/binary-detect");
 const residual_scan_1 = require("../lib/template-merge/residual-scan");
@@ -50,28 +52,7 @@ function formatMaterializeError(schematicsVersion, err) {
  * Template config / path resolution
  * ------------------------------------------------------------------ */
 function resolveTemplatePath(templateName) {
-    let schematicsRoot;
-    const searchPaths = [
-        process.cwd(),
-        path.join(process.cwd(), 'server'),
-        path.resolve(__dirname, '..'),
-    ];
-    for (const searchPath of searchPaths) {
-        try {
-            const pkgPath = require.resolve('@gadmin2n/schematics/package.json', {
-                paths: [searchPath],
-            });
-            schematicsRoot = path.dirname(pkgPath);
-            break;
-        }
-        catch (_a) {
-            // continue
-        }
-    }
-    if (!schematicsRoot) {
-        throw new Error('Cannot resolve @gadmin2n/schematics package. ' +
-            'Make sure it is installed.');
-    }
+    const schematicsRoot = (0, schematics_root_1.findSchematicsRoot)();
     const nameVariants = [templateName];
     if (templateName.startsWith('gadmin2n-')) {
         nameVariants.push(templateName.replace('gadmin2n-', 'gadmin2-'));
@@ -575,19 +556,79 @@ function applyPlan(plan, baseRoot, oursRoot, theirsRoot, opts) {
 /* ------------------------------------------------------------------ *
  * Print summary
  * ------------------------------------------------------------------ */
-function printPlanCounts(plan) {
-    console.info(`   ${plan.update.length} files cleanly merged or 3-way merged\n` +
-        `   ${plan.add.length} files added (template-only)\n` +
-        `   ${plan.delete.length} files deleted (template removed)`);
-    if (plan.keep.length > 0) {
-        console.info(chalk.gray(`   ${plan.keep.length} files kept (instance-only or identical)`));
+/**
+ * Unified file-list printer for a `ClassifiedPlan`. Used by both pre-apply
+ * preview / dry-run output AND post-apply summary so the wording stays
+ * consistent across the three call sites.
+ *
+ * Sections that have zero files are skipped entirely (no "0 files added"
+ * noise). Structural conflicts (add/add, modify/delete, delete/modify) are
+ * shown together because they're all "needs decision" situations the user
+ * should see before applying.
+ *
+ * The "kept" footer (`plan.keep + plan.noop`) is shown by default; pass
+ * `{ showKept: false }` to suppress it.
+ */
+function printPlanFileLists(plan, opts) {
+    var _a;
+    const showKept = (_a = opts === null || opts === void 0 ? void 0 : opts.showKept) !== null && _a !== void 0 ? _a : true;
+    const plural = (n) => (n === 1 ? '' : 's');
+    if (plan.update.length > 0) {
+        console.info(chalk.yellow(`📝 Updated (3-way merged) — ${plan.update.length} file${plural(plan.update.length)}`));
+        for (const f of plan.update)
+            console.info(`   ${f}`);
+        console.info();
+    }
+    if (plan.add.length > 0) {
+        console.info(chalk.green(`➕ Added (template-only) — ${plan.add.length} file${plural(plan.add.length)}`));
+        for (const f of plan.add)
+            console.info(`   ${f}`);
+        console.info();
+    }
+    if (plan.delete.length > 0) {
+        console.info(chalk.red(`🗑  Deleted (template removed) — ${plan.delete.length} file${plural(plan.delete.length)}`));
+        for (const f of plan.delete)
+            console.info(`   ${f}`);
+        console.info();
+    }
+    const structural = [
+        ...plan.addAddConflict.map((p) => ['add/add', p]),
+        ...plan.modifyDeleteConflict.map((p) => ['modify/delete', p]),
+        ...plan.deleteModifyConflict.map((p) => ['delete/modify', p]),
+    ];
+    if (structural.length > 0) {
+        console.info(chalk.magenta(`⚠️  Structural conflicts — ${structural.length} file${plural(structural.length)}`));
+        const padKind = (k) => k.padEnd(16);
+        for (const [kind, p] of structural) {
+            console.info(`   ${chalk.magenta(padKind(`[${kind}]`))} ${p}`);
+        }
+        console.info();
+    }
+    if (showKept) {
+        const keptCount = plan.keep.length + plan.noop.length;
+        if (keptCount > 0) {
+            console.info(chalk.gray(`   ${keptCount} file${plural(keptCount)} kept (instance-only or identical)`));
+        }
+    }
+}
+/**
+ * Print post-apply conflict records (output of `applyPlan`). These differ
+ * from a `ClassifiedPlan` because they include `kind: 'content' | 'binary'`
+ * which is only known after the merge actually runs.
+ */
+function printConflictRecords(conflicts) {
+    const padKind = (k) => k.padEnd(16);
+    for (const c of conflicts) {
+        const kindLabel = `[${c.kind}]`;
+        console.info(`   ${chalk.yellow(padKind(kindLabel))} ${c.path}` +
+            (c.detail ? chalk.gray(`   (${c.detail})`) : ''));
     }
 }
 function printSummary(plan, conflicts, templateName, schematicsVersion) {
     console.info(chalk.bold('\n═══════════════════════════════════════════════════'));
     console.info(chalk.bold('  Template Update Summary'));
     console.info(chalk.bold('═══════════════════════════════════════════════════\n'));
-    printPlanCounts(plan);
+    printPlanFileLists(plan);
     console.info();
     if (conflicts.length === 0) {
         console.info(chalk.green('✅ Template update complete — no conflicts.'));
@@ -595,12 +636,7 @@ function printSummary(plan, conflicts, templateName, schematicsVersion) {
         return;
     }
     console.info(chalk.yellow(`⚠️  ${conflicts.length} conflict(s) need your attention:\n`));
-    const padKind = (k) => k.padEnd(16);
-    for (const c of conflicts) {
-        const kindLabel = `[${c.kind}]`;
-        console.info(`   ${chalk.yellow(padKind(kindLabel))} ${c.path}` +
-            (c.detail ? chalk.gray(`   (${c.detail})`) : ''));
-    }
+    printConflictRecords(conflicts);
     console.info();
     console.info(chalk.gray('   Recommended workflow:'));
     console.info(chalk.gray('     $ git status                   # see all modified files'));
@@ -946,8 +982,7 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                         snapshotPackageJson(path.join(instanceDir, 'web'), 'web'),
                         snapshotPackageJson(path.join(instanceDir, 'server'), 'server'),
                     ];
-                    const schematicsPkg = require(require.resolve('@gadmin2n/schematics/package.json', { paths: [instanceDir, path.join(instanceDir, 'server')] }));
-                    const schematicsVersion = schematicsPkg.version || '0.0.0';
+                    const schematicsVersion = (0, schematics_root_1.getSchematicsVersion)(instanceDir);
                     // First-time bootstrap: meta absent → write meta + README, exit.
                     if (!fs.existsSync((0, base_store_1.metaPath)(instanceDir))) {
                         if (dryRun) {
@@ -996,28 +1031,56 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                             console.info(chalk.bold('═══════════════════════════════════════════════════'));
                             console.info(chalk.bold('  Template Update Plan (dry-run)'));
                             console.info(chalk.bold('═══════════════════════════════════════════════════\n'));
-                            for (const f of plan.add)
-                                console.info(chalk.green(`   add     ${f}`));
-                            for (const f of plan.delete)
-                                console.info(chalk.red(`   delete  ${f}`));
-                            for (const f of plan.update)
-                                console.info(chalk.yellow(`   update  ${f}`));
-                            for (const f of plan.addAddConflict)
-                                console.info(chalk.magenta(`   add/add        ${f}`));
-                            for (const f of plan.modifyDeleteConflict)
-                                console.info(chalk.magenta(`   modify/delete  ${f}`));
-                            for (const f of plan.deleteModifyConflict)
-                                console.info(chalk.magenta(`   delete/modify  ${f}`));
+                            printPlanFileLists(plan);
                             console.info();
                         }
                         else {
-                            const conflicts = applyPlan(plan, baseRoot, instanceDir, theirsRoot, mergeOpts);
-                            // Always advance meta to new version, even when conflicts present (invariant #2).
-                            (0, base_store_1.writeMeta)(instanceDir, {
-                                schematicsVersion,
-                                schemaVersion: types_1.CURRENT_META_SCHEMA_VERSION,
-                            });
-                            printSummary(plan, conflicts, templateName, schematicsVersion);
+                            // Pre-apply preview + confirm (skipped under --yes).
+                            const applyAndReport = () => {
+                                const conflicts = applyPlan(plan, baseRoot, instanceDir, theirsRoot, mergeOpts);
+                                // Always advance meta to new version, even when conflicts present (invariant #2).
+                                (0, base_store_1.writeMeta)(instanceDir, {
+                                    schematicsVersion,
+                                    schemaVersion: types_1.CURRENT_META_SCHEMA_VERSION,
+                                });
+                                // Re-apply +x to known script entry points: applyPlan uses
+                                // fs.copyFileSync for newly-added files, which does not preserve
+                                // the source template's mode bits.
+                                try {
+                                    (0, executable_paths_1.ensureExecutableBits)(instanceDir);
+                                }
+                                catch (_a) {
+                                    // best-effort, never fatal
+                                }
+                                printSummary(plan, conflicts, templateName, schematicsVersion);
+                            };
+                            if (autoYes) {
+                                applyAndReport();
+                            }
+                            else {
+                                console.info(chalk.bold('\n═══════════════════════════════════════════════════'));
+                                console.info(chalk.bold('  Template Update Preview'));
+                                console.info(chalk.bold('═══════════════════════════════════════════════════\n'));
+                                printPlanFileLists(plan);
+                                console.info();
+                                const { proceedTemplate } = yield inquirer.prompt([
+                                    {
+                                        type: 'confirm',
+                                        name: 'proceedTemplate',
+                                        message: 'Apply this template update to your instance?',
+                                        default: true,
+                                    },
+                                ]);
+                                if (proceedTemplate) {
+                                    applyAndReport();
+                                }
+                                else {
+                                    console.info(chalk.gray('\nTemplate update skipped — base & files unchanged.\n'));
+                                    // Fall through to stage 2 (.claude sync) and stage 3 (install).
+                                    // pkgSnapshots are already captured but package.json is unchanged,
+                                    // so maybeInstallChangedDeps will naturally find no diff and skip.
+                                }
+                            }
                         }
                     }
                 }

package/lib/executable-paths.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Files (relative to instance / project root) that must carry the executable
+ * bit. Both `gadmin2 n` and `gadmin2 update` re-apply this set after writing
+ * files because:
+ *
+ *   - @angular-devkit/schematics writes generated files via fs.writeFile, which
+ *     does NOT preserve the source template's mode.
+ *   - update.action's applyPlan uses fs.copyFileSync for "added" files, which
+ *     also does not preserve mode.
+ *
+ * Without this step the user has to `chmod +x compose-ctl.sh` manually after
+ * every `gadmin2 n` / `gadmin2 update`.
+ *
+ * KEEP IN SYNC with the schematics templates: any new shell entry point added
+ * to schematics that the user is expected to invoke directly should be listed
+ * here too.
+ */
+export declare const EXECUTABLE_PATHS: ReadonlyArray<string>;
+/**
+ * Best-effort: add the executable bit to known script entry points under
+ * `projectDir`. Only files that actually exist are touched. Failures are
+ * silently swallowed — chmod is a no-op on Windows and in containers without
+ * permission, but neither is a reason to abort the broader command.
+ *
+ * Returns the list of paths that were updated, suitable for verbose logging.
+ */
+export declare function ensureExecutableBits(projectDir: string): string[];

package/lib/executable-paths.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureExecutableBits = exports.EXECUTABLE_PATHS = void 0;
+const fs = require("fs");
+const path = require("path");
+/**
+ * Files (relative to instance / project root) that must carry the executable
+ * bit. Both `gadmin2 n` and `gadmin2 update` re-apply this set after writing
+ * files because:
+ *
+ *   - @angular-devkit/schematics writes generated files via fs.writeFile, which
+ *     does NOT preserve the source template's mode.
+ *   - update.action's applyPlan uses fs.copyFileSync for "added" files, which
+ *     also does not preserve mode.
+ *
+ * Without this step the user has to `chmod +x compose-ctl.sh` manually after
+ * every `gadmin2 n` / `gadmin2 update`.
+ *
+ * KEEP IN SYNC with the schematics templates: any new shell entry point added
+ * to schematics that the user is expected to invoke directly should be listed
+ * here too.
+ */
+exports.EXECUTABLE_PATHS = [
+    'compose-ctl.sh',
+    'server/start-prod.sh',
+];
+/**
+ * Best-effort: add the executable bit to known script entry points under
+ * `projectDir`. Only files that actually exist are touched. Failures are
+ * silently swallowed — chmod is a no-op on Windows and in containers without
+ * permission, but neither is a reason to abort the broader command.
+ *
+ * Returns the list of paths that were updated, suitable for verbose logging.
+ */
+function ensureExecutableBits(projectDir) {
+    const updated = [];
+    for (const rel of exports.EXECUTABLE_PATHS) {
+        const abs = path.join(projectDir, rel);
+        if (!fs.existsSync(abs))
+            continue;
+        try {
+            const cur = fs.statSync(abs).mode;
+            const next = cur | 0o111; // owner+group+other +x
+            if (next !== cur) {
+                fs.chmodSync(abs, next);
+                updated.push(rel);
+            }
+        }
+        catch (_a) {
+            // ignore — Windows / restricted FS
+        }
+    }
+    return updated;
+}
+exports.ensureExecutableBits = ensureExecutableBits;

package/lib/schematics-root.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Locate the @gadmin2n/schematics install root, searching:
+ *   1. the supplied instance dir (defaults to process.cwd())
+ *   2. <instanceDir>/server (where deps are usually hoisted)
+ *   3. the CLI's own node_modules — covers globally installed CLI where
+ *      schematics ships alongside @gadmin2n/cli but is NOT installed in
+ *      the user's project.
+ *
+ * Throws a helpful error if none of these resolve.
+ *
+ * Used by:
+ *   - update.action  (resolveTemplatePath, schematics version pin)
+ *   - new.action     (meta bootstrap at project init)
+ */
+export declare function findSchematicsRoot(instanceDir?: string): string;
+/**
+ * Convenience wrapper: returns the version field of @gadmin2n/schematics's
+ * package.json. Falls back to '0.0.0' if the field is missing.
+ */
+export declare function getSchematicsVersion(instanceDir?: string): string;

package/lib/schematics-root.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchematicsVersion = exports.findSchematicsRoot = void 0;
+const path = require("path");
+/**
+ * Locate the @gadmin2n/schematics install root, searching:
+ *   1. the supplied instance dir (defaults to process.cwd())
+ *   2. <instanceDir>/server (where deps are usually hoisted)
+ *   3. the CLI's own node_modules — covers globally installed CLI where
+ *      schematics ships alongside @gadmin2n/cli but is NOT installed in
+ *      the user's project.
+ *
+ * Throws a helpful error if none of these resolve.
+ *
+ * Used by:
+ *   - update.action  (resolveTemplatePath, schematics version pin)
+ *   - new.action     (meta bootstrap at project init)
+ */
+function findSchematicsRoot(instanceDir = process.cwd()) {
+    const searchPaths = [
+        instanceDir,
+        path.join(instanceDir, 'server'),
+        path.resolve(__dirname, '..'),
+    ];
+    for (const searchPath of searchPaths) {
+        try {
+            const pkgPath = require.resolve('@gadmin2n/schematics/package.json', {
+                paths: [searchPath],
+            });
+            return path.dirname(pkgPath);
+        }
+        catch (_a) {
+            // continue
+        }
+    }
+    throw new Error('Cannot resolve @gadmin2n/schematics package. ' +
+        'Make sure it is installed globally (alongside @gadmin2n/cli) ' +
+        'or as a dependency of the project.');
+}
+exports.findSchematicsRoot = findSchematicsRoot;
+/**
+ * Convenience wrapper: returns the version field of @gadmin2n/schematics's
+ * package.json. Falls back to '0.0.0' if the field is missing.
+ */
+function getSchematicsVersion(instanceDir) {
+    const root = findSchematicsRoot(instanceDir);
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const pkg = require(path.join(root, 'package.json'));
+    return (pkg && pkg.version) || '0.0.0';
+}
+exports.getSchematicsVersion = getSchematicsVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gadmin2n/cli",
-  "version": "0.0.110",
+  "version": "0.0.112",
   "description": "Gadmin - modern, fast, powerful node.js web framework (@cli)",
   "publishConfig": {
     "access": "public"