@gadmin2n/cli 0.0.90 → 0.0.92

package/commands/command.loader.js

@@ -9,8 +9,8 @@ const build_command_1 = require("./build.command");
 const generate_command_1 = require("./generate.command");
 const info_command_1 = require("./info.command");
 const new_command_1 = require("./new.command");
+const self_update_command_1 = require("./self-update.command");
 const start_command_1 = require("./start.command");
-const template_command_1 = require("./template.command");
 const update_command_1 = require("./update.command");
 class CommandLoader {
     static load(program) {
@@ -19,7 +19,7 @@ class CommandLoader {
         new start_command_1.StartCommand(new actions_1.StartAction()).load(program);
         new info_command_1.InfoCommand(new actions_1.InfoAction()).load(program);
         new update_command_1.UpdateCommand(new actions_1.UpdateAction()).load(program);
-        new template_command_1.TemplateCommand(new actions_1.TemplateAction()).load(program);
+        new self_update_command_1.SelfUpdateCommand(new actions_1.SelfUpdateAction()).load(program);
         new add_command_1.AddCommand(new actions_1.AddAction()).load(program);
         new generate_command_1.GenerateCommand(new actions_1.GenerateAction()).load(program);
         this.handleInvalidCommand(program);

package/commands/{template.command.d.ts → self-update.command.d.ts}

@@ -1,5 +1,5 @@
 import { CommanderStatic } from 'commander';
 import { AbstractCommand } from './abstract.command';
-export declare class TemplateCommand extends AbstractCommand {
+export declare class SelfUpdateCommand extends AbstractCommand {
     load(program: CommanderStatic): void;
 }

package/commands/self-update.command.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelfUpdateCommand = void 0;
+const abstract_command_1 = require("./abstract.command");
+class SelfUpdateCommand extends abstract_command_1.AbstractCommand {
+    load(program) {
+        program
+            .command('self-update')
+            .description('Upgrade the gadmin2 CLI itself.\n\n' +
+            '  By default upgrades to the latest stable release on npm.\n' +
+            '  The package manager (npm | yarn | pnpm) is auto-detected from\n' +
+            '  the CLI install path; override with --manager if needed.\n' +
+            '  Pass --check to only print version status without installing.')
+            .option('-t, --tag <tag>', 'Install a specific dist-tag (latest | next | beta | rc | ...).', 'latest')
+            .option('-m, --manager <name>', 'Force the package manager (npm | yarn | pnpm); overrides auto-detection.')
+            .option('--check', 'Only check for updates; do not install.')
+            .action((command) => __awaiter(this, void 0, void 0, function* () {
+            const options = [];
+            options.push({ name: 'tag', value: command.tag || 'latest' });
+            options.push({ name: 'manager', value: command.manager || '' });
+            options.push({ name: 'check', value: !!command.check });
+            yield this.action.handle([], options);
+        }));
+    }
+}
+exports.SelfUpdateCommand = SelfUpdateCommand;

package/commands/update.command.js

@@ -14,16 +14,33 @@ const abstract_command_1 = require("./abstract.command");
 class UpdateCommand extends abstract_command_1.AbstractCommand {
     load(program) {
         program
-            .command('update')
+            .command('update [subcommand]')
             .alias('u')
-            .description('Update Gadmin dependencies.')
-            .option('-f, --force', 'Remove and re-install dependencies (instead of update).')
-            .option('-t, --tag <tag>', 'Upgrade to tagged packages (latest | beta | rc | next tag).')
-            .action((command) => __awaiter(this, void 0, void 0, function* () {
+            .description('Update project from template, sync .claude context, and install changed deps.\n\n' +
+            '  Subcommands:\n' +
+            '    (none)    Pull updates from template into instance, sync .claude → .claude-internal/.agent,\n' +
+            '              and run install in web/ or server/ if their package.json changed.\n' +
+            '    diff      Show differences between instance and template (read-only).\n\n' +
+            '  Update strategies (per-file interactive prompt):\n' +
+            '    skip        Keep instance file as-is\n' +
+            '    overwrite   Replace with template version\n' +
+            '    merge       Attempt auto merge via git merge-file\n' +
+            '    conflict    Write conflict markers for manual resolve\n')
+            .option('--no-content', '[diff] Only show file list, skip inline diff content.')
+            .option('-d, --dry-run', '[update] Show what would be updated without making changes.')
+            .option('-y, --yes', '[update] Skip per-file prompt, use conflict markers for all.')
+            .option('--no-smart-merge', '[update] Disable smart structural mergers; use line-level prompt for every file.')
+            .option('--no-version-check', '[update | diff] Skip the npm registry version check at startup.')
+            .action((subcommand, command) => __awaiter(this, void 0, void 0, function* () {
+            const inputs = [];
+            inputs.push({ name: 'subcommand', value: subcommand || '' });
             const options = [];
-            options.push({ name: 'force', value: !!command.force });
-            options.push({ name: 'tag', value: command.tag });
-            yield this.action.handle([], options);
+            options.push({ name: 'no-content', value: !command.content });
+            options.push({ name: 'dry-run', value: !!command.dryRun });
+            options.push({ name: 'yes', value: !!command.yes });
+            options.push({ name: 'smart-merge', value: command.smartMerge !== false });
+            options.push({ name: 'version-check', value: command.versionCheck !== false });
+            yield this.action.handle(inputs, options);
         }));
     }
 }

package/lib/install-manager.d.ts

@@ -0,0 +1,48 @@
+export declare type InstallManager = 'npm' | 'yarn' | 'pnpm' | 'unknown';
+export interface DetectionResult {
+    /** Final manager to use (after applying availability fallback). */
+    manager: InstallManager;
+    /** What the path pattern told us, before any fallback. */
+    pathHint: InstallManager;
+    /** Why we landed on `manager`. Used purely for human-readable output. */
+    reason: string;
+}
+/**
+ * Detect how the CLI is currently installed by inspecting the absolute path
+ * of this file (__dirname). Each global package manager drops binaries into
+ * a distinctive directory layout:
+ *
+ *   - npm   :  .../lib/node_modules/<pkg>/...   (Unix; nvm/fnm/system/Homebrew)
+ *              .../npm/node_modules/<pkg>/...   (Windows %APPDATA%/npm)
+ *   - yarn  :  ~/.config/yarn/global/node_modules/...     (yarn classic v1, *nix)
+ *              ~/.yarn/global/node_modules/...            (alt yarn classic layout)
+ *              %LOCALAPPDATA%/Yarn/Data/global/node_modules/...   (Windows)
+ *   - pnpm  :  ~/.local/share/pnpm/global/<v>/node_modules/...    (Unix)
+ *              %LOCALAPPDATA%/pnpm/global/<v>/node_modules/...    (Windows)
+ *              also matches PNPM_HOME-rooted layouts
+ *
+ * Returns 'unknown' if no pattern matches (e.g. yalc / npm link / monorepo dev).
+ */
+export declare function detectFromPath(dir?: string): InstallManager;
+/**
+ * Full detection: path inspection + availability fallback.
+ *
+ * If the path tells us 'yarn' or 'pnpm' but that binary is no longer on
+ * PATH (user uninstalled it), we degrade to 'npm' so the upgrade command
+ * still works. The original path hint is preserved in `pathHint` for
+ * diagnostics.
+ *
+ * If `override` is given (from --manager flag), it wins unconditionally —
+ * we still report the underlying path hint for transparency.
+ */
+export declare function detectInstallManager(override?: InstallManager): DetectionResult;
+/**
+ * Build the canonical "install this package globally" command for a given
+ * manager. The version specifier is appended via `pkg@tag`.
+ */
+export declare function buildUpgradeCommand(manager: InstallManager, packageName: string, tag?: string): string;
+/**
+ * Validate a string from the --manager flag. Returns the normalized
+ * InstallManager value, or null if invalid.
+ */
+export declare function parseManagerFlag(input: string | undefined): InstallManager | null;

package/lib/install-manager.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseManagerFlag = exports.buildUpgradeCommand = exports.detectInstallManager = exports.detectFromPath = void 0;
+const child_process_1 = require("child_process");
+/**
+ * Detect how the CLI is currently installed by inspecting the absolute path
+ * of this file (__dirname). Each global package manager drops binaries into
+ * a distinctive directory layout:
+ *
+ *   - npm   :  .../lib/node_modules/<pkg>/...   (Unix; nvm/fnm/system/Homebrew)
+ *              .../npm/node_modules/<pkg>/...   (Windows %APPDATA%/npm)
+ *   - yarn  :  ~/.config/yarn/global/node_modules/...     (yarn classic v1, *nix)
+ *              ~/.yarn/global/node_modules/...            (alt yarn classic layout)
+ *              %LOCALAPPDATA%/Yarn/Data/global/node_modules/...   (Windows)
+ *   - pnpm  :  ~/.local/share/pnpm/global/<v>/node_modules/...    (Unix)
+ *              %LOCALAPPDATA%/pnpm/global/<v>/node_modules/...    (Windows)
+ *              also matches PNPM_HOME-rooted layouts
+ *
+ * Returns 'unknown' if no pattern matches (e.g. yalc / npm link / monorepo dev).
+ */
+function detectFromPath(dir = __dirname) {
+    const normalized = dir.replace(/\\/g, '/');
+    // yarn classic global
+    if (/(?:\/\.config\/yarn\/global|\/\.yarn\/global|\/Yarn\/Data\/global)\//i.test(normalized)) {
+        return 'yarn';
+    }
+    // pnpm global
+    if (/\/pnpm\/global\//.test(normalized)) {
+        return 'pnpm';
+    }
+    // npm global (Unix-like or Windows AppData)
+    if (/\/lib\/node_modules\//.test(normalized) ||
+        /\/npm\/node_modules\//i.test(normalized)) {
+        return 'npm';
+    }
+    return 'unknown';
+}
+exports.detectFromPath = detectFromPath;
+/** Cheap "is X on PATH?" check, returns false on any error/timeout. */
+function isCommandAvailable(cmd) {
+    try {
+        const probe = process.platform === 'win32' ? `where ${cmd}` : `command -v ${cmd}`;
+        (0, child_process_1.execSync)(probe, { stdio: 'pipe', timeout: 2000 });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Full detection: path inspection + availability fallback.
+ *
+ * If the path tells us 'yarn' or 'pnpm' but that binary is no longer on
+ * PATH (user uninstalled it), we degrade to 'npm' so the upgrade command
+ * still works. The original path hint is preserved in `pathHint` for
+ * diagnostics.
+ *
+ * If `override` is given (from --manager flag), it wins unconditionally —
+ * we still report the underlying path hint for transparency.
+ */
+function detectInstallManager(override) {
+    const pathHint = detectFromPath();
+    if (override && override !== 'unknown') {
+        return {
+            manager: override,
+            pathHint,
+            reason: `manager forced via --manager=${override} (path hint: ${pathHint})`,
+        };
+    }
+    if (pathHint === 'unknown') {
+        return {
+            manager: 'npm',
+            pathHint,
+            reason: 'install path did not match any known global package manager layout — defaulting to npm',
+        };
+    }
+    if (pathHint !== 'npm' && !isCommandAvailable(pathHint)) {
+        return {
+            manager: 'npm',
+            pathHint,
+            reason: `install path suggests ${pathHint}, but \`${pathHint}\` is not on PATH — falling back to npm`,
+        };
+    }
+    return {
+        manager: pathHint,
+        pathHint,
+        reason: `detected from install path`,
+    };
+}
+exports.detectInstallManager = detectInstallManager;
+/**
+ * Build the canonical "install this package globally" command for a given
+ * manager. The version specifier is appended via `pkg@tag`.
+ */
+function buildUpgradeCommand(manager, packageName, tag = 'latest') {
+    const target = `${packageName}@${tag}`;
+    switch (manager) {
+        case 'yarn':
+            // yarn classic v1: `yarn global add`. Yarn berry (2+) deprecated this
+            // in favour of `yarn dlx`; users on berry typically still install
+            // global CLIs via npm or pnpm, so this command is the right default
+            // for the "yarn classic" detection path.
+            return `yarn global add ${target}`;
+        case 'pnpm':
+            return `pnpm add -g ${target}`;
+        case 'npm':
+        case 'unknown':
+        default:
+            return `npm install -g ${target}`;
+    }
+}
+exports.buildUpgradeCommand = buildUpgradeCommand;
+/**
+ * Validate a string from the --manager flag. Returns the normalized
+ * InstallManager value, or null if invalid.
+ */
+function parseManagerFlag(input) {
+    if (!input)
+        return null;
+    const v = input.toLowerCase().trim();
+    if (v === 'npm' || v === 'yarn' || v === 'pnpm')
+        return v;
+    return null;
+}
+exports.parseManagerFlag = parseManagerFlag;

package/lib/template-merge/config-loader.d.ts

@@ -0,0 +1,15 @@
+export interface TemplateUpdateConfig {
+    /** Glob → merger name. Insertion order is preserved (use plain object/array, not Map). */
+    mergers?: Record<string, string>;
+    /** Dot-namespaced key → value, e.g. 'json.scripts': 'preserve-instance' */
+    policies?: Record<string, string>;
+}
+/**
+ * Load the templateUpdate section from gadmin-cli.json.
+ * Searches in this order:
+ *   1. <instanceDir>/server/gadmin-cli.json
+ *   2. <instanceDir>/gadmin-cli.json
+ * Returns null if no config file found, no `templateUpdate` key, or on parse error.
+ * On parse error, also console.warn with the error and the file path.
+ */
+export declare function loadTemplateUpdateConfig(instanceDir: string): TemplateUpdateConfig | null;

package/lib/template-merge/config-loader.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTemplateUpdateConfig = void 0;
+const fs = require("fs");
+const path = require("path");
+/**
+ * Load the templateUpdate section from gadmin-cli.json.
+ * Searches in this order:
+ *   1. <instanceDir>/server/gadmin-cli.json
+ *   2. <instanceDir>/gadmin-cli.json
+ * Returns null if no config file found, no `templateUpdate` key, or on parse error.
+ * On parse error, also console.warn with the error and the file path.
+ */
+function loadTemplateUpdateConfig(instanceDir) {
+    const candidates = [
+        path.join(instanceDir, 'server', 'gadmin-cli.json'),
+        path.join(instanceDir, 'gadmin-cli.json'),
+    ];
+    for (const configPath of candidates) {
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const raw = fs.readFileSync(configPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const section = parsed === null || parsed === void 0 ? void 0 : parsed.templateUpdate;
+            if (!section || typeof section !== 'object') {
+                return null;
+            }
+            return section;
+        }
+        catch (err) {
+            console.warn(`Failed to parse templateUpdate config at ${configPath}: ${(err === null || err === void 0 ? void 0 : err.message) || err}`);
+            return null;
+        }
+    }
+    return null;
+}
+exports.loadTemplateUpdateConfig = loadTemplateUpdateConfig;

package/lib/template-merge/env-merger.d.ts

@@ -0,0 +1,5 @@
+import { Merger, MergeContext, MergeResult } from './merger';
+export declare class EnvMerger implements Merger {
+    readonly name = "env";
+    merge(ctx: MergeContext): MergeResult;
+}

package/lib/template-merge/env-merger.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvMerger = void 0;
+const KEY_RE = /^([A-Za-z_][A-Za-z0-9_]*)=/;
+class EnvMerger {
+    constructor() {
+        this.name = 'env';
+    }
+    merge(ctx) {
+        try {
+            const instLines = ctx.instanceContent.split('\n');
+            const instKeys = new Set();
+            for (const line of instLines) {
+                const m = line.match(KEY_RE);
+                if (m)
+                    instKeys.add(m[1]);
+            }
+            const tmplLines = ctx.templateContent.split('\n');
+            const toAdd = [];
+            const addedKeys = [];
+            for (const line of tmplLines) {
+                const trimmed = line.trim();
+                if (trimmed === '' || trimmed.startsWith('#'))
+                    continue;
+                const m = line.match(KEY_RE);
+                if (!m)
+                    continue;
+                const key = m[1];
+                if (instKeys.has(key))
+                    continue;
+                toAdd.push(line);
+                addedKeys.push(key);
+            }
+            if (toAdd.length === 0) {
+                return {
+                    ok: true,
+                    merged: ctx.instanceContent,
+                    notes: ['no changes'],
+                };
+            }
+            let merged = ctx.instanceContent;
+            if (!merged.endsWith('\n'))
+                merged += '\n';
+            merged += '\n# --- added from template ---\n';
+            merged += toAdd.join('\n');
+            if (!merged.endsWith('\n'))
+                merged += '\n';
+            const notes = addedKeys.map((k) => `added ${k}`);
+            return { ok: true, merged, notes };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { ok: false, reason: `env merge error: ${msg}` };
+        }
+    }
+}
+exports.EnvMerger = EnvMerger;

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

@@ -0,0 +1,5 @@
+/**
+ * Match a file path against a glob pattern.
+ * Equivalent to `matchesPattern` in actions/update.action.ts.
+ */
+export declare function globMatch(filePath: string, pattern: string): boolean;

package/lib/template-merge/glob.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globMatch = void 0;
+/**
+ * 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);
+}
+/**
+ * Match a file path against a glob pattern.
+ * Equivalent to `matchesPattern` in actions/update.action.ts.
+ */
+function globMatch(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;
+}
+exports.globMatch = globMatch;

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

@@ -0,0 +1,8 @@
+export * from './merger';
+export * from './registry';
+export * from './config-loader';
+export * from './glob';
+export * from './json-merger';
+export * from './env-merger';
+export * from './prisma-merger';
+export * from './ts-module-merger';

package/lib/template-merge/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./merger"), exports);
+__exportStar(require("./registry"), exports);
+__exportStar(require("./config-loader"), exports);
+__exportStar(require("./glob"), exports);
+__exportStar(require("./json-merger"), exports);
+__exportStar(require("./env-merger"), exports);
+__exportStar(require("./prisma-merger"), exports);
+__exportStar(require("./ts-module-merger"), exports);

package/lib/template-merge/json-merger.d.ts

@@ -0,0 +1,5 @@
+import { Merger, MergeContext, MergeResult } from './merger';
+export declare class JsonMerger implements Merger {
+    readonly name = "json";
+    merge(ctx: MergeContext): MergeResult;
+}