@lenne.tech/cli 1.6.10 → 1.8.0

package/build/commands/tools/install-scripts.js

@@ -0,0 +1,105 @@
+"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 fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Install all bash helper scripts to /usr/local/bin
+ */
+const NewCommand = {
+    alias: ['is'],
+    description: 'Install bash helper scripts',
+    hidden: false,
+    name: 'install-scripts',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        const { helper, print: { error, info, spin, success }, system: { run, startTimer }, } = toolbox;
+        // Start timer
+        const timer = startTimer();
+        const targetDir = '/usr/local/bin';
+        // Check if target directory exists
+        if (!(0, fs_1.existsSync)(targetDir)) {
+            error(`Target directory not found: ${targetDir}`);
+            info('You may need to create it first: sudo mkdir -p /usr/local/bin');
+            return 'install-scripts: target not found';
+        }
+        // Collect scripts from all subdirectories
+        const baseDir = (0, path_1.join)(__dirname, '..', '..', 'templates', 'bash-scripts');
+        const scriptDirs = ['tools'];
+        const descriptions = {
+            pcf: 'pnpm run check:fix (fallback: check)',
+        };
+        const installed = [];
+        const failed = [];
+        for (const dir of scriptDirs) {
+            const sourceDir = (0, path_1.join)(baseDir, dir);
+            if (!(0, fs_1.existsSync)(sourceDir)) {
+                continue;
+            }
+            const scripts = (0, fs_1.readdirSync)(sourceDir).filter(file => !file.startsWith('.'));
+            for (const script of scripts) {
+                const sourcePath = (0, path_1.join)(sourceDir, script);
+                const targetPath = (0, path_1.join)(targetDir, script);
+                const spinner = spin(`Installing ${script}`);
+                try {
+                    (0, fs_1.copyFileSync)(sourcePath, targetPath);
+                    (0, fs_1.chmodSync)(targetPath, 0o755);
+                    spinner.succeed(`Installed ${script}`);
+                    installed.push(script);
+                }
+                catch (err) {
+                    spinner.fail(`Failed to install ${script}`);
+                    if (err.code === 'EACCES') {
+                        error(`  Permission denied. Try running with sudo: sudo lt tools install-scripts`);
+                    }
+                    else {
+                        error(`  ${err.message}`);
+                    }
+                    failed.push(script);
+                }
+            }
+        }
+        // Install git scripts
+        info('');
+        const gitSpinner = spin('Installing git scripts...');
+        try {
+            yield run('lt git install-scripts');
+            gitSpinner.succeed('Git scripts installed');
+        }
+        catch (err) {
+            gitSpinner.fail('Failed to install git scripts');
+            error(`  ${err.message}`);
+            error('  Try running with sudo: sudo lt git install-scripts');
+        }
+        // Summary
+        info('');
+        if (failed.length === 0) {
+            success(`All scripts installed in ${helper.msToMinutesAndSeconds(timer())}m.`);
+        }
+        else {
+            error(`${installed.length} installed, ${failed.length} failed.`);
+        }
+        if (installed.length > 0) {
+            info('');
+            info('Installed scripts:');
+            for (const script of installed) {
+                const desc = descriptions[script] || 'run from anywhere in terminal';
+                info(`  ${script} - ${desc}`);
+            }
+        }
+        info('');
+        if (!toolbox.parameters.options.fromGluegunMenu) {
+            process.exit();
+        }
+        return failed.length > 0 ? `scripts installed with ${failed.length} failures` : 'scripts installed';
+    }),
+};
+exports.default = NewCommand;
+//# sourceMappingURL=data:application/json;base64,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

package/build/commands/typescript/create.js

@@ -150,14 +150,14 @@ const NewCommand = {
             yield npm.update({ cwd: (0, path_1.join)(filesystem.cwd(), projectDir), install: true, showError: true });
         }
         else {
-            // Init npm
-            const installSpinner = spin('Install npm packages');
+            // Install packages
+            const installSpinner = spin('Install packages');
             try {
-                yield system.run(`cd ${projectDir} && npm i`);
-                installSpinner.succeed('NPM packages installed');
+                yield system.run(`cd ${projectDir} && ${toolbox.pm.install(toolbox.pm.detect(projectDir))}`);
+                installSpinner.succeed('Packages installed');
             }
             catch (err) {
-                installSpinner.fail(`Failed to install npm packages: ${err.message}`);
+                installSpinner.fail(`Failed to install packages: ${err.message}`);
                 return;
             }
         }
@@ -184,4 +184,4 @@ const NewCommand = {
     }),
 };
 exports.default = NewCommand;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL3R5cGVzY3JpcHQvY3JlYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0FBQ0EsK0JBQTRCO0FBSTVCOztHQUVHO0FBQ0gsTUFBTSxVQUFVLEdBQW1CO0lBQ2pDLEtBQUssRUFBRSxDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsR0FBRyxDQUFDO0lBQ3hCLFdBQVcsRUFBRSwyQkFBMkI7SUFDeEMsTUFBTSxFQUFFLEtBQUs7SUFDYixJQUFJLEVBQUUsUUFBUTtJQUNkLEdBQUcsRUFBRSxDQUFPLE9BQStCLEVBQUUsRUFBRTs7UUFDN0MsNkJBQTZCO1FBQzdCLE1BQU0sRUFDSixNQUFNLEVBQ04sVUFBVSxFQUNWLEdBQUcsRUFDSCxNQUFNLEVBQ04sSUFBSSxFQUNKLEdBQUcsRUFDSCxVQUFVLEVBQ1YsUUFBUSxFQUNSLEtBQUssRUFBRSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxFQUNyQyxNQUFNLEVBQUUsRUFBRSxPQUFPLEVBQUUsRUFDbkIsT0FBTyxFQUFFLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsRUFDN0MsTUFBTSxFQUNOLFFBQVEsR0FDVCxHQUFHLE9BQU8sQ0FBQztRQUVaLHFCQUFxQjtRQUNyQixNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDckMsTUFBTSxvQkFBb0IsR0FBRyxNQUFBLE1BQUEsTUFBQSxRQUFRLGFBQVIsUUFBUSx1QkFBUixRQUFRLENBQUUsUUFBUSwwQ0FBRSxVQUFVLDBDQUFFLE1BQU0sMENBQUUsY0FBYyxDQUFDO1FBQ3BGLE1BQU0sWUFBWSxHQUFHLE1BQUEsTUFBQSxNQUFBLFFBQVEsYUFBUixRQUFRLHVCQUFSLFFBQVEsQ0FBRSxRQUFRLDBDQUFFLFVBQVUsMENBQUUsTUFBTSwwQ0FBRSxNQUFNLENBQUM7UUFFcEUsdUJBQXVCO1FBQ3ZCLE1BQU0sWUFBWSxHQUFHLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBUyxRQUFRLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFFekUsc0VBQXNFO1FBQ3RFLE1BQU0sU0FBUyxHQUFHLE1BQU0sQ0FBQyxZQUFZLENBQUM7WUFDcEMsUUFBUSxFQUFFLFVBQVUsQ0FBQyxPQUFPLENBQUMsU0FBUyxJQUFJLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUM5RCxhQUFhLEVBQUUsTUFBQSxNQUFBLFFBQVEsYUFBUixRQUFRLHVCQUFSLFFBQVEsQ0FBRSxRQUFRLDBDQUFFLFVBQVUsMENBQUUsTUFBTTtZQUNyRCxNQUFNLEVBQUUsUUFBUTtTQUNqQixDQUFDLENBQUM7UUFFSCxjQUFjO1FBQ2QsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBRWxDLE9BQU87UUFDUCxJQUFJLENBQUMsaUNBQWlDLENBQUMsQ0FBQztRQUV4QyxZQUFZO1FBQ1osSUFBSSxDQUFDLENBQUMsTUFBTSxHQUFHLENBQUMsWUFBWSxFQUFFLENBQUMsRUFBRSxDQUFDO1lBQ2hDLE9BQU87UUFDVCxDQUFDO1FBRUQsV0FBVztRQUNYLE1BQU0sSUFBSSxHQUFHLE1BQU0sTUFBTSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsS0FBSyxFQUFFO1lBQ25ELElBQUksRUFBRSxjQUFjO1lBQ3BCLFNBQVMsRUFBRSxJQUFJO1NBQ2hCLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUNWLE9BQU87UUFDVCxDQUFDO1FBRUQsd0JBQXdCO1FBQ3hCLE1BQU0sVUFBVSxHQUFHLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUVuQyxvQ0FBb0M7UUFDcEMsSUFBSSxVQUFVLENBQUMsTUFBTSxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUM7WUFDbEMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1lBQ1QsS0FBSyxDQUFDLG1DQUFtQyxVQUFVLFNBQVMsQ0FBQyxDQUFDO1lBQzlELE9BQU87UUFDVCxDQUFDO1FBRUQsdUJBQXVCO1FBQ3ZCLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQywyREFBMkQsQ0FBQyxDQUFDO1FBQ3ZGLElBQUksQ0FBQztZQUNILE1BQU0sTUFBTSxDQUFDLEdBQUcsQ0FBQyxpRUFBaUUsVUFBVSxFQUFFLENBQUMsQ0FBQztZQUNoRyxJQUFJLFVBQVUsQ0FBQyxXQUFXLENBQUMsS0FBSyxVQUFVLEVBQUUsQ0FBQyxFQUFFLENBQUM7Z0JBQzlDLFVBQVUsQ0FBQyxNQUFNLENBQUMsS0FBSyxVQUFVLE9BQU8sQ0FBQyxDQUFDO2dCQUMxQyxZQUFZLENBQUMsT0FBTyxDQUFDLDRFQUE0RSxDQUFDLENBQUM7WUFDckcsQ0FBQztRQUNILENBQUM7UUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ2IsWUFBWSxDQUFDLElBQUksQ0FBQywrQkFBK0IsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFDaEUsT0FBTztRQUNULENBQUM7UUFFRCxrQkFBa0I7UUFDbEIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsS0FBSyxVQUFVLEVBQUUsQ0FBQyxFQUFFLENBQUM7WUFDL0MsS0FBSyxDQUFDLGtCQUFrQixVQUFVLHlCQUF5QixDQUFDLENBQUM7WUFDN0QsT0FBTztRQUNULENBQUM7UUFFRCxzRUFBc0U7UUFDdEUsTUFBTSxTQUFTLEdBQUcsVUFBVSxDQUFDLE1BQU0sSUFBSSxVQUFVLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQztRQUNqRSxJQUFJLE1BQWMsQ0FBQztRQUNuQixJQUFJLFNBQVMsRUFBRSxDQUFDO1lBQ2QsTUFBTSxHQUFHLFNBQVMsQ0FBQztRQUNyQixDQUFDO2FBQU0sSUFBSSxZQUFZLEVBQUUsQ0FBQztZQUN4QixNQUFNLEdBQUcsWUFBWSxDQUFDO1lBQ3RCLElBQUksQ0FBQywyREFBMkQsWUFBWSxFQUFFLENBQUMsQ0FBQztRQUNsRixDQUFDO2FBQU0sSUFBSSxZQUFZLEVBQUUsQ0FBQztZQUN4QixNQUFNLEdBQUcsWUFBWSxDQUFDO1lBQ3RCLElBQUksQ0FBQyx5Q0FBeUMsWUFBWSxFQUFFLENBQUMsQ0FBQztRQUNoRSxDQUFDO2FBQU0sQ0FBQztZQUNOLE1BQU0sR0FBRyxNQUFNLE1BQU0sQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFO2dCQUNuQyxJQUFJLEVBQUUsUUFBUTtnQkFDZCxTQUFTLEVBQUUsS0FBSzthQUNqQixDQUFDLENBQUM7UUFDTCxDQUFDO1FBRUQsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBRTdDLGdEQUFnRDtRQUNoRCxNQUFNLFNBQVMsR0FBRyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDbEMsTUFBTSxTQUFTLEdBQUcsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2xDLE1BQU0sVUFBVSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUVwQyxhQUFhO1FBQ2IsTUFBTSxRQUFRLENBQUMsUUFBUSxDQUFDO1lBQ3RCLEtBQUssRUFBRSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUU7WUFDekQsTUFBTSxFQUFFLEtBQUssVUFBVSxZQUFZO1lBQ25DLFFBQVEsRUFBRSxrQ0FBa0M7U0FDN0MsQ0FBQyxDQUFDO1FBRUgsbUJBQW1CO1FBQ25CLE1BQU0sUUFBUSxDQUFDLE1BQU0sQ0FBQyxLQUFLLFVBQVUsZUFBZSxFQUFFLENBQUMsTUFBTSxFQUFFLEVBQUU7WUFDL0QsTUFBTSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7WUFDdkIsTUFBTSxDQUFDLElBQUksR0FBRztnQkFDWixHQUFHLEVBQUUsRUFBRTthQUNSLENBQUM7WUFDRixNQUFNLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQztZQUMxQixNQUFNLENBQUMsUUFBUSxHQUFHLEVBQUUsQ0FBQztZQUNyQixNQUFNLENBQUMsSUFBSSxHQUFHLFNBQVMsQ0FBQztZQUN4QixNQUFNLENBQUMsVUFBVSxHQUFHO2dCQUNsQixJQUFJLEVBQUUsS0FBSztnQkFDWCxHQUFHLEVBQUUsRUFBRTthQUNSLENBQUM7WUFDRixNQUFNLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztZQUN6QixPQUFPLE1BQU0sQ0FBQztRQUNoQixDQUFDLENBQUMsQ0FBQztRQUVILG1CQUFtQjtRQUNuQixNQUFNLFFBQVEsQ0FBQyxNQUFNLENBQUMsS0FBSyxVQUFVLG9CQUFvQixFQUFFLENBQUMsTUFBTSxFQUFFLEVBQUU7WUFDcEUsTUFBTSxDQUFDLElBQUksR0FBRyxTQUFTLENBQUM7WUFDeEIsTUFBTSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7WUFDekIsT0FBTyxNQUFNLENBQUM7UUFDaEIsQ0FBQyxDQUFDLENBQUM7UUFFSCxjQUFjLENBQUMsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFFekMsaUZBQWlGO1FBQ2pGLElBQUksTUFBZSxDQUFDO1FBQ3BCLElBQUksVUFBVSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDNUMsTUFBTSxHQUFHLFVBQVUsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDO1FBQ3JDLENBQUM7YUFBTSxJQUFJLG9CQUFvQixLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQzlDLE1BQU0sR0FBRyxvQkFBb0IsQ0FBQztZQUM5QixJQUFJLENBQUMsd0NBQXdDLE1BQU0sRUFBRSxDQUFDLENBQUM7UUFDekQsQ0FBQzthQUFNLElBQUksU0FBUyxFQUFFLENBQUM7WUFDckIsTUFBTSxHQUFHLElBQUksQ0FBQyxDQUFDLHdDQUF3QztRQUN6RCxDQUFDO2FBQU0sQ0FBQztZQUNOLE1BQU0sR0FBRyxNQUFNLE9BQU8sQ0FBQyxzRUFBc0UsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUN2RyxDQUFDO1FBQ0QsSUFBSSxNQUFNLEVBQUUsQ0FBQztZQUNYLFNBQVM7WUFDVCxNQUFNLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxHQUFHLEVBQUUsSUFBQSxXQUFJLEVBQUMsVUFBVSxDQUFDLEdBQUcsRUFBRSxFQUFFLFVBQVUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDaEcsQ0FBQzthQUFNLENBQUM7WUFDTixXQUFXO1lBQ1gsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLHNCQUFzQixDQUFDLENBQUM7WUFDcEQsSUFBSSxDQUFDO2dCQUNILE1BQU0sTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLFVBQVUsV0FBVyxDQUFDLENBQUM7Z0JBQzlDLGNBQWMsQ0FBQyxPQUFPLENBQUMsd0JBQXdCLENBQUMsQ0FBQztZQUNuRCxDQUFDO1lBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztnQkFDYixjQUFjLENBQUMsSUFBSSxDQUFDLG1DQUFtQyxHQUFHLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztnQkFDdEUsT0FBTztZQUNULENBQUM7UUFDSCxDQUFDO1FBRUQsV0FBVztRQUNYLE1BQU0sY0FBYyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1FBQzlDLElBQUksQ0FBQztZQUNILE1BQU0sTUFBTSxDQUFDLEdBQUcsQ0FDZCxNQUFNLFVBQVUsd0VBQXdFLElBQUksQ0FBQyxPQUFPLEVBQUUsR0FBRyxDQUMxRyxDQUFDO1lBQ0YsY0FBYyxDQUFDLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO1FBQzVDLENBQUM7UUFBQyxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ2IsY0FBYyxDQUFDLElBQUksQ0FBQyw2QkFBNkIsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFDaEUsT0FBTztRQUNULENBQUM7UUFFRCxzQ0FBc0M7UUFDdEMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQ1QsT0FBTyxDQUFDLGFBQWEsSUFBSSx3QkFBd0IsSUFBSSxDQUFDLE9BQU8sRUFBRSxPQUFPLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNqSCxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7UUFFVCxnQ0FBZ0M7UUFDaEMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLGVBQWUsRUFBRSxDQUFDO1lBQ2hELE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNqQixDQUFDO1FBRUQsWUFBWTtRQUNaLE9BQU8sbUJBQW1CLElBQUksRUFBRSxDQUFDO0lBQ25DLENBQUMsQ0FBQTtDQUNGLENBQUM7QUFFRixrQkFBZSxVQUFVLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/build/extensions/api-mode.js

@@ -0,0 +1,440 @@
+"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.ApiMode = void 0;
+const path_1 = require("path");
+/**
+ * API Mode processing for nest-server-starter template
+ *
+ * Reads the api-mode.manifest.json from the project and processes it
+ * based on the selected API mode (Rest, GraphQL, Both).
+ */
+class ApiMode {
+    constructor(toolbox) {
+        this.toolbox = toolbox;
+        this.filesystem = toolbox.filesystem;
+    }
+    /**
+     * Process the API mode for a project
+     *
+     * @param projectPath - Path to the project root
+     * @param mode - Selected API mode
+     */
+    processApiMode(projectPath, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const manifestPath = (0, path_1.join)(projectPath, 'api-mode.manifest.json');
+            // Read manifest
+            const manifestContent = this.filesystem.read(manifestPath);
+            if (!manifestContent) {
+                return; // No manifest = nothing to do
+            }
+            const manifest = JSON.parse(manifestContent);
+            if (mode === 'Both') {
+                // Both mode: just remove markers and cleanup
+                this.stripAllMarkers(projectPath);
+            }
+            else if (mode === 'Rest') {
+                // REST mode: remove graphql regions, keep rest regions
+                yield this.removeMode(projectPath, manifest, 'graphql', 'rest');
+                yield this.modifyConfigEnvForRest(projectPath);
+            }
+            else if (mode === 'GraphQL') {
+                // GraphQL mode: remove rest regions, keep graphql regions
+                yield this.removeMode(projectPath, manifest, 'rest', 'graphql');
+            }
+            // Remove manifest and strip-markers script
+            this.filesystem.remove(manifestPath);
+            this.filesystem.remove((0, path_1.join)(projectPath, 'scripts', 'strip-api-mode-markers.mjs'));
+            // Remove strip-markers script from package.json
+            this.removeScriptFromPackageJson(projectPath, 'strip-markers');
+        });
+    }
+    /**
+     * Remove a specific mode from the project
+     */
+    removeMode(projectPath, manifest, removeMarker, keepMarker) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const modeConfig = manifest.modes[removeMarker];
+            if (!modeConfig) {
+                return;
+            }
+            // 1. Delete files matching filePatterns
+            if (modeConfig.filePatterns) {
+                for (const pattern of modeConfig.filePatterns) {
+                    const matches = this.filesystem.find(projectPath, {
+                        matching: pattern,
+                    });
+                    for (const file of matches) {
+                        this.filesystem.remove(file);
+                    }
+                }
+            }
+            // 2. Remove packages from package.json
+            const pkgPath = (0, path_1.join)(projectPath, 'package.json');
+            const pkg = JSON.parse(this.filesystem.read(pkgPath));
+            if (modeConfig.packages) {
+                for (const p of modeConfig.packages) {
+                    (_a = pkg.dependencies) === null || _a === void 0 ? true : delete _a[p];
+                }
+            }
+            if (modeConfig.devPackages) {
+                for (const p of modeConfig.devPackages) {
+                    (_b = pkg.devDependencies) === null || _b === void 0 ? true : delete _b[p];
+                }
+            }
+            // 3. Remove scripts
+            if (modeConfig.scripts) {
+                for (const s of modeConfig.scripts) {
+                    (_c = pkg.scripts) === null || _c === void 0 ? true : delete _c[s];
+                }
+            }
+            // 4. Edit scripts (e.g. remove parts from a script value)
+            if (modeConfig.scriptEdits && pkg.scripts) {
+                for (const [scriptName, edit] of Object.entries(modeConfig.scriptEdits)) {
+                    if (pkg.scripts[scriptName] && edit.remove) {
+                        pkg.scripts[scriptName] = pkg.scripts[scriptName].replace(edit.remove, '');
+                    }
+                }
+            }
+            this.filesystem.write(pkgPath, pkg, { jsonIndent: 2 });
+            // 5. Strip regions from source files
+            this.stripRegions(projectPath, removeMarker, keepMarker);
+            // 6. Clean orphan imports
+            this.cleanOrphanImports(projectPath);
+        });
+    }
+    /**
+     * Strip region markers from all .ts files
+     *
+     * For removeMarker: delete marker lines AND content between them
+     * For keepMarker: delete only the marker lines, keep content
+     */
+    stripRegions(projectPath, removeMarker, keepMarker) {
+        const dirs = [(0, path_1.join)(projectPath, 'src'), (0, path_1.join)(projectPath, 'tests')];
+        for (const dir of dirs) {
+            if (!this.filesystem.exists(dir)) {
+                continue;
+            }
+            const files = this.filesystem.find(dir, { matching: '**/*.ts' });
+            for (const file of files) {
+                const content = this.filesystem.read(file);
+                if (!content) {
+                    continue;
+                }
+                const processed = this.processFileRegions(content, removeMarker, keepMarker);
+                if (processed !== content) {
+                    this.filesystem.write(file, processed);
+                }
+            }
+        }
+    }
+    /**
+     * Process region markers in file content
+     */
+    processFileRegions(content, removeMarker, keepMarker) {
+        const lines = content.split('\n');
+        const result = [];
+        let removing = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Check for region start
+            if (trimmed === `// #region ${removeMarker}`) {
+                removing = true;
+                continue; // Skip the marker line
+            }
+            // Check for region end
+            if (trimmed === `// #endregion ${removeMarker}`) {
+                removing = false;
+                continue; // Skip the marker line
+            }
+            // Check for keep markers (just remove the marker lines, keep content)
+            if (trimmed === `// #region ${keepMarker}` || trimmed === `// #endregion ${keepMarker}`) {
+                continue; // Skip marker line, content between them is kept naturally
+            }
+            // Skip content inside remove region
+            if (removing) {
+                continue;
+            }
+            result.push(line);
+        }
+        // Clean up multiple consecutive blank lines (max 1)
+        return this.collapseBlankLines(result.join('\n'));
+    }
+    /**
+     * Strip ALL markers (for Both mode) - keep all content
+     */
+    stripAllMarkers(projectPath) {
+        const dirs = [(0, path_1.join)(projectPath, 'src'), (0, path_1.join)(projectPath, 'tests')];
+        for (const dir of dirs) {
+            if (!this.filesystem.exists(dir)) {
+                continue;
+            }
+            const files = this.filesystem.find(dir, { matching: '**/*.ts' });
+            for (const file of files) {
+                const content = this.filesystem.read(file);
+                if (!content) {
+                    continue;
+                }
+                const lines = content.split('\n');
+                const filtered = lines.filter((line) => {
+                    const trimmed = line.trim();
+                    return !trimmed.match(/^\/\/ #(region|endregion)\s/);
+                });
+                const processed = filtered.join('\n');
+                if (processed !== content) {
+                    this.filesystem.write(file, processed);
+                }
+            }
+        }
+    }
+    /**
+     * Modify config.env.ts for REST mode using ts-morph AST manipulation
+     *
+     * - Replace `graphQl: { ... }` blocks with `graphQl: false`
+     * - Remove `execAfterInit` properties
+     */
+    modifyConfigEnvForRest(projectPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const configPath = (0, path_1.join)(projectPath, 'src', 'config.env.ts');
+            if (!this.filesystem.exists(configPath)) {
+                return;
+            }
+            try {
+                const { Project, SyntaxKind } = require('ts-morph');
+                const project = new Project({ skipAddingFilesFromTsConfig: true });
+                const sourceFile = project.addSourceFileAtPath(configPath);
+                // Find the 'config' variable declaration directly
+                // Structure: export const config: { [env: string]: ... } = { ci: { ... }, develop: { ... }, ... };
+                let configObj;
+                const variableStatements = sourceFile.getVariableStatements();
+                for (const vs of variableStatements) {
+                    for (const decl of vs.getDeclarations()) {
+                        if (decl.getName() === 'config') {
+                            const init = decl.getInitializer();
+                            if ((init === null || init === void 0 ? void 0 : init.getKind()) === SyntaxKind.ObjectLiteralExpression) {
+                                configObj = init;
+                            }
+                        }
+                        // Handle merge() call: const config = merge({ default: ... }, { local: ... }, ...)
+                        if (!configObj) {
+                            const init = decl.getInitializer();
+                            if ((init === null || init === void 0 ? void 0 : init.getKind()) === SyntaxKind.CallExpression) {
+                                const args = (_a = init.getArguments) === null || _a === void 0 ? void 0 : _a.call(init);
+                                if (args) {
+                                    for (const arg of args) {
+                                        if (arg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                                            this.processConfigObject(arg, SyntaxKind);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if (configObj) {
+                    this.processConfigObject(configObj, SyntaxKind);
+                }
+                sourceFile.saveSync();
+            }
+            catch (_b) {
+                // If ts-morph is not available or fails, fall back to regex
+                this.modifyConfigEnvForRestFallback(projectPath);
+            }
+        });
+    }
+    /**
+     * Process a config object literal: replace graphQl and remove execAfterInit
+     */
+    processConfigObject(obj, SyntaxKind) {
+        // Process all nested object literals (environment configs)
+        const properties = obj.getProperties();
+        for (const prop of properties) {
+            if (prop.getKind() !== SyntaxKind.PropertyAssignment) {
+                continue;
+            }
+            const name = prop.getName();
+            // Replace graphQl: { ... } with graphQl: false
+            if (name === 'graphQl') {
+                const init = prop.getInitializer();
+                if (init && init.getKind() === SyntaxKind.ObjectLiteralExpression) {
+                    prop.setInitializer('false');
+                }
+                continue;
+            }
+            // Remove execAfterInit
+            if (name === 'execAfterInit') {
+                prop.remove();
+                continue;
+            }
+            // Recurse into nested objects (environment configs like default, local, etc.)
+            const init = prop.getInitializer();
+            if ((init === null || init === void 0 ? void 0 : init.getKind()) === SyntaxKind.ObjectLiteralExpression) {
+                this.processConfigObject(init, SyntaxKind);
+            }
+        }
+    }
+    /**
+     * Fallback: Regex-based config.env.ts modification
+     */
+    modifyConfigEnvForRestFallback(projectPath) {
+        const configPath = (0, path_1.join)(projectPath, 'src', 'config.env.ts');
+        let content = this.filesystem.read(configPath);
+        if (!content) {
+            return;
+        }
+        // Replace graphQl: { ... } blocks with graphQl: false
+        // Match graphQl: { ... }, handling nested braces
+        content = content.replace(/graphQl:\s*\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\},?/g, 'graphQl: false,');
+        // Remove execAfterInit lines
+        content = content.replace(/\s*execAfterInit:.*,?\n/g, '\n');
+        this.filesystem.write(configPath, content);
+    }
+    /**
+     * Clean orphan imports after region stripping
+     *
+     * After removing region content, some imports may reference identifiers
+     * that no longer exist in the file. This removes those imports.
+     */
+    cleanOrphanImports(projectPath) {
+        const dirs = [(0, path_1.join)(projectPath, 'src')];
+        for (const dir of dirs) {
+            if (!this.filesystem.exists(dir)) {
+                continue;
+            }
+            const files = this.filesystem.find(dir, { matching: '**/*.ts' });
+            for (const file of files) {
+                const content = this.filesystem.read(file);
+                if (!content) {
+                    continue;
+                }
+                const cleaned = this.removeUnusedImports(content);
+                if (cleaned !== content) {
+                    this.filesystem.write(file, cleaned);
+                }
+            }
+        }
+    }
+    /**
+     * Remove unused imports from TypeScript file content
+     */
+    removeUnusedImports(content) {
+        const lines = content.split('\n');
+        const importLines = [];
+        // Parse import statements
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            const singleImportMatch = line.match(/^import\s+\{([^}]+)\}\s+from\s+['"]/);
+            const multiImportStart = line.match(/^import\s+\{$/);
+            if (singleImportMatch) {
+                const imports = singleImportMatch[1].split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean)
+                    .map((s) => ({ original: s, resolved: this.resolveImportAlias(s) }));
+                importLines.push({ end: i, imports, start: i });
+            }
+            else if (multiImportStart) {
+                // Multi-line import
+                const start = i;
+                const imports = [];
+                i++;
+                while (i < lines.length && !lines[i].match(/^\}\s+from\s+['"]/)) {
+                    const raw = lines[i].replace(/,?\s*$/, '').trim();
+                    if (raw) {
+                        imports.push({ original: raw, resolved: this.resolveImportAlias(raw) });
+                    }
+                    i++;
+                }
+                importLines.push({ end: i, imports, start });
+            }
+            i++;
+        }
+        // Get the non-import part of the file
+        const maxImportEnd = importLines.reduce((max, il) => Math.max(max, il.end), -1);
+        const codeContent = lines.slice(maxImportEnd + 1).join('\n');
+        // Check each import
+        const linesToRemove = new Set();
+        for (const imp of importLines) {
+            const usedImports = imp.imports.filter(({ resolved }) => {
+                // Check if resolved identifier is used in code (not in imports)
+                const regex = new RegExp(`\\b${resolved.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`);
+                return regex.test(codeContent);
+            });
+            if (usedImports.length === 0) {
+                // Remove entire import
+                for (let j = imp.start; j <= imp.end; j++) {
+                    linesToRemove.add(j);
+                }
+            }
+            else if (usedImports.length < imp.imports.length) {
+                // Rebuild import with only used identifiers (using original text for aliases)
+                const fromMatch = lines[imp.end].match(/from\s+['"].*['"]/);
+                const fromClause = fromMatch ? fromMatch[0] : '';
+                if (fromClause) {
+                    // Remove old lines
+                    for (let j = imp.start; j <= imp.end; j++) {
+                        linesToRemove.add(j);
+                    }
+                    const originals = usedImports.map((ui) => ui.original);
+                    // Add rebuilt import at start position
+                    if (originals.length <= 3) {
+                        lines[imp.start] = `import { ${originals.join(', ')} } ${fromClause};`;
+                        linesToRemove.delete(imp.start);
+                    }
+                    else {
+                        // Multi-line for many imports
+                        lines[imp.start] = `import {\n  ${originals.join(',\n  ')},\n} ${fromClause};`;
+                        linesToRemove.delete(imp.start);
+                    }
+                }
+            }
+        }
+        // Remove marked lines
+        const result = lines.filter((_, idx) => !linesToRemove.has(idx));
+        return this.collapseBlankLines(result.join('\n'));
+    }
+    /**
+     * Resolve import alias: "Schema as MongooseSchema" -> "MongooseSchema"
+     * For non-aliased imports, returns the identifier as-is.
+     */
+    resolveImportAlias(identifier) {
+        const asMatch = identifier.match(/^\S+\s+as\s+(\S+)$/);
+        return asMatch ? asMatch[1] : identifier;
+    }
+    /**
+     * Collapse multiple consecutive blank lines into at most one
+     */
+    collapseBlankLines(content) {
+        return content.replace(/\n{3,}/g, '\n\n');
+    }
+    /**
+     * Remove a script from package.json
+     */
+    removeScriptFromPackageJson(projectPath, scriptName) {
+        var _a;
+        const pkgPath = (0, path_1.join)(projectPath, 'package.json');
+        const pkg = JSON.parse(this.filesystem.read(pkgPath));
+        if ((_a = pkg.scripts) === null || _a === void 0 ? void 0 : _a[scriptName]) {
+            delete pkg.scripts[scriptName];
+            this.filesystem.write(pkgPath, pkg, { jsonIndent: 2 });
+        }
+    }
+}
+exports.ApiMode = ApiMode;
+/**
+ * Extend toolbox
+ */
+exports.default = (toolbox) => {
+    toolbox.apiMode = new ApiMode(toolbox);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-mode.js","sourceRoot":"","sources":["../../src/extensions/api-mode.ts"],"names":[],"mappings":"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"}