@gadmin2n/cli 0.0.169 → 0.0.170

package/actions/update.action.js

@@ -23,6 +23,7 @@ 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");
 const classify_1 = require("../lib/template-merge/classify");
+const git_history_1 = require("../lib/template-merge/git-history");
 const excludes_1 = require("../lib/template-merge/excludes");
 const base_store_1 = require("../lib/template-merge/base-store");
 const materialize_1 = require("../lib/template-merge/materialize");
@@ -487,6 +488,81 @@ function handleBinary(rel, baseRoot, oursRoot, theirsRoot, opts, conflicts) {
     console.warn(chalk.gray(`      template(theirs): ${theirsPath}`));
     console.warn(chalk.gray(`      base:     ${basePath}`));
 }
+/**
+ * Interactive batch picker for a group of files the instance could adopt from
+ * the template. Returns the subset the user chose to adopt. Default action is
+ * "skip all" so hitting Enter never pulls in unwanted files.
+ */
+function pickAdoptions(label, files) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { mode } = yield inquirer.prompt([
+            {
+                type: 'list',
+                name: 'mode',
+                message: `${files.length} ${label}. What would you like to do?`,
+                choices: [
+                    { name: 'Skip all — keep them out of your instance (default)', value: 'skip' },
+                    { name: 'Adopt all — copy them from the template', value: 'all' },
+                    { name: 'Choose per-file', value: 'choose' },
+                ],
+                default: 'skip',
+            },
+        ]);
+        if (mode === 'all')
+            return [...files];
+        if (mode === 'skip')
+            return [];
+        const { picks } = yield inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'picks',
+                message: 'Select files to adopt:',
+                choices: files.map((f) => ({ name: f, value: f })),
+            },
+        ]);
+        return picks;
+    });
+}
+/**
+ * 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.
+ *
+ * Resolution policy:
+ *   --theirs → adopt everything;  --ours / --yes → adopt nothing;
+ *   interactive → batch prompt per 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: 'deleteModifyConflict',
+                label: 'file(s) you previously deleted that the template has since modified',
+            },
+        ];
+        for (const g of groups) {
+            const files = plan[g.bucket];
+            if (files.length === 0)
+                continue;
+            let adopt;
+            if (opts.theirs)
+                adopt = [...files];
+            else if (opts.ours || autoYes)
+                adopt = [];
+            else
+                adopt = yield pickAdoptions(g.label, files);
+            if (adopt.length === 0)
+                continue;
+            const adoptSet = new Set(adopt);
+            for (const rel of adopt)
+                plan.add.push(rel);
+            plan[g.bucket] = files.filter((f) => !adoptSet.has(f));
+        }
+    });
+}
 function applyPlan(plan, baseRoot, oursRoot, theirsRoot, opts) {
     const conflicts = [];
     for (const rel of plan.add) {
@@ -603,6 +679,13 @@ function printPlanFileLists(plan, opts) {
             console.info(`   ${f}`);
         console.info();
     }
+    if (plan.adoptable.length > 0) {
+        console.info(chalk.cyan(`🆕 Adoptable (optional) — ${plan.adoptable.length} file${plural(plan.adoptable.length)} the template provides that your instance never had`));
+        for (const f of plan.adoptable)
+            console.info(`   ${f}`);
+        console.info(chalk.gray('   Not conflicts — skipped by default. Adopt interactively or with --theirs.'));
+        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)
@@ -814,7 +897,8 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                     ? `(materialized from schematics ${meta.schematicsVersion})`
                     : '(not yet established — run `gadmin2 update` once to bootstrap)'}`);
                 console.info();
-                const plan = (0, classify_1.classifyAll)(baseRoot, instanceDir, theirsRoot, userExcludes);
+                const oursEverTracked = (0, git_history_1.buildEverTrackedChecker)(instanceDir);
+                const plan = (0, classify_1.classifyAll)(baseRoot, instanceDir, theirsRoot, userExcludes, oursEverTracked);
                 if (filterFile) {
                     printPerFileTriDiff(filterFile, baseRoot, instanceDir, theirsRoot, metaExists);
                     return;
@@ -827,6 +911,11 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                     plan.add.forEach((f) => console.info(`   ${f}`));
                     console.info();
                 }
+                if (plan.adoptable.length > 0) {
+                    console.info(chalk.cyan(`🆕 Adoptable — optional, never had (${plan.adoptable.length} files)`));
+                    plan.adoptable.forEach((f) => console.info(`   ${f}`));
+                    console.info();
+                }
                 if (plan.delete.length > 0) {
                     console.info(chalk.red(`🗑  To delete (${plan.delete.length} files)`));
                     plan.delete.forEach((f) => console.info(`   ${f}`));
@@ -847,7 +936,7 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                     conflicts.forEach(([k, p]) => console.info(`   [${k}] ${p}`));
                     console.info();
                 }
-                if (plan.add.length + plan.delete.length + plan.update.length + conflicts.length === 0) {
+                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'));
                 }
             }
@@ -906,12 +995,19 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                     console.error(chalk.red(formatMaterializeError(meta.schematicsVersion, err)));
                     process.exit(2);
                 }
-                const plan = (0, classify_1.classifyAll)(baseHandle.dir, instanceDir, theirsHandle.dir, userExcludes);
+                const oursEverTracked = (0, git_history_1.buildEverTrackedChecker)(instanceDir);
+                const plan = (0, classify_1.classifyAll)(baseHandle.dir, instanceDir, theirsHandle.dir, userExcludes, oursEverTracked);
                 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.
+                if (plan.adoptable.length > 0) {
+                    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'));
+                }
                 const totalConflicts = residual.length + structural.length;
                 if (totalConflicts === 0) {
                     console.info('Instance state:  ' + chalk.green('✅ clean (no unresolved conflicts)\n'));
@@ -1034,9 +1130,11 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                             process.exit(1);
                         }
                         const baseRoot = baseHandle.dir;
-                        // Classify three sides.
-                        const plan = (0, classify_1.classifyAll)(baseRoot, instanceDir, theirsRoot, userExcludes);
-                        const totalChanges = plan.add.length + plan.delete.length + plan.update.length +
+                        // Classify three sides. git history lets us tell "instance never had
+                        // this file" (adoptable) from "instance deleted it" (deleteModifyConflict).
+                        const oursEverTracked = (0, git_history_1.buildEverTrackedChecker)(instanceDir);
+                        const plan = (0, classify_1.classifyAll)(baseRoot, instanceDir, theirsRoot, userExcludes, oursEverTracked);
+                        const totalChanges = plan.add.length + plan.delete.length + plan.update.length + plan.adoptable.length +
                             plan.addAddConflict.length + plan.modifyDeleteConflict.length + plan.deleteModifyConflict.length;
                         if (totalChanges === 0) {
                             console.info(chalk.green('✅ Instance is up to date with template.\n'));
@@ -1050,7 +1148,10 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                         }
                         else {
                             // Pre-apply preview + confirm (skipped under --yes).
-                            const applyAndReport = () => {
+                            const applyAndReport = () => __awaiter(this, void 0, void 0, function* () {
+                                // Decide which never-had / previously-deleted files to adopt, then
+                                // fold them into plan.add before applying.
+                                yield resolveAdoptions(plan, mergeOpts, autoYes);
                                 const conflicts = applyPlan(plan, baseRoot, instanceDir, theirsRoot, mergeOpts);
                                 changesApplied = true;
                                 // Always advance meta to new version, even when conflicts present (invariant #2).
@@ -1064,13 +1165,13 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                                 try {
                                     (0, executable_paths_1.ensureExecutableBits)(instanceDir);
                                 }
-                                catch (_a) {
+                                catch (_j) {
                                     // best-effort, never fatal
                                 }
                                 printSummary(plan, conflicts, templateName, schematicsVersion);
-                            };
+                            });
                             if (autoYes) {
-                                applyAndReport();
+                                yield applyAndReport();
                             }
                             else {
                                 console.info(chalk.bold('\n═══════════════════════════════════════════════════'));
@@ -1087,7 +1188,7 @@ class UpdateAction extends abstract_action_1.AbstractAction {
                                     },
                                 ]);
                                 if (proceedTemplate) {
-                                    applyAndReport();
+                                    yield applyAndReport();
                                 }
                                 else {
                                     console.info(chalk.gray('\nTemplate update skipped — base & files unchanged.\n'));

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

@@ -6,6 +6,7 @@ export interface ClassifyInput {
     oursEqBase?: () => boolean;
     oursEqTheirs?: () => boolean;
     baseEqTheirs?: () => boolean;
+    oursEverTracked?: () => boolean;
 }
 export declare function classifyFile(input: ClassifyInput): ClassifyResult;
-export declare function classifyAll(baseDir: string, oursDir: string, theirsDir: string, userExcludes: string[]): ClassifiedPlan;
+export declare function classifyAll(baseDir: string, oursDir: string, theirsDir: string, userExcludes: string[], oursEverTracked?: (rel: string) => boolean): ClassifiedPlan;

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;
+    var _a, _b, _c, _d, _e;
     const { baseExists, oursExists, theirsExists } = input;
     if (!baseExists && !oursExists && !theirsExists) {
         throw new Error('classifyFile: impossible state — file in none of the three sides');
@@ -20,14 +20,20 @@ function classifyFile(input) {
     }
     if (baseExists && !oursExists && !theirsExists)
         return 'noop';
-    if (baseExists && !oursExists && theirsExists)
-        return 'deleteModifyConflict';
+    if (baseExists && !oursExists && theirsExists) {
+        // Instance lacks a file the template has. 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';
+    }
     if (baseExists && oursExists && !theirsExists) {
-        return ((_b = input.oursEqBase) === null || _b === void 0 ? void 0 : _b.call(input)) ? 'delete' : 'modifyDeleteConflict';
+        return ((_c = input.oursEqBase) === null || _c === void 0 ? void 0 : _c.call(input)) ? 'delete' : 'modifyDeleteConflict';
     }
     // ✓✓✓ — all three sides exist.
     // Fast path 1: ours already equals theirs → no merge needed.
-    if ((_c = input.oursEqTheirs) === null || _c === void 0 ? void 0 : _c.call(input))
+    if ((_d = input.oursEqTheirs) === null || _d === void 0 ? void 0 : _d.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
@@ -35,7 +41,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 ((_d = input.baseEqTheirs) === null || _d === void 0 ? void 0 : _d.call(input))
+    if ((_e = input.baseEqTheirs) === null || _e === void 0 ? void 0 : _e.call(input))
         return 'keep';
     return 'update';
 }
@@ -43,7 +49,7 @@ exports.classifyFile = classifyFile;
 function fileBytesEqual(p, q) {
     return fs.readFileSync(p).equals(fs.readFileSync(q));
 }
-function classifyAll(baseDir, oursDir, theirsDir, userExcludes) {
+function classifyAll(baseDir, oursDir, theirsDir, userExcludes, oursEverTracked) {
     const excludes = [...excludes_1.HARDCODED_EXCLUDES, ...userExcludes];
     const baseFiles = new Set((0, excludes_1.collectFiles)(baseDir, excludes));
     const oursFiles = new Set((0, excludes_1.collectFiles)(oursDir, excludes));
@@ -51,7 +57,7 @@ function classifyAll(baseDir, oursDir, theirsDir, userExcludes) {
     const all = new Set([...baseFiles, ...oursFiles, ...theirsFiles]);
     const plan = {
         add: [], keep: [], noop: [],
-        delete: [], update: [],
+        delete: [], update: [], adoptable: [],
         addAddConflict: [], modifyDeleteConflict: [], deleteModifyConflict: [],
     };
     for (const rel of [...all].sort()) {
@@ -65,6 +71,7 @@ function classifyAll(baseDir, oursDir, theirsDir, userExcludes) {
             oursEqBase: () => baseExists && oursExists && fileBytesEqual(path.join(baseDir, rel), path.join(oursDir, rel)),
             oursEqTheirs: () => oursExists && theirsExists && fileBytesEqual(path.join(oursDir, rel), path.join(theirsDir, rel)),
             baseEqTheirs: () => baseExists && theirsExists && fileBytesEqual(path.join(baseDir, rel), path.join(theirsDir, rel)),
+            oursEverTracked: oursEverTracked ? () => oursEverTracked(rel) : undefined,
         });
         plan[result].push(rel);
     }

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

@@ -0,0 +1,21 @@
+/**
+ * Build a checker that answers: "has this relative path EVER been tracked in
+ * the instance's git repository?"
+ *
+ * Used by the 3-way classifier to disambiguate the `base有 / ours无 / theirs有`
+ * 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`.
+ *
+ * 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
+ * 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
+ * `false` (never tracked). That's the correct signal: nothing has ever been
+ * committed, so any template file the instance lacks is genuinely "never had".
+ */
+export declare function buildEverTrackedChecker(instanceDir: string): (rel: string) => boolean;

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEverTrackedChecker = void 0;
+// cli/lib/template-merge/git-history.ts
+const child_process_1 = require("child_process");
+/**
+ * Build a checker that answers: "has this relative path EVER been tracked in
+ * the instance's git repository?"
+ *
+ * Used by the 3-way classifier to disambiguate the `base有 / ours无 / theirs有`
+ * 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`.
+ *
+ * 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
+ * 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
+ * `false` (never tracked). That's the correct signal: nothing has ever been
+ * committed, so any template file the instance lacks is genuinely "never had".
+ */
+function buildEverTrackedChecker(instanceDir) {
+    if (!isGitRepo(instanceDir)) {
+        return () => true; // conservative: can't tell → treat as tracked
+    }
+    const tracked = collectEverTrackedPaths(instanceDir);
+    return (rel) => tracked.has(normalizeRel(rel));
+}
+exports.buildEverTrackedChecker = buildEverTrackedChecker;
+function isGitRepo(instanceDir) {
+    try {
+        const out = (0, child_process_1.execFileSync)('git', ['-C', instanceDir, 'rev-parse', '--is-inside-work-tree'], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8' });
+        return out.trim() === 'true';
+    }
+    catch (_a) {
+        // ENOENT (git missing) or exit 128 (not a repo) → not usable
+        return false;
+    }
+}
+/**
+ * Union of:
+ *   - every path touched by any commit on any branch (`git log --all --name-only`)
+ *   - every path currently tracked in the index (`git ls-files`)
+ * The first captures files that were added-then-deleted; the second captures
+ * staged-but-never-committed files. Together they answer "ever tracked".
+ */
+function collectEverTrackedPaths(instanceDir) {
+    const paths = new Set();
+    // Historical: all paths ever touched across all refs. Empty on a repo with
+    // no commits (git exits 128) — swallowed, leaving the set to be filled by
+    // ls-files (also empty for a fresh repo).
+    addLines(paths, runGitLines(instanceDir, [
+        'log',
+        '--all',
+        '--pretty=format:',
+        '--name-only',
+    ]));
+    // Current index.
+    addLines(paths, runGitLines(instanceDir, ['ls-files']));
+    return paths;
+}
+function runGitLines(instanceDir, args) {
+    try {
+        // core.quotePath=false → git emits UTF-8 paths verbatim instead of
+        // octal-escaping non-ASCII bytes inside quotes, so plain string compare works.
+        const out = (0, child_process_1.execFileSync)('git', ['-C', instanceDir, '-c', 'core.quotePath=false', ...args], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            encoding: 'utf-8',
+            maxBuffer: 64 * 1024 * 1024,
+        });
+        return out.split('\n');
+    }
+    catch (_a) {
+        // No commits yet / any git error → treat as "no paths from this source".
+        return [];
+    }
+}
+function addLines(set, lines) {
+    for (const line of lines) {
+        const rel = normalizeRel(line);
+        if (rel)
+            set.add(rel);
+    }
+}
+function normalizeRel(rel) {
+    // classify.ts builds rel paths with '/'; git already uses '/'. Trim and
+    // strip any surrounding quotes git may add for paths with special chars.
+    return rel.trim().replace(/^"|"$/g, '');
+}

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

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

package/package.json

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