boiling-fullstack 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lebowvsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,140 @@
+# boiling-fullstack
+
+Scaffold fullstack projects with Docker, NestJS backend, and Vue/Nuxt frontends in seconds.
+
+## Features
+
+- **Multi-frontend** — 1 to 5 frontends per project, each independently configured
+- **Framework choice** — Nuxt 4 (SSR) or Vue 3 + Vite (SPA) per frontend
+- **Styling choice** — CSS or Sass per frontend
+- **Backend** — NestJS + TypeORM + PostgreSQL with JWT authentication pre-configured
+- **Database migrations** — TypeORM migration scripts ready to use
+- **Docker Compose** — Dev and production configs with hot reloading
+- **Makefile** — All common commands available via `make`
+- **Code quality** — ESLint + Prettier pre-configured for all services
+- **DB admin** — Optional pgAdmin or Adminer
+- **Auto-generated README** — Each scaffolded project includes full documentation
+
+## Quick Start
+
+```bash
+npx boiling-fullstack my-project
+```
+
+The interactive CLI guides you through the setup:
+
+```
+◆  Project name: my-project
+◆  Number of frontends (1-5): 2
+◆  Frontend 1 - Service name: app
+◆  Frontend 1 - Framework: Nuxt
+◆  Frontend 1 - Styling: Sass
+◆  Frontend 1 - Port: 3000
+◆  Frontend 2 - Service name: backoffice
+◆  Frontend 2 - Framework: Vue
+◆  Frontend 2 - Styling: Plain CSS
+◆  Frontend 2 - Port: 3010
+◆  Backend port: 3001
+◆  Database, DB admin tool...
+◆  Generate project? Yes
+
+✔  Project generated successfully!
+```
+
+Then start everything:
+
+```bash
+cd my-project
+make up
+```
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) >= 20
+- [Docker](https://docs.docker.com/get-docker/) & Docker Compose V2
+
+## Generated Structure
+
+Example with 2 frontends (`app` Nuxt + `backoffice` Vue):
+
+```
+my-project/
+├── app/                          # Nuxt 4 frontend
+│   ├── app/
+│   │   ├── app.vue
+│   │   └── pages/
+│   │       └── index.vue
+│   ├── Dockerfile
+│   ├── nuxt.config.ts
+│   ├── package.json
+│   └── tsconfig.json
+├── backoffice/                   # Vue 3 + Vite frontend
+│   ├── src/
+│   │   ├── App.vue
+│   │   └── main.ts
+│   ├── Dockerfile
+│   ├── index.html
+│   ├── package.json
+│   ├── vite.config.ts
+│   └── tsconfig.json
+├── backend/                      # NestJS + TypeORM
+│   ├── src/
+│   │   ├── auth/
+│   │   │   ├── auth.controller.ts
+│   │   │   ├── auth.service.ts
+│   │   │   ├── auth.module.ts
+│   │   │   ├── jwt.strategy.ts
+│   │   │   ├── auth.guard.ts
+│   │   │   ├── dto/
+│   │   │   └── entities/
+│   │   │       └── user.entity.ts
+│   │   ├── config/
+│   │   │   ├── typeorm.config.ts
+│   │   │   └── data-source.ts
+│   │   ├── migrations/
+│   │   ├── app.module.ts
+│   │   └── main.ts
+│   ├── Dockerfile
+│   └── package.json
+├── docker-compose.yml            # Dev
+├── docker-compose.prod.yml       # Production
+├── .env                          # Dev env variables
+├── .env.production               # Prod env variables (placeholders)
+├── Makefile
+├── README.md
+└── .gitignore
+```
+
+## Available Commands
+
+| Command | Description |
+|---------|-------------|
+| `make up` | Start all services (dev) |
+| `make down` | Stop all services |
+| `make logs` | View all logs |
+| `make build` | Rebuild all services |
+| `make restart` | Restart all services |
+| `make clean` | Stop & remove volumes |
+| `make db-shell` | Open PostgreSQL shell |
+| `make backend-shell` | Open backend container shell |
+| `make lint-back` | Run ESLint on backend |
+| `make format-back` | Run Prettier on backend |
+| `make migration-generate name=Name` | Generate a TypeORM migration |
+| `make migration-run` | Run pending migrations |
+| `make up-prod` | Start all services (production) |
+
+## CLI Options
+
+```
+Usage: boiling [options] [project-name]
+
+Options:
+  -f, --force    Overwrite existing directory
+  -v, --verbose  Show shell command output
+  -V, --version  Output version number
+  -h, --help     Display help
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+import type { CliOptions } from './types';
+export declare function runCli(projectName?: string, options?: CliOptions): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,313 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const clack = __importStar(require("@clack/prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const validation_1 = require("./utils/validation");
+const scaffolder_1 = require("./scaffolder");
+const shell_1 = require("./utils/shell");
+function handleCancel() {
+    clack.cancel('Operation cancelled.');
+    process.exit(0);
+}
+async function runCli(projectName, options = { force: false, verbose: false }) {
+    clack.intro(chalk_1.default.bgCyan.black(' boiling-fullstack '));
+    (0, shell_1.setVerbose)(options.verbose);
+    await (0, shell_1.checkEnvironment)();
+    // --- Project name ---
+    const nameResult = await clack.text({
+        message: 'Project name:',
+        placeholder: 'my-project',
+        initialValue: projectName,
+        validate(value) {
+            const result = (0, validation_1.isValidProjectName)(value);
+            if (result !== true)
+                return result;
+        },
+    });
+    if (clack.isCancel(nameResult))
+        handleCancel();
+    const finalProjectName = nameResult;
+    // --- Number of frontends ---
+    const frontendCountResult = await clack.text({
+        message: 'Number of frontends (1-5):',
+        defaultValue: '1',
+        validate(value) {
+            const n = parseInt(value, 10);
+            if (isNaN(n) || n < 1 || n > 5)
+                return 'Enter a number between 1 and 5';
+        },
+    });
+    if (clack.isCancel(frontendCountResult))
+        handleCancel();
+    const frontendCount = parseInt(frontendCountResult, 10);
+    // --- Frontend configs ---
+    const usedPorts = [5432];
+    const usedServiceNames = ['backend', 'db'];
+    const frontends = [];
+    for (let i = 0; i < frontendCount; i++) {
+        const defaultPort = 3000 + i * 10;
+        const prefix = frontendCount > 1 ? `Frontend ${i + 1}` : 'Frontend';
+        clack.log.step(chalk_1.default.cyan(`${prefix} configuration`));
+        // Name
+        const nameRes = await clack.text({
+            message: `${prefix} - Service name:`,
+            placeholder: frontendCount === 1 ? 'frontend' : `frontend-${i + 1}`,
+            defaultValue: frontendCount === 1 ? 'frontend' : `frontend-${i + 1}`,
+            validate(value) {
+                const result = (0, validation_1.isValidServiceName)(value, usedServiceNames);
+                if (result !== true)
+                    return result;
+            },
+        });
+        if (clack.isCancel(nameRes))
+            handleCancel();
+        const serviceName = nameRes;
+        usedServiceNames.push(serviceName);
+        // Framework
+        const frameworkRes = await clack.select({
+            message: `${prefix} - Framework:`,
+            options: [
+                { value: 'nuxt', label: 'Nuxt', hint: 'full-stack Vue framework' },
+                { value: 'vue', label: 'Vue', hint: 'SPA with Vite' },
+            ],
+            initialValue: 'nuxt',
+        });
+        if (clack.isCancel(frameworkRes))
+            handleCancel();
+        const framework = frameworkRes;
+        // Styling
+        const stylingRes = await clack.select({
+            message: `${prefix} - Styling:`,
+            options: [
+                { value: 'css', label: 'Plain CSS' },
+                { value: 'sass', label: 'Sass', hint: 'installs sass as dependency' },
+            ],
+            initialValue: 'css',
+        });
+        if (clack.isCancel(stylingRes))
+            handleCancel();
+        const styling = stylingRes;
+        // Port
+        const portRes = await clack.text({
+            message: `${prefix} - Port:`,
+            defaultValue: String(defaultPort),
+            validate(value) {
+                const port = parseInt(value, 10);
+                if (isNaN(port))
+                    return 'Enter a valid number';
+                const result = (0, validation_1.isValidPort)(port, usedPorts);
+                if (result !== true)
+                    return result;
+            },
+        });
+        if (clack.isCancel(portRes))
+            handleCancel();
+        const port = parseInt(portRes, 10);
+        usedPorts.push(port);
+        frontends.push({ name: serviceName, framework, styling, port });
+    }
+    // --- Backend port ---
+    const backendPortRes = await clack.text({
+        message: 'Backend port:',
+        defaultValue: '3001',
+        validate(value) {
+            const port = parseInt(value, 10);
+            if (isNaN(port))
+                return 'Enter a valid number';
+            const result = (0, validation_1.isValidPort)(port, usedPorts);
+            if (result !== true)
+                return result;
+        },
+    });
+    if (clack.isCancel(backendPortRes))
+        handleCancel();
+    const backendPort = parseInt(backendPortRes, 10);
+    usedPorts.push(backendPort);
+    // --- Database config ---
+    clack.log.step(chalk_1.default.cyan('Database configuration'));
+    const dbNameRes = await clack.text({
+        message: 'Database name:',
+        defaultValue: `${finalProjectName.replace(/-/g, '_')}_db`,
+        validate(value) {
+            if (!value)
+                return 'Name is required';
+        },
+    });
+    if (clack.isCancel(dbNameRes))
+        handleCancel();
+    const dbName = dbNameRes;
+    const dbUserRes = await clack.text({
+        message: 'Database user:',
+        defaultValue: 'postgres',
+        validate(value) {
+            if (!value)
+                return 'User is required';
+        },
+    });
+    if (clack.isCancel(dbUserRes))
+        handleCancel();
+    const dbUser = dbUserRes;
+    const defaultPassword = (0, validation_1.generatePassword)();
+    const dbPasswordRes = await clack.text({
+        message: 'Database password:',
+        defaultValue: defaultPassword,
+        validate(value) {
+            if (!value)
+                return 'Password is required';
+            if (value.length < 8)
+                return 'Password must be at least 8 characters';
+        },
+    });
+    if (clack.isCancel(dbPasswordRes))
+        handleCancel();
+    const dbPassword = dbPasswordRes;
+    // --- JWT Secret ---
+    const jwtSecret = (0, validation_1.generateJwtSecret)();
+    // --- DB Admin tool ---
+    clack.log.step(chalk_1.default.cyan('DB admin tool'));
+    const dbAdminToolRes = await clack.select({
+        message: 'Database admin tool:',
+        options: [
+            { value: 'none', label: 'None' },
+            { value: 'pgadmin', label: 'pgAdmin', hint: 'feature-rich interface' },
+            { value: 'adminer', label: 'Adminer', hint: 'lightweight and fast' },
+        ],
+        initialValue: 'none',
+    });
+    if (clack.isCancel(dbAdminToolRes))
+        handleCancel();
+    const dbAdminTool = dbAdminToolRes;
+    let dbAdmin;
+    if (dbAdminTool !== 'none') {
+        const defaultPort = dbAdminTool === 'pgadmin' ? 5050 : 8080;
+        const dbAdminPortRes = await clack.text({
+            message: `${dbAdminTool === 'pgadmin' ? 'pgAdmin' : 'Adminer'} port:`,
+            defaultValue: String(defaultPort),
+            validate(value) {
+                const port = parseInt(value, 10);
+                if (isNaN(port))
+                    return 'Enter a valid number';
+                const result = (0, validation_1.isValidPort)(port, usedPorts);
+                if (result !== true)
+                    return result;
+            },
+        });
+        if (clack.isCancel(dbAdminPortRes))
+            handleCancel();
+        const dbAdminPort = parseInt(dbAdminPortRes, 10);
+        usedPorts.push(dbAdminPort);
+        if (dbAdminTool === 'pgadmin') {
+            const pgAdminEmailRes = await clack.text({
+                message: 'pgAdmin email:',
+                defaultValue: 'admin@admin.com',
+                validate(value) {
+                    if (!value)
+                        return 'Email is required';
+                },
+            });
+            if (clack.isCancel(pgAdminEmailRes))
+                handleCancel();
+            const pgAdminEmail = pgAdminEmailRes;
+            const defaultPgAdminPassword = (0, validation_1.generatePassword)();
+            const pgAdminPasswordRes = await clack.text({
+                message: 'pgAdmin password:',
+                defaultValue: defaultPgAdminPassword,
+                validate(value) {
+                    if (!value)
+                        return 'Password is required';
+                    if (value.length < 8)
+                        return 'Password must be at least 8 characters';
+                },
+            });
+            if (clack.isCancel(pgAdminPasswordRes))
+                handleCancel();
+            const pgAdminPassword = pgAdminPasswordRes;
+            dbAdmin = { tool: 'pgadmin', port: dbAdminPort, email: pgAdminEmail, password: pgAdminPassword };
+        }
+        else {
+            dbAdmin = { tool: 'adminer', port: dbAdminPort };
+        }
+    }
+    // --- Build config ---
+    const config = {
+        projectName: finalProjectName,
+        frontends,
+        backendPort,
+        dbName,
+        dbUser,
+        dbPassword,
+        jwtSecret,
+        dbAdmin,
+    };
+    // --- Recap ---
+    const frontendLines = config.frontends
+        .map((f, i) => `  ${i + 1}. ${f.name} (${f.framework}, ${f.styling}, port ${f.port})`)
+        .join('\n');
+    const dbAdminLabel = config.dbAdmin
+        ? `${config.dbAdmin.tool === 'pgadmin' ? 'pgAdmin' : 'Adminer'} (port ${config.dbAdmin.port})`
+        : 'None';
+    const recap = [
+        `${chalk_1.default.bold('Project')}      : ${config.projectName}`,
+        `${chalk_1.default.bold('Frontends')}    :`,
+        frontendLines,
+        `${chalk_1.default.bold('Backend')}      : port ${config.backendPort}`,
+        `${chalk_1.default.bold('Database')}     :`,
+        `  Name         : ${config.dbName}`,
+        `  User         : ${config.dbUser}`,
+        `  Password     : ${config.dbPassword}`,
+        `${chalk_1.default.bold('DB Admin')}     : ${dbAdminLabel}`,
+    ].join('\n');
+    clack.note(recap, 'Summary');
+    // --- Confirmation ---
+    const confirmRes = await clack.confirm({
+        message: 'Generate project?',
+        initialValue: true,
+    });
+    if (clack.isCancel(confirmRes))
+        handleCancel();
+    if (!confirmRes) {
+        clack.outro('Generation cancelled.');
+        return;
+    }
+    // --- Scaffold ---
+    await (0, scaffolder_1.scaffold)(config, options);
+    clack.note(`cd ${config.projectName}\nmake up`, 'Getting started');
+    clack.outro(chalk_1.default.green('Project generated successfully!'));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const cli_1 = require("./cli");
+const { version } = require('../package.json');
+const program = new commander_1.Command();
+program
+    .name('boiling')
+    .description('Scaffold a fullstack project with Docker, NestJS backend, and Vue/Nuxt frontends')
+    .version(version)
+    .argument('[project-name]', 'Project name')
+    .option('-f, --force', 'Overwrite existing directory', false)
+    .option('-v, --verbose', 'Show shell command output', false)
+    .action(async (projectName, opts) => {
+    try {
+        const options = { force: opts.force, verbose: opts.verbose };
+        await (0, cli_1.runCli)(projectName, options);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`\nError: ${error.message}`));
+        process.exit(1);
+    }
+});
+process.on('unhandledRejection', (reason) => {
+    console.error(chalk_1.default.red(`\nUnexpected error: ${reason?.message || reason}`));
+    process.exit(1);
+});
+program.parse();

package/dist/scaffolder.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectConfig, CliOptions } from './types';
+export declare function scaffold(config: ProjectConfig, options: CliOptions): Promise<void>;

package/dist/scaffolder.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffold = scaffold;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const clack = __importStar(require("@clack/prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const template_1 = require("./utils/template");
+const shell_1 = require("./utils/shell");
+function getTemplatesDir() {
+    return path_1.default.resolve(__dirname, '..', 'templates');
+}
+async function scaffold(config, options) {
+    const s = clack.spinner();
+    const projectDir = path_1.default.resolve(process.cwd(), config.projectName);
+    const templatesDir = getTemplatesDir();
+    if (await fs_extra_1.default.pathExists(projectDir)) {
+        if (options.force) {
+            await fs_extra_1.default.remove(projectDir);
+        }
+        else {
+            throw new Error(`Directory "${config.projectName}" already exists. Use --force to overwrite.`);
+        }
+    }
+    try {
+        await fs_extra_1.default.ensureDir(projectDir);
+        // Frontends
+        for (const fe of config.frontends) {
+            s.start(`Generating ${chalk_1.default.cyan(fe.name)} (${fe.framework})...`);
+            await (0, template_1.copyAndRenderDir)(path_1.default.join(templatesDir, 'frontend', fe.framework), path_1.default.join(projectDir, fe.name), { name: fe.name, styling: fe.styling });
+            s.stop(`${chalk_1.default.cyan(fe.name)} created`);
+        }
+        // Backend
+        s.start(`Generating ${chalk_1.default.cyan('backend')} (NestJS)...`);
+        await (0, template_1.copyAndRenderDir)(path_1.default.join(templatesDir, 'backend', 'nestjs'), path_1.default.join(projectDir, 'backend'), { projectName: config.projectName, backendPort: config.backendPort });
+        s.stop(`${chalk_1.default.cyan('backend')} created`);
+        // Root files
+        s.start('Generating root files...');
+        await (0, template_1.copyAndRenderDir)(path_1.default.join(templatesDir, 'root'), projectDir, { ...config });
+        s.stop('Root files created');
+        // Git init
+        s.start('Initializing git repository...');
+        await (0, shell_1.gitInit)(projectDir);
+        s.stop('Git repository initialized');
+    }
+    catch (error) {
+        s.stop(chalk_1.default.red('Error'));
+        if (await fs_extra_1.default.pathExists(projectDir)) {
+            await fs_extra_1.default.remove(projectDir);
+        }
+        throw error;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+export interface FrontendConfig {
+    name: string;
+    framework: 'nuxt' | 'vue';
+    styling: 'css' | 'sass';
+    port: number;
+}
+export interface ProjectConfig {
+    projectName: string;
+    frontends: FrontendConfig[];
+    backendPort: number;
+    dbName: string;
+    dbUser: string;
+    dbPassword: string;
+    jwtSecret?: string;
+    dbAdmin?: DbAdminConfig;
+}
+export type DbAdminTool = 'none' | 'pgadmin' | 'adminer';
+export interface DbAdminConfig {
+    tool: DbAdminTool;
+    port: number;
+    email?: string;
+    password?: string;
+}
+export interface CliOptions {
+    force: boolean;
+    verbose: boolean;
+}
+export type ValidationResult = true | string;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/shell.d.ts

@@ -0,0 +1,6 @@
+export declare function setVerbose(v: boolean): void;
+export declare function runCommand(command: string, args: string[], cwd: string): Promise<void>;
+export declare function checkCommand(cmd: string): Promise<boolean>;
+export declare function checkEnvironment(): Promise<void>;
+export declare function gitInit(cwd: string): Promise<void>;
+export declare function npmInstall(cwd: string): Promise<void>;