@lenne.tech/cli 1.9.6 → 1.11.0

package/build/commands/fullstack/convert-mode.js

@@ -0,0 +1,368 @@
+"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 });
+const path_1 = require("path");
+const framework_detection_1 = require("../../lib/framework-detection");
+const frontend_framework_detection_1 = require("../../lib/frontend-framework-detection");
+/**
+ * Convert both backend and frontend of a fullstack monorepo between
+ * npm mode and vendor mode in a single command.
+ *
+ * Usage:
+ *   lt fullstack convert-mode --to vendor [--framework-upstream-branch 11.24.3] [--frontend-framework-upstream-branch 1.5.3]
+ *   lt fullstack convert-mode --to npm
+ *   lt fullstack convert-mode --to vendor --skip-frontend
+ *   lt fullstack convert-mode --to vendor --skip-backend
+ *   lt fullstack convert-mode --to vendor --dry-run
+ *
+ * Orchestrates `lt server convert-mode` + `lt frontend convert-mode` with
+ * auto-detection of `projects/api/` and `projects/app/` subdirectories.
+ */
+const ConvertModeCommand = {
+    description: 'Convert fullstack monorepo between npm and vendor modes',
+    hidden: false,
+    name: 'convert-mode',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        const { filesystem, frontendHelper, parameters, print: { colors, error, info, spin, success, warning }, prompt: { confirm }, server, } = toolbox;
+        // Handle --help-json flag
+        if (toolbox.tools.helpJson({
+            description: 'Convert fullstack monorepo (backend + frontend) between npm and vendor modes',
+            name: 'convert-mode',
+            options: [
+                {
+                    description: 'Target mode',
+                    flag: '--to',
+                    required: true,
+                    type: 'string',
+                    values: ['vendor', 'npm'],
+                },
+                {
+                    description: 'Backend upstream branch/tag (only with --to vendor, e.g. "11.24.3")',
+                    flag: '--framework-upstream-branch',
+                    required: false,
+                    type: 'string',
+                },
+                {
+                    description: 'Frontend upstream branch/tag (only with --to vendor, e.g. "1.5.3")',
+                    flag: '--frontend-framework-upstream-branch',
+                    required: false,
+                    type: 'string',
+                },
+                {
+                    description: 'Backend version to install (only with --to npm, default: from VENDOR.md baseline)',
+                    flag: '--framework-version',
+                    required: false,
+                    type: 'string',
+                },
+                {
+                    description: 'Frontend version to install (only with --to npm, default: from VENDOR.md baseline)',
+                    flag: '--frontend-framework-version',
+                    required: false,
+                    type: 'string',
+                },
+                {
+                    default: false,
+                    description: 'Skip backend conversion',
+                    flag: '--skip-backend',
+                    required: false,
+                    type: 'boolean',
+                },
+                {
+                    default: false,
+                    description: 'Skip frontend conversion',
+                    flag: '--skip-frontend',
+                    required: false,
+                    type: 'boolean',
+                },
+                {
+                    default: false,
+                    description: 'Show the resolved plan without making any changes',
+                    flag: '--dry-run',
+                    required: false,
+                    type: 'boolean',
+                },
+                {
+                    default: false,
+                    description: 'Skip confirmation prompt',
+                    flag: '--noConfirm',
+                    required: false,
+                    type: 'boolean',
+                },
+            ],
+        })) {
+            return;
+        }
+        const targetMode = parameters.options.to;
+        if (!targetMode || !['npm', 'vendor'].includes(targetMode)) {
+            error('Missing or invalid --to flag. Use: --to vendor  or  --to npm');
+            return;
+        }
+        const skipBackend = parameters.options['skip-backend'] === true || parameters.options['skip-backend'] === 'true';
+        const skipFrontend = parameters.options['skip-frontend'] === true || parameters.options['skip-frontend'] === 'true';
+        const dryRun = parameters.options['dry-run'] === true || parameters.options['dry-run'] === 'true';
+        const noConfirm = parameters.options.noConfirm === true || parameters.options.noConfirm === 'true';
+        if (skipBackend && skipFrontend) {
+            error('Cannot skip both backend and frontend — nothing would happen.');
+            return;
+        }
+        // Locate the subprojects. Typical monorepo layouts: projects/{api,app} or packages/{api,app}.
+        const cwd = filesystem.cwd();
+        const backendCandidates = [(0, path_1.join)(cwd, 'projects', 'api'), (0, path_1.join)(cwd, 'packages', 'api')];
+        const frontendCandidates = [(0, path_1.join)(cwd, 'projects', 'app'), (0, path_1.join)(cwd, 'packages', 'app')];
+        let backendDir;
+        for (const candidate of backendCandidates) {
+            if (filesystem.exists((0, path_1.join)(candidate, 'package.json'))) {
+                backendDir = candidate;
+                break;
+            }
+        }
+        let frontendDir;
+        for (const candidate of frontendCandidates) {
+            if (filesystem.exists((0, path_1.join)(candidate, 'package.json'))) {
+                frontendDir = candidate;
+                break;
+            }
+        }
+        if (!backendDir && !frontendDir) {
+            error('Could not find any api or app subproject. Expected projects/api, projects/app, packages/api, or packages/app.');
+            return;
+        }
+        // Detect current modes
+        const backendCurrentMode = backendDir ? (0, framework_detection_1.detectFrameworkMode)(backendDir) : null;
+        const frontendCurrentMode = frontendDir ? (0, frontend_framework_detection_1.detectFrontendFrameworkMode)(frontendDir) : null;
+        // Decide what will actually happen
+        const willConvertBackend = !skipBackend && backendDir && backendCurrentMode && backendCurrentMode !== targetMode;
+        const willConvertFrontend = !skipFrontend && frontendDir && frontendCurrentMode && frontendCurrentMode !== targetMode;
+        // ── Plan output ─────────────────────────────────────────────────────
+        info('');
+        info(colors.bold('Fullstack convert-mode plan:'));
+        info(colors.dim('─'.repeat(60)));
+        if (backendDir) {
+            const backendLabel = skipBackend
+                ? colors.yellow('(skipped via --skip-backend)')
+                : backendCurrentMode === targetMode
+                    ? colors.dim(`(already in ${targetMode} mode — nothing to do)`)
+                    : colors.green(`${backendCurrentMode} → ${targetMode}`);
+            info(`  Backend:  ${backendDir}`);
+            info(`            ${backendLabel}`);
+        }
+        else {
+            info(`  Backend:  ${colors.dim('(not found)')}`);
+        }
+        if (frontendDir) {
+            const frontendLabel = skipFrontend
+                ? colors.yellow('(skipped via --skip-frontend)')
+                : frontendCurrentMode === targetMode
+                    ? colors.dim(`(already in ${targetMode} mode — nothing to do)`)
+                    : colors.green(`${frontendCurrentMode} → ${targetMode}`);
+            info(`  Frontend: ${frontendDir}`);
+            info(`            ${frontendLabel}`);
+        }
+        else {
+            info(`  Frontend: ${colors.dim('(not found)')}`);
+        }
+        info(colors.dim('─'.repeat(60)));
+        if (!willConvertBackend && !willConvertFrontend) {
+            info('');
+            warning('Nothing to do: both subprojects are already in the target mode (or skipped).');
+            return;
+        }
+        if (dryRun) {
+            info('');
+            info(colors.bold('Would execute:'));
+            if (willConvertBackend) {
+                if (targetMode === 'vendor') {
+                    const branch = parameters.options['framework-upstream-branch'] || '(auto-detect from package.json)';
+                    info(`  [Backend]  lt server convert-mode --to vendor --upstream-branch ${branch} --noConfirm`);
+                }
+                else {
+                    const version = parameters.options['framework-version'] || '(from VENDOR.md baseline)';
+                    info(`  [Backend]  lt server convert-mode --to npm --version ${version} --noConfirm`);
+                }
+            }
+            if (willConvertFrontend) {
+                if (targetMode === 'vendor') {
+                    const branch = parameters.options['frontend-framework-upstream-branch'] || '(auto-detect from package.json)';
+                    info(`  [Frontend] lt frontend convert-mode --to vendor --upstream-branch ${branch} --noConfirm`);
+                }
+                else {
+                    const version = parameters.options['frontend-framework-version'] || '(from VENDOR.md baseline)';
+                    info(`  [Frontend] lt frontend convert-mode --to npm --version ${version} --noConfirm`);
+                }
+            }
+            info('');
+            return `fullstack convert-mode dry-run (target: ${targetMode})`;
+        }
+        // ── Confirmation ────────────────────────────────────────────────────
+        if (!noConfirm) {
+            info('');
+            const proceed = yield confirm(`Convert ${[willConvertBackend && 'backend', willConvertFrontend && 'frontend'].filter(Boolean).join(' + ')} to ${targetMode} mode?`);
+            if (!proceed) {
+                info('Aborted.');
+                return;
+            }
+        }
+        // ── Execute ─────────────────────────────────────────────────────────
+        const results = [];
+        // 1. Backend conversion
+        if (willConvertBackend && backendDir) {
+            info('');
+            info(colors.bold(`[1/2] Backend: ${backendCurrentMode} → ${targetMode}`));
+            if (targetMode === 'vendor') {
+                let branch = parameters.options['framework-upstream-branch'];
+                // Auto-detect version from package.json if not provided
+                if (!branch) {
+                    try {
+                        const pkg = filesystem.read(`${backendDir}/package.json`, 'json');
+                        const deps = Object.assign(Object.assign({}, ((pkg === null || pkg === void 0 ? void 0 : pkg.dependencies) || {})), ((pkg === null || pkg === void 0 ? void 0 : pkg.devDependencies) || {}));
+                        const version = deps['@lenne.tech/nest-server'];
+                        if (version) {
+                            branch = version.replace(/^[^0-9]*/, '');
+                            info(`  Auto-detected @lenne.tech/nest-server version: ${branch}`);
+                        }
+                    }
+                    catch (_a) {
+                        // Will use HEAD
+                    }
+                }
+                const spinner = spin('  Converting backend to vendor mode...');
+                try {
+                    yield server.convertToVendorMode({
+                        dest: backendDir,
+                        upstreamBranch: branch,
+                    });
+                    spinner.succeed('  Backend converted to vendor mode');
+                    results.push({ part: 'backend', status: 'ok' });
+                }
+                catch (err) {
+                    spinner.fail(`  Backend conversion failed: ${err.message}`);
+                    results.push({ message: err.message, part: 'backend', status: 'failed' });
+                }
+            }
+            else {
+                const targetVersion = parameters.options['framework-version'];
+                const spinner = spin('  Converting backend to npm mode...');
+                try {
+                    yield server.convertToNpmMode({
+                        dest: backendDir,
+                        targetVersion,
+                    });
+                    spinner.succeed('  Backend converted to npm mode');
+                    results.push({ part: 'backend', status: 'ok' });
+                }
+                catch (err) {
+                    spinner.fail(`  Backend conversion failed: ${err.message}`);
+                    results.push({ message: err.message, part: 'backend', status: 'failed' });
+                }
+            }
+        }
+        else if (backendDir) {
+            const reason = skipBackend ? 'skipped via flag' : `already in ${targetMode} mode`;
+            info('');
+            info(colors.dim(`[1/2] Backend: ${reason}`));
+            results.push({ message: reason, part: 'backend', status: 'skipped' });
+        }
+        // 2. Frontend conversion
+        if (willConvertFrontend && frontendDir) {
+            info('');
+            info(colors.bold(`[2/2] Frontend: ${frontendCurrentMode} → ${targetMode}`));
+            if (targetMode === 'vendor') {
+                let branch = parameters.options['frontend-framework-upstream-branch'];
+                if (!branch) {
+                    try {
+                        const pkg = filesystem.read(`${frontendDir}/package.json`, 'json');
+                        const deps = Object.assign(Object.assign({}, ((pkg === null || pkg === void 0 ? void 0 : pkg.dependencies) || {})), ((pkg === null || pkg === void 0 ? void 0 : pkg.devDependencies) || {}));
+                        const version = deps['@lenne.tech/nuxt-extensions'];
+                        if (version) {
+                            branch = version.replace(/^[^0-9]*/, '');
+                            info(`  Auto-detected @lenne.tech/nuxt-extensions version: ${branch}`);
+                        }
+                    }
+                    catch (_b) {
+                        // Will use HEAD
+                    }
+                }
+                const spinner = spin('  Converting frontend to vendor mode...');
+                try {
+                    yield frontendHelper.convertAppToVendorMode({
+                        dest: frontendDir,
+                        upstreamBranch: branch,
+                    });
+                    spinner.succeed('  Frontend converted to vendor mode');
+                    results.push({ part: 'frontend', status: 'ok' });
+                }
+                catch (err) {
+                    spinner.fail(`  Frontend conversion failed: ${err.message}`);
+                    results.push({ message: err.message, part: 'frontend', status: 'failed' });
+                }
+            }
+            else {
+                const targetVersion = parameters.options['frontend-framework-version'];
+                const spinner = spin('  Converting frontend to npm mode...');
+                try {
+                    yield frontendHelper.convertAppToNpmMode({
+                        dest: frontendDir,
+                        targetVersion,
+                    });
+                    spinner.succeed('  Frontend converted to npm mode');
+                    results.push({ part: 'frontend', status: 'ok' });
+                }
+                catch (err) {
+                    spinner.fail(`  Frontend conversion failed: ${err.message}`);
+                    results.push({ message: err.message, part: 'frontend', status: 'failed' });
+                }
+            }
+        }
+        else if (frontendDir) {
+            const reason = skipFrontend ? 'skipped via flag' : `already in ${targetMode} mode`;
+            info('');
+            info(colors.dim(`[2/2] Frontend: ${reason}`));
+            results.push({ message: reason, part: 'frontend', status: 'skipped' });
+        }
+        // ── Summary ─────────────────────────────────────────────────────────
+        info('');
+        info(colors.bold('Summary:'));
+        info(colors.dim('─'.repeat(60)));
+        for (const result of results) {
+            const icon = result.status === 'ok' ? colors.green('✓') : result.status === 'skipped' ? colors.dim('–') : colors.red('✗');
+            const label = result.part.padEnd(10);
+            info(`  ${icon}  ${label} ${result.message || result.status}`);
+        }
+        info(colors.dim('─'.repeat(60)));
+        const failed = results.filter((r) => r.status === 'failed');
+        if (failed.length > 0) {
+            info('');
+            error(`${failed.length} conversion(s) failed. See messages above.`);
+            if (!parameters.options.fromGluegunMenu) {
+                process.exit(1);
+            }
+            return `fullstack convert-mode failed (${failed.length} error(s))`;
+        }
+        info('');
+        success('All conversions completed successfully.');
+        info('');
+        info(colors.bold('Next steps:'));
+        info('  1. Run: pnpm install  (from monorepo root)');
+        if (backendDir && results.find((r) => r.part === 'backend' && r.status === 'ok')) {
+            info('  2. Verify backend:   cd projects/api && pnpm exec tsc --noEmit && pnpm test');
+        }
+        if (frontendDir && results.find((r) => r.part === 'frontend' && r.status === 'ok')) {
+            info('  3. Verify frontend:  cd projects/app && pnpm run build');
+        }
+        info('  4. Commit the changes');
+        info('');
+        if (!parameters.options.fromGluegunMenu) {
+            process.exit();
+        }
+        return `fullstack convert-mode completed (target: ${targetMode})`;
+    }),
+};
+exports.default = ConvertModeCommand;

package/build/commands/fullstack/init.js

@@ -18,7 +18,7 @@ const NewCommand = {
     hidden: false,
     name: 'init',
     run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
         // Retrieve the tools we need
         const { config, filesystem, frontendHelper, git, helper, parameters, patching, print: { error, info, spin, success }, prompt: { ask, confirm }, server, strings: { kebabCase }, system, } = toolbox;
         // Start timer
@@ -26,7 +26,7 @@ const NewCommand = {
         // Info
         info('Create a new fullstack workspace');
         // Hint for non-interactive callers (e.g. Claude Code)
-        toolbox.tools.nonInteractiveHint('lt fullstack init --name <name> --frontend <nuxt|angular> --api-mode <Rest|GraphQL|Both> --noConfirm');
+        toolbox.tools.nonInteractiveHint('lt fullstack init --name <name> --frontend <nuxt|angular> --api-mode <Rest|GraphQL|Both> --framework-mode <npm|vendor> [--framework-upstream-branch <ref>] [--dry-run] --noConfirm');
         // Check git
         if (!(yield git.gitInstalled())) {
             return;
@@ -43,12 +43,17 @@ const NewCommand = {
         const configFrontendCopy = (_r = (_q = ltConfig === null || ltConfig === void 0 ? void 0 : ltConfig.commands) === null || _q === void 0 ? void 0 : _q.fullstack) === null || _r === void 0 ? void 0 : _r.frontendCopy;
         const configApiLink = (_t = (_s = ltConfig === null || ltConfig === void 0 ? void 0 : ltConfig.commands) === null || _s === void 0 ? void 0 : _s.fullstack) === null || _t === void 0 ? void 0 : _t.apiLink;
         const configFrontendLink = (_v = (_u = ltConfig === null || ltConfig === void 0 ? void 0 : ltConfig.commands) === null || _u === void 0 ? void 0 : _u.fullstack) === null || _v === void 0 ? void 0 : _v.frontendLink;
+        const configFrameworkMode = (_x = (_w = ltConfig === null || ltConfig === void 0 ? void 0 : ltConfig.commands) === null || _w === void 0 ? void 0 : _w.fullstack) === null || _x === void 0 ? void 0 : _x.frameworkMode;
         // Parse CLI arguments
-        const { 'api-branch': cliApiBranch, 'api-copy': cliApiCopy, 'api-link': cliApiLink, 'api-mode': cliApiMode, frontend: cliFrontend, 'frontend-branch': cliFrontendBranch, 'frontend-copy': cliFrontendCopy, 'frontend-link': cliFrontendLink, git: cliGit, 'git-link': cliGitLink, name: cliName, } = parameters.options;
+        const { 'api-branch': cliApiBranch, 'api-copy': cliApiCopy, 'api-link': cliApiLink, 'api-mode': cliApiMode, 'dry-run': cliDryRun, 'framework-mode': cliFrameworkMode, 'framework-upstream-branch': cliFrameworkUpstreamBranch, frontend: cliFrontend, 'frontend-branch': cliFrontendBranch, 'frontend-copy': cliFrontendCopy, 'frontend-framework-mode': cliFrontendFrameworkMode, 'frontend-link': cliFrontendLink, git: cliGit, 'git-link': cliGitLink, name: cliName, } = parameters.options;
+        const dryRun = cliDryRun === true || cliDryRun === 'true';
+        const frameworkUpstreamBranch = typeof cliFrameworkUpstreamBranch === 'string' && cliFrameworkUpstreamBranch.length > 0
+            ? cliFrameworkUpstreamBranch
+            : undefined;
         // Determine noConfirm with priority: CLI > command > parent > global > default
         const noConfirm = config.getNoConfirm({
             cliValue: parameters.options.noConfirm,
-            commandConfig: (_w = ltConfig === null || ltConfig === void 0 ? void 0 : ltConfig.commands) === null || _w === void 0 ? void 0 : _w.fullstack,
+            commandConfig: (_y = ltConfig === null || ltConfig === void 0 ? void 0 : ltConfig.commands) === null || _y === void 0 ? void 0 : _y.fullstack,
             config: ltConfig,
         });
         // Get name of the workspace
@@ -132,6 +137,71 @@ const NewCommand = {
             });
             apiMode = apiModeChoice.apiMode.split(' - ')[0];
         }
+        // Determine framework-consumption mode (npm vs vendored)
+        //
+        //   npm    — classic: @lenne.tech/nest-server is an npm dependency. Framework
+        //            source lives in node_modules/@lenne.tech/nest-server. Backend is
+        //            cloned from nest-server-starter. Updates via
+        //            `/lt-dev:backend:update-nest-server`.
+        //
+        //   vendor — pilot: the framework's core/ directory is copied directly into
+        //            projects/api/src/core/ as first-class project code. No npm
+        //            dependency. Backend is cloned from the nest-server framework repo
+        //            itself and stripped of framework-internal content. Updates via
+        //            `/lt-dev:backend:update-nest-server-core`; local patches are logged
+        //            in src/core/VENDOR.md.
+        //
+        // Default is still 'npm' until the vendoring pilot is fully evaluated.
+        let frameworkMode;
+        if (cliFrameworkMode === 'npm' || cliFrameworkMode === 'vendor') {
+            frameworkMode = cliFrameworkMode;
+        }
+        else if (cliFrameworkMode) {
+            error(`Invalid --framework-mode value "${cliFrameworkMode}". Use "npm" or "vendor".`);
+            return;
+        }
+        else if (configFrameworkMode === 'npm' || configFrameworkMode === 'vendor') {
+            frameworkMode = configFrameworkMode;
+            info(`Using framework mode from lt.config: ${frameworkMode}`);
+        }
+        else if (noConfirm) {
+            frameworkMode = 'npm';
+            info('Using default framework mode: npm (noConfirm mode)');
+        }
+        else {
+            const frameworkModeChoice = yield ask({
+                choices: [
+                    'npm    - @lenne.tech/nest-server as npm dependency (classic, stable)',
+                    'vendor - framework core vendored into projects/api/src/core/ (pilot, allows local patches)',
+                ],
+                initial: 0,
+                message: 'Framework consumption mode?',
+                name: 'frameworkMode',
+                type: 'select',
+            });
+            frameworkMode = frameworkModeChoice.frameworkMode.startsWith('vendor') ? 'vendor' : 'npm';
+        }
+        // ── Frontend framework mode ─────────────────────────────────────────
+        const configFrontendFrameworkMode = (_0 = (_z = ltConfig === null || ltConfig === void 0 ? void 0 : ltConfig.commands) === null || _z === void 0 ? void 0 : _z.fullstack) === null || _0 === void 0 ? void 0 : _0.frontendFrameworkMode;
+        let frontendFrameworkMode;
+        if (cliFrontendFrameworkMode === 'npm' || cliFrontendFrameworkMode === 'vendor') {
+            frontendFrameworkMode = cliFrontendFrameworkMode;
+        }
+        else if (cliFrontendFrameworkMode) {
+            error(`Invalid --frontend-framework-mode value "${cliFrontendFrameworkMode}". Use "npm" or "vendor".`);
+            return;
+        }
+        else if (configFrontendFrameworkMode === 'npm' || configFrontendFrameworkMode === 'vendor') {
+            frontendFrameworkMode = configFrontendFrameworkMode;
+            info(`Using frontend framework mode from lt.config: ${frontendFrameworkMode}`);
+        }
+        else if (noConfirm) {
+            frontendFrameworkMode = 'npm';
+        }
+        else {
+            // Default to npm without asking (unless user sets it explicitly)
+            frontendFrameworkMode = 'npm';
+        }
         // Determine remote push settings with priority: CLI > config > interactive
         // Git is always initialized; the question is whether to push to a remote
         let pushToRemote = false;
@@ -190,6 +260,59 @@ const NewCommand = {
         const apiLink = cliApiLink || configApiLink;
         const frontendCopy = cliFrontendCopy || configFrontendCopy;
         const frontendLink = cliFrontendLink || configFrontendLink;
+        // Dry-run mode: print the resolved plan and exit without any disk
+        // changes. Useful for CI previews, for Claude Code confirmation
+        // steps, and for debugging the mode-detection logic without
+        // committing to a multi-minute init flow.
+        if (dryRun) {
+            info('');
+            info('Dry-run plan:');
+            info(`  name:                       ${name}`);
+            info(`  projectDir:                 ${projectDir}`);
+            info(`  frontend:                   ${frontend}`);
+            info(`  apiMode:                    ${apiMode}`);
+            info(`  frameworkMode:              ${frameworkMode}`);
+            info(`  frontendFrameworkMode:      ${frontendFrameworkMode}`);
+            if (frameworkUpstreamBranch) {
+                info(`  frameworkUpstreamBranch:    ${frameworkUpstreamBranch}`);
+            }
+            info(`  apiBranch:                  ${apiBranch || '(default)'}`);
+            info(`  frontendBranch:             ${frontendBranch || '(default)'}`);
+            info(`  apiCopy:                    ${apiCopy || '(none)'}`);
+            info(`  apiLink:                    ${apiLink || '(none)'}`);
+            info(`  frontendCopy:               ${frontendCopy || '(none)'}`);
+            info(`  frontendLink:               ${frontendLink || '(none)'}`);
+            info(`  pushToRemote:               ${pushToRemote}`);
+            if (pushToRemote) {
+                info(`  gitLink:                    ${gitLink || '(unset — would abort at run-time)'}`);
+            }
+            info('');
+            info('Would execute:');
+            info(`  1. git clone lt-monorepo → ${projectDir}/`);
+            info(`  2. setup frontend (${frontend}) → ${projectDir}/projects/app`);
+            if (frameworkMode === 'vendor') {
+                info(`  3. clone nest-server-starter → ${projectDir}/projects/api`);
+                info(`  4. clone @lenne.tech/nest-server${frameworkUpstreamBranch ? ` (branch/tag: ${frameworkUpstreamBranch})` : ''} → /tmp`);
+                info(`  5. vendor core/ + flatten-fix + codemod consumer imports`);
+                info(`  6. merge upstream deps (dynamic, no hard-coded list)`);
+                info(`  7. run processApiMode(${apiMode})`);
+                if (apiMode === 'Rest') {
+                    info(`  8. restore vendored core essentials (graphql-*)`);
+                }
+            }
+            else {
+                info(`  3. clone nest-server-starter → ${projectDir}/projects/api`);
+                info(`  4. run processApiMode(${apiMode})`);
+            }
+            if (frontendFrameworkMode === 'vendor') {
+                info(`  M1. clone @lenne.tech/nuxt-extensions → /tmp`);
+                info(`  M2. vendor app/core/ (module.ts + runtime/) + codemod consumer imports`);
+                info(`  M3. rewrite nuxt.config.ts module entry`);
+            }
+            info('  N. pnpm install + initial git commit');
+            info('');
+            return `fullstack init dry-run (${frameworkMode} / ${apiMode})`;
+        }
         const workspaceSpinner = spin(`Create fullstack workspace with ${frontend} in ${projectDir} with ${name} app`);
         // Clone monorepo
         try {
@@ -217,6 +340,7 @@ const NewCommand = {
                 .replace(/\{\{PROJECT_NAME\}\}/g, () => name)
                 .replace(/\{\{PROJECT_DIR\}\}/g, () => projectDir)
                 .replace(/\{\{API_MODE\}\}/g, () => apiMode)
+                .replace(/\{\{FRAMEWORK_MODE\}\}/g, () => frameworkMode)
                 .replace(/\{\{FRONTEND_FRAMEWORK\}\}/g, () => frontendName));
         }
         // Always initialize git
@@ -267,6 +391,21 @@ const NewCommand = {
         if (frontendResult.method !== 'link') {
             frontendHelper.patchFrontendEnv(frontendDest, projectDir);
         }
+        // ── Frontend vendoring (if requested) ───────────────────────────────
+        if (isNuxt && frontendFrameworkMode === 'vendor' && frontendResult.method !== 'link') {
+            const vendorSpinner = spin('Converting frontend to vendor mode...');
+            try {
+                yield frontendHelper.convertAppCloneToVendored({
+                    dest: frontendDest,
+                    projectName: name,
+                });
+                vendorSpinner.succeed('Frontend converted to vendor mode (app/core/)');
+            }
+            catch (err) {
+                vendorSpinner.fail(`Frontend vendor conversion failed: ${err.message}`);
+                toolbox.print.warning('Continuing with npm mode for frontend.');
+            }
+        }
         // Remove gitkeep file
         filesystem.remove(`${projectDir}/projects/.gitkeep`);
         // Integrate files
@@ -280,6 +419,8 @@ const NewCommand = {
                 apiMode,
                 branch: apiBranch,
                 copyPath: apiCopy,
+                frameworkMode,
+                frameworkUpstreamBranch,
                 linkPath: apiLink,
                 name,
                 projectDir,
@@ -289,6 +430,10 @@ const NewCommand = {
                 return;
             }
             // Create lt.config.json for API
+            // Note: frameworkMode is persisted under meta so that subsequent `lt
+            // server module` / `addProp` / `permissions` calls can detect the mode
+            // without re-probing src/core/VENDOR.md each time (the VENDOR.md check
+            // still works; this is just an explicit marker).
             const apiConfigPath = filesystem.path(apiDest, 'lt.config.json');
             filesystem.write(apiConfigPath, {
                 commands: {
@@ -300,6 +445,7 @@ const NewCommand = {
                 },
                 meta: {
                     apiMode,
+                    frameworkMode,
                     version: '1.0.0',
                 },
             }, { jsonIndent: 2 });