@lenne.tech/cli 1.10.0 → 1.11.1

package/README.md

@@ -38,9 +38,11 @@ $ lt
 
 ## Documentation
 
-- [Command Reference](docs/commands.md) - Complete list of all commands with options
-- [Configuration Guide](docs/lt.config.md) - Configuration file documentation
-- [Plugin Guide](docs/plugins.md) - How to create plugins
+- **[LT-ECOSYSTEM-GUIDE](docs/LT-ECOSYSTEM-GUIDE.md)** — Complete reference for `lt` CLI **and** the `lt-dev` Claude-Code Plugin (architecture, functions, vendor-mode workflows, agents, skills)
+- **[VENDOR-MODE-WORKFLOW](docs/VENDOR-MODE-WORKFLOW.md)** — Step-by-step guide for npm → vendor conversion, updates, and rollback
+- [Command Reference](docs/commands.md) — Complete list of all commands with options
+- [Configuration Guide](docs/lt.config.md) — Configuration file documentation
+- [Plugin Guide](docs/plugins.md) — How to create plugins
 
 ## Quick Start
 

package/build/commands/config/validate.js

@@ -56,9 +56,11 @@ const KNOWN_KEYS = {
             apiCopy: 'string',
             apiLink: 'string',
             apiMode: ['Rest', 'GraphQL', 'Both'],
+            frameworkMode: ['npm', 'vendor'],
             frontend: ['angular', 'nuxt'],
             frontendBranch: 'string',
             frontendCopy: 'string',
+            frontendFrameworkMode: ['npm', 'vendor'],
             frontendLink: 'string',
             git: 'boolean',
             gitLink: 'string',

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

@@ -0,0 +1,198 @@
+"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 frontend_framework_detection_1 = require("../../lib/frontend-framework-detection");
+/**
+ * Convert an existing frontend project between npm mode and vendor mode.
+ *
+ * Usage:
+ *   lt frontend convert-mode --to vendor [--upstream-branch 1.5.3]
+ *   lt frontend convert-mode --to npm [--version 1.5.3]
+ */
+const ConvertModeCommand = {
+    description: 'Convert app framework mode',
+    hidden: false,
+    name: 'convert-mode',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        const { filesystem, frontendHelper, parameters, print: { error, info, spin, success, warning }, prompt: { confirm }, } = toolbox;
+        // Handle --help-json flag
+        if (toolbox.tools.helpJson({
+            description: 'Convert frontend project between npm and vendor framework modes',
+            name: 'convert-mode',
+            options: [
+                {
+                    description: 'Target mode',
+                    flag: '--to',
+                    required: true,
+                    type: 'string',
+                    values: ['vendor', 'npm'],
+                },
+                {
+                    description: 'Upstream branch/tag to vendor from (only with --to vendor)',
+                    flag: '--upstream-branch',
+                    required: false,
+                    type: 'string',
+                },
+                {
+                    description: 'nuxt-extensions version to install (only with --to npm, default: from VENDOR.md baseline)',
+                    flag: '--version',
+                    required: false,
+                    type: 'string',
+                },
+                {
+                    default: false,
+                    description: 'Skip confirmation prompt',
+                    flag: '--noConfirm',
+                    required: false,
+                    type: 'boolean',
+                },
+                {
+                    default: false,
+                    description: 'Show the resolved plan without making any changes',
+                    flag: '--dry-run',
+                    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;
+        }
+        // Find the frontend project root
+        const cwd = filesystem.cwd();
+        const appDir = (0, frontend_framework_detection_1.findAppDir)(cwd);
+        if (!appDir) {
+            error('Could not find a nuxt.config.ts in the current directory or any parent. Are you inside a Nuxt project?');
+            return;
+        }
+        // Detect current mode
+        const currentMode = (0, frontend_framework_detection_1.detectFrontendFrameworkMode)(appDir);
+        info(`Detected current mode: ${currentMode}`);
+        if (currentMode === targetMode) {
+            warning(`Project is already in ${targetMode} mode. Nothing to do.`);
+            return;
+        }
+        // Dry-run: print the resolved plan and exit without any disk changes.
+        const dryRun = parameters.options['dry-run'] === true || parameters.options['dry-run'] === 'true';
+        if (dryRun) {
+            info('');
+            info('Dry-run plan:');
+            info(`  appDir:       ${appDir}`);
+            info(`  currentMode:  ${currentMode}`);
+            info(`  targetMode:   ${targetMode}`);
+            if (targetMode === 'vendor') {
+                const upstreamBranch = parameters.options['upstream-branch'];
+                info(`  upstreamBranch: ${upstreamBranch || '(auto-detect from package.json)'}`);
+                info('');
+                info('Would execute:');
+                info('  1. Clone @lenne.tech/nuxt-extensions → /tmp/lt-vendor-nuxt-ext-*');
+                info('  2. Copy src/module.ts + src/runtime/ → app/core/');
+                info('  3. Rewrite nuxt.config.ts: @lenne.tech/nuxt-extensions → ./app/core/module');
+                info('  4. Codemod consumer imports (app/**/*.{ts,vue}, tests/**/*.ts)');
+                info('  5. Remove @lenne.tech/nuxt-extensions from package.json');
+                info('  6. Add check:vendor-freshness script');
+                info('  7. Create app/core/VENDOR.md with baseline metadata');
+                info('  8. Prepend vendor-mode notice to CLAUDE.md');
+            }
+            else {
+                const targetVersion = parameters.options.version;
+                info(`  targetVersion: ${targetVersion || '(from VENDOR.md baseline)'}`);
+                info('');
+                info('Would execute:');
+                info('  1. Read baseline version from app/core/VENDOR.md');
+                info('  2. Warn if local patches exist in VENDOR.md');
+                info('  3. Rewrite consumer imports: relative → @lenne.tech/nuxt-extensions');
+                info('  4. Delete app/core/');
+                info('  5. Restore @lenne.tech/nuxt-extensions in package.json');
+                info('  6. Rewrite nuxt.config.ts: ./app/core/module → @lenne.tech/nuxt-extensions');
+                info('  7. Remove vendor scripts and CLAUDE.md marker');
+            }
+            info('');
+            return `frontend convert-mode dry-run (${currentMode} → ${targetMode})`;
+        }
+        // Confirm
+        const noConfirm = parameters.options.noConfirm;
+        if (!noConfirm) {
+            const proceed = yield confirm(`Convert project from ${currentMode} mode to ${targetMode} mode?\n` +
+                `  Project: ${appDir}\n` +
+                `  This will modify nuxt.config.ts, package.json, imports, and CLAUDE.md.`);
+            if (!proceed) {
+                info('Aborted.');
+                return;
+            }
+        }
+        // Execute conversion
+        if (targetMode === 'vendor') {
+            // npm → vendor
+            const upstreamBranch = parameters.options['upstream-branch'];
+            // Auto-detect version from current @lenne.tech/nuxt-extensions dep
+            let branch = upstreamBranch;
+            if (!branch) {
+                try {
+                    const pkg = filesystem.read(`${appDir}/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) {
+                        // Strip semver range chars (^, ~, >=, etc.) to get the bare version
+                        branch = version.replace(/^[^0-9]*/, '');
+                        info(`Auto-detected @lenne.tech/nuxt-extensions version: ${branch}`);
+                    }
+                }
+                catch (_a) {
+                    // Will use HEAD
+                }
+            }
+            const spinner = spin('Converting to vendor mode...');
+            try {
+                yield frontendHelper.convertAppToVendorMode({
+                    dest: appDir,
+                    upstreamBranch: branch,
+                });
+                spinner.succeed('Converted to vendor mode successfully.');
+                success('\nNext steps:');
+                info('  1. Run: pnpm install');
+                info('  2. Run: pnpm run build (or nuxt build)');
+                info('  3. Commit the changes');
+            }
+            catch (err) {
+                spinner.fail(`Conversion failed: ${err.message}`);
+            }
+        }
+        else {
+            // vendor → npm
+            const targetVersion = parameters.options.version;
+            const spinner = spin('Converting to npm mode...');
+            try {
+                yield frontendHelper.convertAppToNpmMode({
+                    dest: appDir,
+                    targetVersion,
+                });
+                spinner.succeed('Converted to npm mode successfully.');
+                success('\nNext steps:');
+                info('  1. Run: pnpm install');
+                info('  2. Run: pnpm run build (or nuxt build)');
+                info('  3. Commit the changes');
+            }
+            catch (err) {
+                spinner.fail(`Conversion failed: ${err.message}`);
+            }
+        }
+        if (!parameters.options.fromGluegunMenu) {
+            process.exit();
+        }
+        return `converted frontend to ${targetMode} mode`;
+    }),
+};
+exports.default = ConvertModeCommand;

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;