@gadmin2n/cli 0.0.191 → 0.0.192

package/actions/update.action.js

@@ -535,24 +535,38 @@ function pickAdoptions(label, files) {
     });
 }
 /**
- * Decide which `adoptable` (never-tracked) and `deleteModifyConflict`
- * (previously-deleted) files to bring in from the template, then fold the
- * chosen ones into `plan.add` so applyPlan copies them like any other add.
- * Unchosen files are left where they are: adoptable → silently kept absent;
- * deleteModifyConflict → handled by applyPlan's existing conflict path.
+ * Decide which template-side-only files to bring in, then fold the chosen ones
+ * into `plan.add` so applyPlan copies them like any other add. Unchosen files
+ * are left absent — nothing is copied and no conflict is recorded.
+ *
+ * Buckets and how they're offered:
+ *   - `adoptable`            never tracked here → promptable (optional feature)
+ *   - `deleteModifyConflict` absent, template since updated → promptable, and
+ *                            one-time (the next run reclassifies it as
+ *                            `keptDeleted` once base advances)
+ *   - `keptDeleted`          absent, template unchanged → NOT promptable. The
+ *                            absence is an old, already-final decision;
+ *                            re-asking on every update would be pure noise.
+ *                            Only an explicit `--theirs` opts back in.
  *
  * Resolution policy:
  *   --theirs → adopt everything;  --ours / --yes → adopt nothing;
- *   interactive → batch prompt per group (default skip).
+ *   interactive → batch prompt per promptable group (default skip).
  */
 function resolveAdoptions(plan, opts, autoYes) {
     return __awaiter(this, void 0, void 0, function* () {
         const groups = [
-            { bucket: 'adoptable', label: 'template file(s) your instance has never had' },
+            {
+                bucket: 'adoptable',
+                label: 'template file(s) your instance has never had',
+                promptable: true,
+            },
             {
                 bucket: 'deleteModifyConflict',
-                label: 'file(s) you previously deleted that the template has since modified',
+                label: 'file(s) absent from your instance that the template has since updated (default: keep absent)',
+                promptable: true,
             },
+            { bucket: 'keptDeleted', label: '', promptable: false },
         ];
         for (const g of groups) {
             const files = plan[g.bucket];
@@ -561,7 +575,7 @@ function resolveAdoptions(plan, opts, autoYes) {
             let adopt;
             if (opts.theirs)
                 adopt = [...files];
-            else if (opts.ours || autoYes)
+            else if (opts.ours || autoYes || !g.promptable)
                 adopt = [];
             else
                 adopt = yield pickAdoptions(g.label, files);
@@ -640,36 +654,48 @@ function applyPlan(plan, baseRoot, oursRoot, theirsRoot, opts) {
             });
         }
     }
-    // delete/modify (instance deleted, template modified)
-    for (const rel of plan.deleteModifyConflict) {
-        const oursPath = path.join(oursRoot, rel);
-        const theirsPath = path.join(theirsRoot, rel);
-        if (opts.theirs) {
-            ensureDir(oursPath);
-            fs.copyFileSync(theirsPath, oursPath);
-        }
-        else if (!opts.ours) {
-            conflicts.push({
-                path: rel,
-                kind: 'delete/modify',
-                detail: 'instance deleted this file; template modified — file NOT restored',
-            });
-        }
-    }
+    // keptDeleted / deleteModifyConflict need no handling here: neither is a
+    // conflict (the instance has no file to corrupt), so the absence is simply
+    // kept. Restoring them is `resolveAdoptions`' job — it folds the chosen ones
+    // (all of them under --theirs) into `plan.add` before we run.
     return conflicts;
 }
 /* ------------------------------------------------------------------ *
  * Print summary
  * ------------------------------------------------------------------ */
+const plural = (n) => (n === 1 ? '' : 's');
+/**
+ * The two "kept absent" notices share a prefix but must stay textually
+ * distinct: one is a one-time heads-up (the template changed a file you don't
+ * have), the other a recurring reminder (nothing changed; it stays absent).
+ */
+const KEPT_DELETED_UPDATED_TITLE = '🗑  Kept deleted (template updated since)';
+const KEPT_DELETED_TITLE = '🗑  Kept deleted (template unchanged)';
+/**
+ * Recurring reminder for files the template has but the instance doesn't, and
+ * which the template hasn't touched since the recorded base. Worded to fit both
+ * cases the classifier folds in here: a deliberate deletion (git says the file
+ * was tracked) and a non-git instance where we cannot tell deletion apart from
+ * "never had it".
+ */
+function printKeptDeletedSection(keptDeleted) {
+    if (keptDeleted.length === 0)
+        return;
+    console.info(chalk.cyan(`${KEPT_DELETED_TITLE} — ${keptDeleted.length} file${plural(keptDeleted.length)} absent from your instance; NOT restored from the template`));
+    for (const f of keptDeleted)
+        console.info(`   ${chalk.cyan('[deleted]        ')} ${f}`);
+    console.info(chalk.gray('   Informational only — the absence is kept. Restore with --theirs.'));
+    console.info();
+}
 /**
  * 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.
+ * noise). Structural conflicts (add/add, modify/delete) 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.
@@ -677,7 +703,6 @@ function applyPlan(plan, baseRoot, oursRoot, theirsRoot, opts) {
 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)
@@ -706,7 +731,6 @@ function printPlanFileLists(plan, opts) {
     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)}`));
@@ -716,6 +740,17 @@ function printPlanFileLists(plan, opts) {
         }
         console.info();
     }
+    // delete/modify is NOT a conflict: the instance has no file to corrupt.
+    // One-time info (reclassified as keptDeleted on later runs, once an applied
+    // update advances base past the template change).
+    if (plan.deleteModifyConflict.length > 0) {
+        console.info(chalk.cyan(`${KEPT_DELETED_UPDATED_TITLE} — ${plan.deleteModifyConflict.length} file${plural(plan.deleteModifyConflict.length)} absent from your instance that the template has since updated`));
+        for (const f of plan.deleteModifyConflict)
+            console.info(`   ${chalk.cyan('[delete/modify]  ')} ${f}`);
+        console.info(chalk.gray('   Not conflicts — kept absent by default. Restore interactively or with --theirs.'));
+        console.info();
+    }
+    printKeptDeletedSection(plan.keptDeleted);
     if (showKept) {
         const keptCount = plan.keep.length + plan.noop.length;
         if (keptCount > 0) {
@@ -940,15 +975,31 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                 const conflicts = [
                     ...plan.addAddConflict.map((p) => ['add/add', p]),
                     ...plan.modifyDeleteConflict.map((p) => ['modify/delete', p]),
-                    ...plan.deleteModifyConflict.map((p) => ['delete/modify', p]),
                 ];
                 if (conflicts.length > 0) {
                     console.info(chalk.magenta(`⚠️  Structural conflicts (${conflicts.length} files)`));
                     conflicts.forEach(([k, p]) => console.info(`   [${k}] ${p}`));
                     console.info();
                 }
-                if (plan.add.length + plan.delete.length + plan.update.length + plan.adoptable.length + conflicts.length === 0) {
-                    console.info(chalk.green('✅ No differences found. Instance matches template.\n'));
+                if (plan.deleteModifyConflict.length > 0) {
+                    console.info(chalk.cyan(`${KEPT_DELETED_UPDATED_TITLE} — absent here, template has since updated (${plan.deleteModifyConflict.length} files)`));
+                    plan.deleteModifyConflict.forEach((f) => console.info(`   [delete/modify]   ${f}`));
+                    console.info();
+                }
+                if (plan.keptDeleted.length > 0) {
+                    console.info(chalk.cyan(`${KEPT_DELETED_TITLE} — absent here, NOT restored from template (${plan.keptDeleted.length} files)`));
+                    plan.keptDeleted.forEach((f) => console.info(`   [deleted]         ${f}`));
+                    console.info();
+                }
+                // `keptDeleted` is a standing state, not a pending change — it never
+                // resolves on its own, so counting it here would permanently suppress
+                // the "matches template" signal.
+                const pending = plan.add.length + plan.delete.length + plan.update.length + plan.adoptable.length +
+                    plan.deleteModifyConflict.length + conflicts.length;
+                if (pending === 0) {
+                    console.info(plan.keptDeleted.length > 0
+                        ? chalk.green('✅ No pending changes. Instance matches template, aside from the kept deletions above.\n')
+                        : chalk.green('✅ No differences found. Instance matches template.\n'));
                 }
             }
             finally {
@@ -1011,7 +1062,6 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                 const structural = [
                     ...plan.addAddConflict.map((p) => ({ kind: 'add/add', path: p })),
                     ...plan.modifyDeleteConflict.map((p) => ({ kind: 'modify/delete', path: p })),
-                    ...plan.deleteModifyConflict.map((p) => ({ kind: 'delete/modify', path: p })),
                 ];
                 // Adoptable files are optional (template features the instance never had),
                 // NOT conflicts — surfaced informationally without affecting clean state.
@@ -1019,6 +1069,18 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                     console.info(chalk.cyan(`Adoptable:       ${plan.adoptable.length} optional template file(s) available`) +
                         chalk.gray('  (run `gadmin2 update` to adopt, or `gadmin2 update diff` to list)\n'));
                 }
+                // delete/modify is informational too: files absent from the instance that
+                // the template has since updated. The absence is kept; not a conflict.
+                if (plan.deleteModifyConflict.length > 0) {
+                    console.info(chalk.cyan(`Kept deleted:    ${plan.deleteModifyConflict.length} file(s) absent here; template has since updated them`) +
+                        chalk.gray('  (run `gadmin2 update` to review, or `gadmin2 update --theirs` to restore)\n'));
+                }
+                // keptDeleted: recurring reminder for files absent from the instance that
+                // the template hasn't touched since — they will NOT be restored.
+                if (plan.keptDeleted.length > 0) {
+                    console.info(chalk.cyan(`Kept deleted:    ${plan.keptDeleted.length} file(s) absent here; NOT restored from template`) +
+                        chalk.gray('  (informational only — restore with `gadmin2 update --theirs`)\n'));
+                }
                 const totalConflicts = residual.length + structural.length;
                 if (totalConflicts === 0) {
                     console.info('Instance state:  ' + chalk.green('✅ clean (no unresolved conflicts)\n'));
@@ -1142,13 +1204,40 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                         }
                         const baseRoot = baseHandle.dir;
                         // Classify three sides. git history lets us tell "instance never had
-                        // this file" (adoptable) from "instance deleted it" (deleteModifyConflict).
+                        // this file" (adoptable) from "instance deleted it" (keptDeleted when
+                        // the template hasn't touched it since, deleteModifyConflict when it has).
                         const oursEverTracked = (0, git_history_1.buildEverTrackedChecker)(instanceDir);
                         const plan = (0, classify_1.classifyAll)(baseRoot, instanceDir, theirsRoot, userExcludes, oursEverTracked);
+                        // `keptDeleted` is a standing state, not a pending change: it never
+                        // resolves on its own, so counting it unconditionally would
+                        // permanently turn "up to date" into a confirm prompt plus a bogus
+                        // "files have been updated, commit them" epilogue. It only becomes
+                        // actionable under --theirs, which explicitly opts back into the
+                        // template's copy.
                         const totalChanges = plan.add.length + plan.delete.length + plan.update.length + plan.adoptable.length +
-                            plan.addAddConflict.length + plan.modifyDeleteConflict.length + plan.deleteModifyConflict.length;
+                            plan.addAddConflict.length + plan.modifyDeleteConflict.length + plan.deleteModifyConflict.length +
+                            (mergeOpts.theirs ? plan.keptDeleted.length : 0);
                         if (totalChanges === 0) {
+                            printKeptDeletedSection(plan.keptDeleted);
                             console.info(chalk.green('✅ Instance is up to date with template.\n'));
+                            // Nothing to apply, but the instance IS reconciled with this
+                            // template version: every remaining difference is a deliberate
+                            // ours-side state (kept deletions, files that already match).
+                            // Advance the base anyway so later runs diff against the newest
+                            // template — otherwise an instance whose only difference is a kept
+                            // deletion would stay pinned to an ever-older base forever.
+                            if (meta.schematicsVersion !== schematicsVersion) {
+                                if (dryRun) {
+                                    console.info(chalk.gray(`   (dry-run: would advance base to schematics ${schematicsVersion})\n`));
+                                }
+                                else {
+                                    (0, base_store_1.writeMeta)(instanceDir, {
+                                        schematicsVersion,
+                                        schemaVersion: types_1.CURRENT_META_SCHEMA_VERSION,
+                                    });
+                                    console.info(chalk.gray(`   Base advanced to: ${templateName} @ schematics ${schematicsVersion}\n`));
+                                }
+                            }
                         }
                         else if (dryRun) {
                             console.info(chalk.bold('═══════════════════════════════════════════════════'));

package/lib/template-merge/classify.js

@@ -6,7 +6,7 @@ const fs = require("fs");
 const path = require("path");
 const excludes_1 = require("./excludes");
 function classifyFile(input) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g;
     const { baseExists, oursExists, theirsExists } = input;
     if (!baseExists && !oursExists && !theirsExists) {
         throw new Error('classifyFile: impossible state — file in none of the three sides');
@@ -21,19 +21,31 @@ function classifyFile(input) {
     if (baseExists && !oursExists && !theirsExists)
         return 'noop';
     if (baseExists && !oursExists && theirsExists) {
-        // Instance lacks a file the template has. If the instance NEVER tracked it
+        if (((_b = input.baseEqTheirs) === null || _b === void 0 ? void 0 : _b.call(input)) === true) {
+            // Template hasn't touched this file since the recorded base — the
+            // instance's deletion is an old, already-final decision. Still
+            // surface a recurring info notice (never a conflict): never-tracked →
+            // adoptable (optional feature); previously-tracked → keptDeleted
+            // ("absent here; we won't restore it"). No callback → we can't tell a
+            // deletion from "never had it", so stay on the side that copies
+            // nothing (keptDeleted).
+            return ((_c = input.oursEverTracked) === null || _c === void 0 ? void 0 : _c.call(input)) === false ? 'adoptable' : 'keptDeleted';
+        }
+        // Template HAS since modified the file. If the instance NEVER tracked it
         // in git, it's a template feature the instance simply never had → optional
-        // adoption (adoptable). If it was tracked and later deleted, it's a genuine
-        // delete/modify conflict. When we can't tell (no callback / no git), stay
-        // conservative → deleteModifyConflict (the historical behaviour).
-        return ((_b = input.oursEverTracked) === null || _b === void 0 ? void 0 : _b.call(input)) === false ? 'adoptable' : 'deleteModifyConflict';
+        // adoption (adoptable). If it was tracked and later deleted, surface a
+        // one-time informational notice (deleteModifyConflict — no longer treated
+        // as a blocking conflict; the deletion is kept by default). When we can't
+        // tell (no callback / no git), stay conservative → deleteModifyConflict
+        // (the historical behaviour).
+        return ((_d = input.oursEverTracked) === null || _d === void 0 ? void 0 : _d.call(input)) === false ? 'adoptable' : 'deleteModifyConflict';
     }
     if (baseExists && oursExists && !theirsExists) {
-        return ((_c = input.oursEqBase) === null || _c === void 0 ? void 0 : _c.call(input)) ? 'delete' : 'modifyDeleteConflict';
+        return ((_e = input.oursEqBase) === null || _e === void 0 ? void 0 : _e.call(input)) ? 'delete' : 'modifyDeleteConflict';
     }
     // ✓✓✓ — all three sides exist.
     // Fast path 1: ours already equals theirs → no merge needed.
-    if ((_d = input.oursEqTheirs) === null || _d === void 0 ? void 0 : _d.call(input))
+    if ((_f = input.oursEqTheirs) === null || _f === void 0 ? void 0 : _f.call(input))
         return 'keep';
     // Fast path 2: base equals theirs → template hasn't changed for this file
     // since the recorded base. A 3-way merge would produce ours unchanged
@@ -41,7 +53,7 @@ function classifyFile(input) {
     // avoid spurious "Updated" entries on every run when the instance has
     // legitimately diverged from the template — rendered placeholders in
     // init.sql, regenerated yarn.lock files, user-edited .env, etc.
-    if ((_e = input.baseEqTheirs) === null || _e === void 0 ? void 0 : _e.call(input))
+    if ((_g = input.baseEqTheirs) === null || _g === void 0 ? void 0 : _g.call(input))
         return 'keep';
     return 'update';
 }
@@ -57,7 +69,7 @@ function classifyAll(baseDir, oursDir, theirsDir, userExcludes, oursEverTracked)
     const all = new Set([...baseFiles, ...oursFiles, ...theirsFiles]);
     const plan = {
         add: [], keep: [], noop: [],
-        delete: [], update: [], adoptable: [],
+        delete: [], update: [], adoptable: [], keptDeleted: [],
         addAddConflict: [], modifyDeleteConflict: [], deleteModifyConflict: [],
     };
     for (const rel of [...all].sort()) {

package/lib/template-merge/git-history.d.ts

@@ -6,12 +6,14 @@
  * state:
  *   - never tracked  → the template carries a file the instance never had
  *                      (a new feature) → `adoptable` (optional adoption).
- *   - was tracked    → the instance had it and deleted it on purpose
- *                      → genuine `deleteModifyConflict`.
+ *   - was tracked    → the instance had it and deleted it on purpose → the
+ *                      deletion is kept: `keptDeleted` when the template hasn't
+ *                      touched the file since the recorded base,
+ *                      `deleteModifyConflict` when it has.
  *
  * Safety-first fallback: when the directory is NOT a git repo, or git is not on
  * PATH, we return a checker that reports EVERYTHING as tracked (`true`). That
- * keeps the classifier's conservative default (deleteModifyConflict) and makes
+ * keeps the classifier's conservative default (never silently adopt) and makes
  * this feature a no-op for non-git projects — zero behaviour change for them.
  *
  * A git repo with no commits yet resolves to an empty set → every path reports

package/lib/template-merge/git-history.js

@@ -11,12 +11,14 @@ const child_process_1 = require("child_process");
  * state:
  *   - never tracked  → the template carries a file the instance never had
  *                      (a new feature) → `adoptable` (optional adoption).
- *   - was tracked    → the instance had it and deleted it on purpose
- *                      → genuine `deleteModifyConflict`.
+ *   - was tracked    → the instance had it and deleted it on purpose → the
+ *                      deletion is kept: `keptDeleted` when the template hasn't
+ *                      touched the file since the recorded base,
+ *                      `deleteModifyConflict` when it has.
  *
  * Safety-first fallback: when the directory is NOT a git repo, or git is not on
  * PATH, we return a checker that reports EVERYTHING as tracked (`true`). That
- * keeps the classifier's conservative default (deleteModifyConflict) and makes
+ * keeps the classifier's conservative default (never silently adopt) and makes
  * this feature a no-op for non-git projects — zero behaviour change for them.
  *
  * A git repo with no commits yet resolves to an empty set → every path reports

package/lib/template-merge/types.d.ts

@@ -1,5 +1,5 @@
 /** 单个文件在三方合并中的分类结果。 */
-export declare type ClassifyResult = 'add' | 'keep' | 'noop' | 'delete' | 'update' | 'adoptable' | 'addAddConflict' | 'modifyDeleteConflict' | 'deleteModifyConflict';
+export declare type ClassifyResult = 'add' | 'keep' | 'noop' | 'delete' | 'update' | 'adoptable' | 'keptDeleted' | 'addAddConflict' | 'modifyDeleteConflict' | 'deleteModifyConflict';
 export interface ClassifiedPlan {
     add: string[];
     keep: string[];
@@ -7,11 +7,12 @@ export interface ClassifiedPlan {
     delete: string[];
     update: string[];
     adoptable: string[];
+    keptDeleted: string[];
     addAddConflict: string[];
     modifyDeleteConflict: string[];
     deleteModifyConflict: string[];
 }
-export declare type ConflictKind = 'content' | 'add/add' | 'modify/delete' | 'delete/modify' | 'binary';
+export declare type ConflictKind = 'content' | 'add/add' | 'modify/delete' | 'binary';
 export interface ConflictRecord {
     path: string;
     kind: ConflictKind;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gadmin2n/cli",
-  "version": "0.0.191",
+  "version": "0.0.192",
   "description": "Gadmin - modern, fast, powerful node.js web framework (@cli)",
   "publishConfig": {
     "access": "public"
@@ -24,8 +24,9 @@
     "prepublish:npm": "npm run build",
     "publish:npm": "npm publish --access public",
     "updateAndPublish": "node ./updateVersion.js",
+    "pretest": "npm run build",
     "test": "jest --config test/jest-config.json",
-    "test:dev": "npm run clean && jest --config test/jest-config.json --watchAll",
+    "test:dev": "npm run build && jest --config test/jest-config.json --watchAll",
     "prerelease": "npm run build",
     "release": "release-it"
   },