@gadmin2n/cli 0.0.90 → 0.0.92

package/actions/update.action.js

@@ -10,16 +10,955 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateAction = void 0;
-const dependency_managers_1 = require("../lib/dependency-managers");
-const package_managers_1 = require("../lib/package-managers");
+const chalk = require("chalk");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const inquirer = require("inquirer");
+const child_process_1 = require("child_process");
 const abstract_action_1 = require("./abstract.action");
+const template_merge_1 = require("../lib/template-merge");
+const version_check_1 = require("../lib/version-check");
+/* ------------------------------------------------------------------ *
+ * Config / constants
+ * ------------------------------------------------------------------ */
+const DEFAULT_EXCLUDES = [
+    'node_modules',
+    '.git',
+    'dist',
+    'generated',
+    '.DS_Store',
+    '.env.local',
+    'readme.md',
+];
+const CLAUDE_CONTEXT_REPO = 'https://git.tencent.com/OIT-OMC/erp-ai-coding-context.git';
+const CLAUDE_CONTEXT_BRANCH = 'master';
+const CLAUDE_SOURCE_SUBDIR = '.claude';
+const CLAUDE_TARGET_DIRS = ['.claude-internal', '.agent'];
+/* ------------------------------------------------------------------ *
+ * Glob / pattern utilities
+ * ------------------------------------------------------------------ */
+/**
+ * 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] === '*') {
+                if (pattern[i + 2] === '/') {
+                    regexStr += '(?:.+/)?';
+                    i += 3;
+                }
+                else {
+                    regexStr += '.*';
+                    i += 2;
+                }
+            }
+            else {
+                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) {
+    if (filePath === pattern)
+        return true;
+    if (filePath.startsWith(pattern + '/'))
+        return true;
+    const parts = filePath.split('/');
+    if (!pattern.includes('/') &&
+        !pattern.includes('*') &&
+        !pattern.includes('?')) {
+        if (parts.includes(pattern))
+            return true;
+    }
+    if (pattern.includes('*') || pattern.includes('?')) {
+        const regex = globToRegex(pattern);
+        return regex.test(filePath);
+    }
+    return false;
+}
+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 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 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 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}`);
+}
+/* ------------------------------------------------------------------ *
+ * Diff / merge utilities
+ * ------------------------------------------------------------------ */
+function createUnifiedDiff(filePath, instanceContent, templateContent) {
+    const instanceLines = instanceContent.split('\n');
+    const templateLines = templateContent.split('\n');
+    const lines = [];
+    lines.push(chalk.bold(`--- a/${filePath} (instance)`));
+    lines.push(chalk.bold(`+++ b/${filePath} (template)`));
+    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);
+    for (const hunk of hunks.slice(0, 10)) {
+        const contextStart = Math.max(0, hunk.start - 2);
+        lines.push(chalk.cyan(`@@ -${hunk.start + 1},${hunk.instanceLines.length} +${hunk.start + 1},${hunk.templateLines.length} @@`));
+        for (let i = contextStart; i < hunk.start; i++) {
+            if (i < instanceLines.length) {
+                lines.push(` ${instanceLines[i]}`);
+            }
+        }
+        for (const line of hunk.instanceLines) {
+            lines.push(chalk.red(`-${line}`));
+        }
+        for (const line of hunk.templateLines) {
+            lines.push(chalk.green(`+${line}`));
+        }
+        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');
+}
+function tryAutoMerge(instanceContent, templateContent) {
+    const tmpDir = fs.mkdtempSync(path.join(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 });
+    }
+}
+/* ------------------------------------------------------------------ *
+ * .claude context sync (from remote git repo)
+ * ------------------------------------------------------------------ */
+/**
+ * Shallow-clone the remote .claude context repo into a temp dir and return
+ * the absolute path to the `.claude` subfolder. Returns null on failure
+ * (e.g. no network, repo private, credentials missing, etc.).
+ */
+function fetchClaudeContextRepo() {
+    var _a, _b;
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gadmin-claude-ctx-'));
+    try {
+        (0, child_process_1.execSync)(`git clone --depth 1 --branch ${CLAUDE_CONTEXT_BRANCH} ${CLAUDE_CONTEXT_REPO} "${tmpDir}"`, { stdio: 'pipe' });
+        const claudeSrc = path.join(tmpDir, CLAUDE_SOURCE_SUBDIR);
+        if (!fs.existsSync(claudeSrc)) {
+            // Repo cloned, but the .claude dir is missing — treat as no-op
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+            return null;
+        }
+        // Caller is responsible for cleaning up the parent tmpDir.
+        // We return the inner path; we stash the parent on a property so caller
+        // can clean it. To keep things simple, register a process exit cleanup
+        // hook here.
+        process.on('exit', () => {
+            try {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch (_a) {
+                // ignore
+            }
+        });
+        return claudeSrc;
+    }
+    catch (err) {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        const msg = ((_b = (_a = err === null || err === void 0 ? void 0 : err.stderr) === null || _a === void 0 ? void 0 : _a.toString) === null || _b === void 0 ? void 0 : _b.call(_a)) || (err === null || err === void 0 ? void 0 : err.message) || String(err);
+        console.warn(chalk.yellow(`⚠️  Skipping .claude context sync: failed to clone ${CLAUDE_CONTEXT_REPO}\n   ${msg
+            .trim()
+            .split('\n')
+            .join('\n   ')}`));
+        return null;
+    }
+}
+/**
+ * Recursively copy every file under `srcDir` into `destDir`, preserving
+ * relative structure. Existing destination files are NOT overwritten.
+ * Returns counts.
+ */
+function copyTreeNoOverwrite(srcDir, destDir) {
+    let added = 0;
+    let skipped = 0;
+    function walk(rel) {
+        const absSrc = path.join(srcDir, rel);
+        const entries = fs.readdirSync(absSrc, { withFileTypes: true });
+        for (const entry of entries) {
+            const childRel = rel ? path.join(rel, entry.name) : entry.name;
+            const absChildSrc = path.join(srcDir, childRel);
+            const absChildDest = path.join(destDir, childRel);
+            if (entry.isDirectory()) {
+                walk(childRel);
+            }
+            else if (entry.isFile()) {
+                if (fs.existsSync(absChildDest)) {
+                    skipped++;
+                    continue;
+                }
+                fs.mkdirSync(path.dirname(absChildDest), { recursive: true });
+                fs.copyFileSync(absChildSrc, absChildDest);
+                added++;
+            }
+        }
+    }
+    if (!fs.existsSync(srcDir))
+        return { added, skipped };
+    walk('');
+    return { added, skipped };
+}
+function syncClaudeContext(instanceDir, dryRun) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.info(chalk.bold('\n═══════════════════════════════════════════════════'));
+        console.info(chalk.bold('  Sync .claude context'));
+        console.info(chalk.bold('═══════════════════════════════════════════════════'));
+        console.info(`${chalk.gray('Source: ')} ${CLAUDE_CONTEXT_REPO} (${CLAUDE_CONTEXT_BRANCH}) :: ${CLAUDE_SOURCE_SUBDIR}/`);
+        console.info(`${chalk.gray('Targets:')} ${CLAUDE_TARGET_DIRS.map((d) => `${d}/`).join(', ')}\n`);
+        if (dryRun) {
+            console.info(chalk.gray('(dry-run mode — would clone the repo and copy missing files into target dirs)\n'));
+            return;
+        }
+        const claudeSrc = fetchClaudeContextRepo();
+        if (!claudeSrc) {
+            return;
+        }
+        for (const targetName of CLAUDE_TARGET_DIRS) {
+            const destDir = path.join(instanceDir, targetName);
+            fs.mkdirSync(destDir, { recursive: true });
+            const { added, skipped } = copyTreeNoOverwrite(claudeSrc, destDir);
+            const summary = [];
+            if (added > 0)
+                summary.push(`${added} added`);
+            if (skipped > 0)
+                summary.push(`${skipped} kept (already exists)`);
+            if (summary.length === 0)
+                summary.push('no files');
+            console.info(`   ${chalk.cyan(targetName + '/')}  ${summary.join(' | ')}`);
+        }
+        console.info();
+    });
+}
+function snapshotPackageJson(dir, label) {
+    const pkgPath = path.join(dir, 'package.json');
+    const before = fs.existsSync(pkgPath)
+        ? fs.readFileSync(pkgPath, 'utf-8')
+        : null;
+    return { dir, label, before };
+}
+/**
+ * Build a stable, canonical JSON string of only the dependency-related
+ * sections of a package.json. Sub-keys are sorted alphabetically so that
+ * pure formatting / key-order changes do not register as a difference.
+ *
+ * Returns null if the input cannot be parsed as JSON.
+ */
+function canonicalDeps(content) {
+    try {
+        const json = JSON.parse(content);
+        const depKeys = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+        ];
+        const subset = {};
+        for (const key of depKeys) {
+            const val = json[key];
+            if (val && typeof val === 'object' && !Array.isArray(val)) {
+                const sorted = {};
+                for (const sk of Object.keys(val).sort()) {
+                    sorted[sk] = val[sk];
+                }
+                subset[key] = sorted;
+            }
+        }
+        return JSON.stringify(subset);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * Determine whether the dependency-related sections of package.json have
+ * meaningfully changed between two snapshots. Ignores formatting / key
+ * order / unrelated fields like name / scripts / description.
+ *
+ * - First-time existence (before === null) → considered changed (need install).
+ * - Identical bytes → no change (fast path).
+ * - Either side fails to parse → fall back to raw byte comparison (safe default).
+ */
+function depsChanged(before, after) {
+    if (before === null)
+        return true;
+    if (before === after)
+        return false;
+    const cBefore = canonicalDeps(before);
+    const cAfter = canonicalDeps(after);
+    if (cBefore === null || cAfter === null) {
+        return before !== after;
+    }
+    return cBefore !== cAfter;
+}
+function detectInstallCommand(dir) {
+    if (fs.existsSync(path.join(dir, 'yarn.lock'))) {
+        return { cmd: 'yarn', manager: 'yarn' };
+    }
+    if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) {
+        return { cmd: 'pnpm install', manager: 'pnpm' };
+    }
+    return { cmd: 'npm install', manager: 'npm' };
+}
+function maybeInstallChangedDeps(snapshots, dryRun) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const changed = [];
+        const skippedNoDepChange = [];
+        for (const snap of snapshots) {
+            const pkgPath = path.join(snap.dir, 'package.json');
+            if (!fs.existsSync(pkgPath))
+                continue;
+            const after = fs.readFileSync(pkgPath, 'utf-8');
+            if (depsChanged(snap.before, after)) {
+                changed.push(snap);
+            }
+            else if (snap.before !== after) {
+                // package.json bytes changed but deps did not (e.g. scripts / formatting only)
+                skippedNoDepChange.push(snap.label);
+            }
+        }
+        if (changed.length === 0 && skippedNoDepChange.length === 0)
+            return;
+        console.info(chalk.bold('\n═══════════════════════════════════════════════════'));
+        console.info(chalk.bold('  Install dependencies for changed package.json'));
+        console.info(chalk.bold('═══════════════════════════════════════════════════\n'));
+        for (const label of skippedNoDepChange) {
+            console.info(`   ${chalk.cyan(label + '/')} package.json changed but deps unchanged — ${chalk.gray('skip install')}`);
+        }
+        for (const snap of changed) {
+            const { cmd, manager } = detectInstallCommand(snap.dir);
+            console.info(`   ${chalk.cyan(snap.label + '/')} deps changed — using ${chalk.bold(manager)}: ${chalk.gray(cmd)}`);
+            if (dryRun) {
+                console.info(chalk.gray(`   (dry-run: skip running)\n`));
+                continue;
+            }
+            try {
+                (0, child_process_1.execSync)(cmd, { cwd: snap.dir, stdio: 'inherit' });
+                console.info(chalk.green(`   ✓ ${snap.label}/ install done\n`));
+            }
+            catch (err) {
+                console.warn(chalk.yellow(`   ⚠️  ${snap.label}/ install failed: ${(err === null || err === void 0 ? void 0 : err.message) || err}\n`));
+            }
+        }
+    });
+}
+/* ------------------------------------------------------------------ *
+ * Smart merger registry
+ * ------------------------------------------------------------------ */
+const DEFAULT_MERGER_RULES = [
+    { pattern: 'package.json', mergerName: 'json' },
+    { pattern: '**/package.json', mergerName: 'json' },
+    { pattern: 'tsconfig*.json', mergerName: 'json' },
+    { pattern: '**/tsconfig*.json', mergerName: 'json' },
+    { pattern: '**/*.module.ts', mergerName: 'ts-module' },
+    { pattern: 'config/prisma/*.prisma', mergerName: 'prisma' },
+    { pattern: 'server/prisma/schema.prisma', mergerName: 'prisma' },
+    { pattern: '.env', mergerName: 'env' },
+    { pattern: '.env.*', mergerName: 'env' },
+    { pattern: '**/.env', mergerName: 'env' },
+    { pattern: '**/.env.*', mergerName: 'env' },
+];
+function buildMergerRegistry(userConfig) {
+    const reg = new template_merge_1.MergerRegistry();
+    reg.register(new template_merge_1.JsonMerger());
+    reg.register(new template_merge_1.EnvMerger());
+    reg.register(new template_merge_1.PrismaMerger());
+    reg.register(new template_merge_1.TsModuleMerger());
+    if ((userConfig === null || userConfig === void 0 ? void 0 : userConfig.mergers) && Object.keys(userConfig.mergers).length > 0) {
+        // 用户配置完全替换默认规则
+        for (const [pattern, mergerName] of Object.entries(userConfig.mergers)) {
+            reg.addRule({ pattern, mergerName });
+        }
+    }
+    else {
+        for (const rule of DEFAULT_MERGER_RULES) {
+            reg.addRule(rule);
+        }
+    }
+    return reg;
+}
+/* ------------------------------------------------------------------ *
+ * Action
+ * ------------------------------------------------------------------ */
 class UpdateAction extends abstract_action_1.AbstractAction {
     handle(inputs, options) {
+        var _a, _b;
+        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 && subcommand !== 'update' && subcommand !== 'diff') {
+                console.error(chalk.red(`Unknown subcommand "${subcommand}". Expected: (none) | diff`));
+                process.exit(1);
+            }
+            // Pre-flight version check (B): silent network call to npm registry,
+            // hard 1.5s timeout, never blocks. Prints a yellow banner if outdated.
+            const versionCheckEnabled = ((_b = options.find((o) => o.name === 'version-check')) === null || _b === void 0 ? void 0 : _b.value) !==
+                false;
+            if (versionCheckEnabled) {
+                try {
+                    const info = yield (0, version_check_1.checkVersion)(1500);
+                    if (info && (0, version_check_1.compareVersions)(info.installed, info.latest) < 0) {
+                        (0, version_check_1.printOutdatedWarning)(info);
+                    }
+                }
+                catch (_c) {
+                    // never let the version check break update
+                }
+            }
+            if (subcommand === 'diff') {
+                yield this.handleDiff(options);
+                return;
+            }
+            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);
+            const modified = [];
+            const onlyInTemplate = [];
+            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);
+                }
+            }
+            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;
+            }
+            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, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            const force = options.find((option) => option.name === 'force');
-            const tag = options.find((option) => option.name === 'tag');
-            const manager = new dependency_managers_1.NestDependencyManager(yield package_managers_1.PackageManagerFactory.find());
-            yield manager.update(force.value, tag.value);
+            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;
+            const smartMergeEnabled = (_d = (_c = options.find((o) => o.name === 'smart-merge')) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : true;
+            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`);
+            // Build smart-merger registry (or null if disabled)
+            const userTemplateUpdate = smartMergeEnabled
+                ? (0, template_merge_1.loadTemplateUpdateConfig)(instanceDir)
+                : null;
+            const registry = smartMergeEnabled
+                ? buildMergerRegistry(userTemplateUpdate)
+                : null;
+            const userPolicies = userTemplateUpdate === null || userTemplateUpdate === void 0 ? void 0 : userTemplateUpdate.policies;
+            // Snapshot package.json files BEFORE any writes. We watch:
+            //   - <instanceDir>/package.json       (root, if present — workspace / husky / etc.)
+            //   - <instanceDir>/web/package.json
+            //   - <instanceDir>/server/package.json
+            const pkgSnapshots = [
+                snapshotPackageJson(instanceDir, '(root)'),
+                snapshotPackageJson(path.join(instanceDir, 'web'), 'web'),
+                snapshotPackageJson(path.join(instanceDir, 'server'), 'server'),
+            ];
+            const templateFiles = collectFiles(templateDir, excludes);
+            const instanceFiles = collectFiles(instanceDir, excludes);
+            const instanceSet = new Set(instanceFiles);
+            const toUpdate = [];
+            const toAdd = [];
+            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'));
+            }
+            else {
+                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) {
+                    if (!autoYes) {
+                        const { confirm } = yield inquirer.prompt([
+                            {
+                                type: 'confirm',
+                                name: 'confirm',
+                                message: 'Proceed with template update?',
+                                default: false,
+                            },
+                        ]);
+                        if (!confirm) {
+                            console.info('Cancelled.\n');
+                            return;
+                        }
+                    }
+                    let skippedCount = 0;
+                    let overwrittenCount = 0;
+                    let mergedCount = 0;
+                    let conflictCount = 0;
+                    let smartCount = 0;
+                    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');
+                        // 1. Try smart merger if registered for this file
+                        const smartMerger = registry
+                            ? registry.resolve(file)
+                            : null;
+                        let smartResult = null;
+                        if (smartMerger) {
+                            try {
+                                smartResult = yield smartMerger.merge({
+                                    filePath: file,
+                                    instancePath: path.join(instanceDir, file),
+                                    templatePath: path.join(templateDir, file),
+                                    instanceContent: iContent,
+                                    templateContent: tContent,
+                                    policies: userPolicies,
+                                });
+                            }
+                            catch (err) {
+                                smartResult = {
+                                    ok: false,
+                                    reason: (err === null || err === void 0 ? void 0 : err.message) || String(err),
+                                };
+                            }
+                        }
+                        let strategy = applyAll;
+                        if (!strategy) {
+                            if (autoYes) {
+                                // autoYes: prefer smart merge when available, else conflict markers
+                                strategy =
+                                    smartResult && smartResult.ok ? 'smart' : 'conflict';
+                            }
+                            else {
+                                const diff = createUnifiedDiff(file, iContent, tContent);
+                                console.info(`\n${chalk.bold(`[${i + 1}/${toUpdate.length}]`)} ${chalk.yellow(file)}`);
+                                console.info(diff);
+                                console.info();
+                                const choices = [];
+                                if (smartResult && smartResult.ok) {
+                                    const summary = smartResult.notes.slice(0, 3).join('; ');
+                                    const more = smartResult.notes.length > 3 ? '...' : '';
+                                    choices.push({
+                                        name: `Smart merge — ${smartMerger.name} (recommended): ${summary}${more}`,
+                                        value: 'smart',
+                                        short: 'smart',
+                                    });
+                                }
+                                else if (smartMerger) {
+                                    const reason = smartResult && !smartResult.ok
+                                        ? smartResult.reason
+                                        : 'no result';
+                                    choices.push({
+                                        name: `Smart merge — ${smartMerger.name} (UNAVAILABLE: ${reason})`,
+                                        value: 'smart-unavailable',
+                                        short: 'smart-unavailable',
+                                        disabled: reason,
+                                    });
+                                }
+                                choices.push({
+                                    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());
+                                if (smartResult && smartResult.ok) {
+                                    choices.push({
+                                        name: 'Smart-merge ALL remaining (where supported)',
+                                        value: 'smart-all',
+                                        short: 'smart all',
+                                    });
+                                }
+                                choices.push({
+                                    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',
+                                });
+                                const { action } = yield inquirer.prompt([
+                                    {
+                                        type: 'list',
+                                        name: 'action',
+                                        message: `How to handle ${file}?`,
+                                        default: smartResult && smartResult.ok ? 'smart' : 'skip',
+                                        choices,
+                                    },
+                                ]);
+                                if (action.endsWith('-all')) {
+                                    applyAll = action.replace('-all', '');
+                                    strategy = applyAll;
+                                }
+                                else {
+                                    strategy = action;
+                                }
+                            }
+                        }
+                        const destPath = path.join(instanceDir, file);
+                        switch (strategy) {
+                            case 'smart':
+                                if (smartResult && smartResult.ok) {
+                                    fs.writeFileSync(destPath, smartResult.merged, 'utf-8');
+                                    smartCount++;
+                                    console.info(chalk.green(`   ✓  ${file} — smart merge (${smartMerger.name})`));
+                                    for (const note of smartResult.notes) {
+                                        console.info(chalk.gray(`      • ${note}`));
+                                    }
+                                }
+                                else {
+                                    // No smart merger usable: fallback to conflict markers
+                                    fs.writeFileSync(destPath, createConflictContent(iContent, tContent), 'utf-8');
+                                    conflictCount++;
+                                    console.info(chalk.yellow(`   ⚠️  ${file} — no smart merger available, wrote conflict markers`));
+                                }
+                                break;
+                            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;
+                        }
+                    }
+                    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✅ Template update complete!\n'));
+                    const stats = [];
+                    if (overwrittenCount > 0)
+                        stats.push(`${overwrittenCount} overwritten`);
+                    if (smartCount > 0)
+                        stats.push(`${smartCount} smart-merged`);
+                    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`));
+                    }
+                }
+                else {
+                    console.info(chalk.gray('(dry-run mode, no template changes made)\n'));
+                }
+            }
+            // 2. Sync .claude context (regardless of whether template had changes)
+            yield syncClaudeContext(instanceDir, dryRun);
+            // 3. If web/server package.json changed during template update, install deps
+            yield maybeInstallChangedDeps(pkgSnapshots, dryRun);
         });
     }
 }