esa-cli 0.0.2-beta.14 → 0.0.2-beta.15

package/dist/commands/init/helper.js

@@ -9,14 +9,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { execSync } from 'child_process';
 import path from 'path';
+import { confirm as clackConfirm, isCancel, log, outro } from '@clack/prompts';
 import chalk from 'chalk';
 import fs from 'fs-extra';
-import inquirer from 'inquirer';
 import t from '../../i18n/index.js';
 import logger from '../../libs/logger.js';
 import Template from '../../libs/templates/index.js';
 import { getDirName } from '../../utils/fileUtils/base.js';
-import { getProjectConfig } from '../../utils/fileUtils/index.js';
+import { generateConfigFile, getCliConfig, getProjectConfig, getTemplatesConfig, templateHubPath, updateProjectConfigFile } from '../../utils/fileUtils/index.js';
+import { execCommand } from '../../utils/command.js';
+import promptParameter from '../../utils/prompt.js';
+import Haikunator from 'haikunator';
+import { commitAndDeployVersion } from '../common/utils.js';
+import { exit } from 'process';
 export const getTemplateInstances = (templateHubPath) => {
     return fs
         .readdirSync(templateHubPath)
@@ -131,12 +136,11 @@ export function checkAndUpdatePackage(packageName) {
                     '    ' +
                     t('display_latest_esa_template_version').d(`Latest esa-template version:`) +
                     chalk.green(latestVersion));
-                const { isUpdate } = yield inquirer.prompt({
-                    type: 'confirm',
-                    name: 'isUpdate',
+                logger.stopSpinner();
+                const isUpdate = yield clackConfirm({
                     message: t('is_update_to_latest_version').d('Do you want to update templates to latest version?')
                 });
-                if (isUpdate) {
+                if (!isCancel(isUpdate) && isUpdate) {
                     spinner.start(t('template_updating').d('Updating templates to latest...'));
                     execSync(`rm -rf node_modules/${packageName}`, {
                         cwd: packageJsonPath
@@ -185,3 +189,475 @@ export const getAllFrameworkConfig = () => {
     const json = JSON.parse(jsonc);
     return json;
 };
+export function getInitParamsFromArgv(argv) {
+    const a = argv;
+    const HaikunatorCtor = Haikunator;
+    const haikunator = new HaikunatorCtor();
+    const params = {
+        name: ''
+    };
+    if (a.yes) {
+        params.name = haikunator.haikunate();
+        params.git = true;
+        params.deploy = true;
+        params.template = 'Hello World';
+        params.framework = undefined;
+        params.language = undefined;
+        params.yes = true;
+    }
+    if (typeof a.name === 'string')
+        params.name = a.name;
+    if (typeof a.template === 'string' && a.template) {
+        params.template = a.template;
+        params.framework = undefined;
+        params.language = undefined;
+    }
+    else {
+        const fw = a.framework;
+        const lang = a.language;
+        if (fw) {
+            params.framework = fw;
+        }
+        if (lang) {
+            params.language = lang;
+        }
+    }
+    if (typeof a.git === 'boolean')
+        params.git = Boolean(a.git);
+    if (typeof a.deploy === 'boolean')
+        params.deploy = Boolean(a.deploy);
+    return params;
+}
+// 配置项目名称
+export const configProjectName = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    if (initParams.name) {
+        log.step(`Project name configured ${initParams.name}`);
+        return;
+    }
+    const name = (yield promptParameter({
+        type: 'text',
+        question: `${t('init_input_name').d('Enter the name of edgeRoutine:')}`,
+        label: 'Project name',
+        validate: (input) => {
+            const regex = /^[a-z0-9-]{2,}$/;
+            if (!regex.test(input)) {
+                return t('init_name_error').d('Error: The project name must be at least 2 characters long and can only contain lowercase letters, numbers, and hyphens.');
+            }
+            return true;
+        }
+    }));
+    initParams.name = name;
+});
+export const configCategory = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    if (initParams.category || initParams.framework || initParams.template) {
+        return;
+    }
+    const initMode = (yield promptParameter({
+        type: 'select',
+        question: 'How would you like to initialize the project?',
+        label: 'Init mode',
+        choices: [
+            { name: 'Framework Starter', value: 'framework' },
+            {
+                name: 'Function Template',
+                value: 'template'
+            }
+        ]
+    }));
+    initParams.category = initMode;
+});
+/*
+选择模板
+如果选择的是framework，则选择具体的模版 vue /react等
+如果选择的是template，则选择具体的模版 esa template
+*/
+export const configTemplate = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    if (initParams.template) {
+        log.step(`Template configured ${initParams.template}`);
+        return;
+    }
+    if (initParams.framework) {
+        log.step(`Framework configured ${initParams.framework}`);
+        return;
+    }
+    if (initParams.category === 'template') {
+        const templateItems = prepareTemplateItems();
+        const selectedTemplatePath = yield promptParameter({
+            type: 'multiLevelSelect',
+            question: 'Select a template:',
+            treeItems: templateItems
+        });
+        if (!selectedTemplatePath)
+            return null;
+        // TODO
+        initParams.template = selectedTemplatePath;
+    }
+    else {
+        const allFrameworkConfig = getAllFrameworkConfig();
+        const fw = (yield promptParameter({
+            type: 'select',
+            question: 'Select a framework',
+            label: 'Framework',
+            choices: Object.keys(allFrameworkConfig).map((fw) => {
+                var _a;
+                return ({
+                    name: allFrameworkConfig[fw].label,
+                    value: fw,
+                    hint: (_a = allFrameworkConfig[fw]) === null || _a === void 0 ? void 0 : _a.hint
+                });
+            })
+        }));
+        initParams.framework = fw;
+    }
+});
+export const configLanguage = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    if (initParams.language) {
+        log.info(`Language configured ${initParams.language}`);
+        return;
+    }
+    const framework = initParams.framework;
+    if (!framework) {
+        log.info('Framework config not configured, language skipped');
+        return;
+    }
+    const frameworkConfig = getFrameworkConfig(framework);
+    if (frameworkConfig.language) {
+        const language = (yield promptParameter({
+            type: 'select',
+            question: t('init_language_select').d('Select programming language:'),
+            label: 'Language',
+            choices: [
+                {
+                    name: t('init_language_typescript').d('TypeScript (.ts) - Type-safe JavaScript, recommended'),
+                    value: 'typescript'
+                },
+                {
+                    name: t('init_language_javascript').d('JavaScript (.js) - Traditional JavaScript'),
+                    value: 'javascript'
+                }
+            ],
+            defaultValue: 'typescript'
+        }));
+        initParams.language = language;
+    }
+});
+export const createProject = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (initParams.template) {
+        // resolve template value: it may be a filesystem path or a template title
+        let selectedTemplatePath = initParams.template;
+        if (!path.isAbsolute(selectedTemplatePath) ||
+            !fs.existsSync(selectedTemplatePath)) {
+            const instances = getTemplateInstances(templateHubPath);
+            const matched = instances.find((it) => it.title === initParams.template);
+            if (matched) {
+                selectedTemplatePath = matched.path;
+            }
+        }
+        if (!fs.existsSync(selectedTemplatePath)) {
+            outro(`Project creation failed: cannot resolve template "${initParams.template}"`);
+            exit(1);
+        }
+        const res = yield initializeProject(selectedTemplatePath, initParams.name);
+        if (!res) {
+            outro(`Project creation failed`);
+            exit(1);
+        }
+    }
+    if (initParams.framework) {
+        const framework = initParams.framework;
+        const frameworkConfig = getFrameworkConfig(framework);
+        const command = frameworkConfig.command;
+        const templateFlag = ((_a = frameworkConfig.language) === null || _a === void 0 ? void 0 : _a[initParams.language || 'typescript']) || '';
+        const extraParams = frameworkConfig.params || '';
+        const full = `${command} ${initParams.name} ${templateFlag} ${extraParams}`.trim();
+        const res = yield execCommand(['sh', '-lc', full], {
+            interactive: true,
+            startText: `Starting to execute framework command: ${chalk.gray(full)}`,
+            doneText: `Framework command executed: ${chalk.bold(full)}`
+        });
+        if (!res.success) {
+            outro(`Framework command execution failed`);
+            exit(1);
+        }
+    }
+});
+export const installDependencies = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    if (initParams.template) {
+        return;
+    }
+    const targetPath = path.join(process.cwd(), initParams.name);
+    const res = yield execCommand(['npm', 'install'], {
+        cwd: targetPath,
+        useSpinner: true,
+        silent: true,
+        startText: 'Installing dependencies',
+        doneText: 'Dependencies installed'
+    });
+    if (!res.success) {
+        outro(`Dependencies installation failed`);
+        exit(1);
+    }
+});
+/**
+ * Apply configured file edits (方式1: overwrite) after project scaffold
+ */
+export const applyFileEdits = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (!initParams.framework) {
+        return true;
+    }
+    const frameworkConfig = getFrameworkConfig(initParams.framework || '');
+    const edits = frameworkConfig.fileEdits || [];
+    if (!edits.length)
+        return true;
+    logger.startSubStep(`Applying file edits`);
+    const __dirname = getDirName(import.meta.url);
+    try {
+        const toRegexFromGlob = (pattern) => {
+            // Very small glob subset: *, ?, {a,b,c}
+            let escaped = pattern
+                .replace(/[-/\\^$+?.()|[\]{}]/g, '\\$&') // escape regex specials first
+                .replace(/\\\*/g, '.*')
+                .replace(/\\\?/g, '.');
+            // restore and convert {a,b} to (a|b)
+            escaped = escaped.replace(/\\\{([^}]+)\\\}/g, (_, inner) => {
+                const parts = inner.split(',').map((s) => s.trim());
+                return `(${parts.join('|')})`;
+            });
+            return new RegExp('^' + escaped + '$');
+        };
+        const targetPath = path.join(process.cwd(), initParams.name);
+        const listRootFiles = () => {
+            try {
+                return fs.readdirSync(targetPath);
+            }
+            catch (_a) {
+                return [];
+            }
+        };
+        for (const edit of edits) {
+            if (((_a = edit.when) === null || _a === void 0 ? void 0 : _a.language) && initParams.language) {
+                if (edit.when.language !== initParams.language)
+                    continue;
+            }
+            const createIfMissing = edit.createIfMissing !== false;
+            let matchedFiles = [];
+            if (edit.matchType === 'exact') {
+                matchedFiles = [edit.match];
+            }
+            else if (edit.matchType === 'glob') {
+                const regex = toRegexFromGlob(edit.match);
+                matchedFiles = listRootFiles().filter((name) => regex.test(name));
+            }
+            else if (edit.matchType === 'regex') {
+                const regex = new RegExp(edit.match);
+                matchedFiles = listRootFiles().filter((name) => regex.test(name));
+            }
+            // if no matched files and allowed to create, provide a reasonable default for common patterns
+            if (!matchedFiles.length && createIfMissing) {
+                if (edit.matchType === 'exact') {
+                    matchedFiles = [edit.match];
+                }
+                else if (edit.matchType === 'glob' &&
+                    /next\.config\.\{.*\}/.test(edit.match)) {
+                    matchedFiles = ['next.config.ts'];
+                }
+            }
+            if (!matchedFiles.length)
+                continue;
+            // resolve content
+            let payload = null;
+            if (edit.fromFile) {
+                const absFrom = path.isAbsolute(edit.fromFile)
+                    ? edit.fromFile
+                    : path.join(__dirname, edit.fromFile);
+                payload = fs.readFileSync(absFrom, 'utf-8');
+            }
+            else if (typeof edit.content === 'string') {
+                payload = edit.content;
+            }
+            for (const rel of matchedFiles) {
+                const abs = path.join(targetPath, rel);
+                if (payload == null)
+                    continue;
+                fs.ensureDirSync(path.dirname(abs));
+                fs.writeFileSync(abs, payload, 'utf-8');
+            }
+        }
+        logger.endSubStep('File edits applied');
+        return true;
+    }
+    catch (_b) {
+        outro(`File edits application failed`);
+        exit(1);
+    }
+});
+export const installESACli = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    const targetPath = path.join(process.cwd(), initParams.name);
+    const res = yield execCommand(['npm', 'install', '-D', 'esa-cli'], {
+        cwd: targetPath,
+        useSpinner: true,
+        silent: true,
+        startText: 'Installing ESA CLI',
+        doneText: 'ESA CLI installed in the project'
+    });
+    if (!res.success) {
+        outro(`ESA CLI installation failed`);
+        exit(1);
+    }
+});
+export const updateConfigFile = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const targetPath = path.join(process.cwd(), initParams.name);
+    const configFormat = 'jsonc';
+    logger.startSubStep(`Updating config file`);
+    try {
+        if (initParams.framework) {
+            const frameworkConfig = getFrameworkConfig(initParams.framework);
+            const assetsDirectory = (_a = frameworkConfig.assets) === null || _a === void 0 ? void 0 : _a.directory;
+            const notFoundStrategy = (_b = frameworkConfig.assets) === null || _b === void 0 ? void 0 : _b.notFoundStrategy;
+            yield generateConfigFile(initParams.name, {
+                assets: assetsDirectory ? { directory: assetsDirectory } : undefined
+            }, targetPath, configFormat, notFoundStrategy);
+        }
+        else {
+            // TODO revise template config file later
+            // console.log(
+            //   'test:',
+            //   initParams.name,
+            //   undefined,
+            //   targetPath,
+            //   configFormat
+            // );
+            // logger.startSubStep(`Updating config file`);
+            // await generateConfigFile(initParams.name, undefined, targetPath, 'toml');
+        }
+        logger.endSubStep('Config file updated');
+    }
+    catch (_c) {
+        outro(`Config file update failed`);
+        exit(1);
+    }
+});
+export const initGit = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    const frameworkConfig = getFrameworkConfig(initParams.framework || '');
+    if ((frameworkConfig === null || frameworkConfig === void 0 ? void 0 : frameworkConfig.useGit) === false) {
+        log.step('Git skipped');
+        return true;
+    }
+    const gitInstalled = yield isGitInstalled();
+    if (!gitInstalled) {
+        log.step('You have not installed Git, Git skipped');
+        return true;
+    }
+    if (!initParams.git) {
+        const initGit = (yield promptParameter({
+            type: 'confirm',
+            question: t('init_git').d('Do you want to init git in your project?'),
+            label: 'Init git',
+            defaultValue: false
+        }));
+        initParams.git = initGit;
+    }
+    if (initParams.git) {
+        const targetPath = path.join(process.cwd(), initParams.name);
+        const res = yield execCommand(['git', 'init'], {
+            cwd: targetPath
+        });
+        if (!res.success) {
+            outro(`Git initialization failed`);
+            exit(1);
+        }
+    }
+    return true;
+});
+export function getGitVersion() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const stdout = yield execCommand(['git', '--version'], {
+                useSpinner: false,
+                silent: true,
+                captureOutput: true
+            });
+            const gitVersion = stdout.stdout.replace(/^git\s+version\s+/, '');
+            return gitVersion;
+        }
+        catch (_a) {
+            log.error('Failed to get Git version');
+            return null;
+        }
+    });
+}
+export function isGitInstalled() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield getGitVersion()) !== null;
+    });
+}
+export const buildProject = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    if (initParams.template) {
+        return;
+    }
+    const targetPath = path.join(process.cwd(), initParams.name);
+    const res = yield execCommand(['npm', 'run', 'build'], {
+        useSpinner: true,
+        silent: true,
+        startText: 'Building project',
+        doneText: 'Project built',
+        cwd: targetPath
+    });
+    if (!res.success) {
+        outro(`Build project failed`);
+        exit(1);
+    }
+});
+export function prepareTemplateItems() {
+    var _a;
+    const templateInstanceList = getTemplateInstances(templateHubPath);
+    const templateConfig = getTemplatesConfig();
+    const cliConfig = getCliConfig();
+    const lang = (_a = cliConfig === null || cliConfig === void 0 ? void 0 : cliConfig.lang) !== null && _a !== void 0 ? _a : 'en';
+    return transferTemplatesToSelectItem(templateConfig, templateInstanceList, lang);
+}
+export const deployProject = (initParams) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!initParams.deploy) {
+        log.step('Deploy project skipped');
+        return;
+    }
+    const targetPath = path.join(process.cwd(), initParams.name);
+    const res = yield commitAndDeployVersion(initParams.name, undefined, undefined, 'Init project', targetPath, 'all');
+    if (!res) {
+        outro(`Deploy project failed`);
+        exit(1);
+    }
+});
+export function initializeProject(selectedTemplatePath, name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const selectTemplate = new Template(selectedTemplatePath, name);
+        const projectConfig = getProjectConfig(selectedTemplatePath);
+        if (!projectConfig) {
+            logger.notInProject();
+            return null;
+        }
+        const targetPath = path.join(process.cwd(), name);
+        if (fs.existsSync(targetPath)) {
+            logger.block();
+            logger.tree([
+                `${chalk.bgRed(' ERROR ')} ${chalk.bold.red(t('init_abort').d('Initialization aborted'))}`,
+                `${chalk.gray(t('reason').d('Reason:'))} ${chalk.red(t('dir_already_exists').d('Target directory already exists'))}`,
+                `${chalk.gray(t('path').d('Path:'))} ${chalk.cyan(targetPath)}`,
+                chalk.gray(t('try').d('Try one of the following:')),
+                `- ${chalk.white(t('try_diff_name').d('Choose a different project name'))}`,
+                `- ${chalk.white(t('try_remove').d('Remove the directory:'))} ${chalk.yellow(`rm -rf "${name}”`)}`,
+                `- ${chalk.white(t('try_another_dir').d('Run the command in another directory'))}`
+            ]);
+            logger.block();
+            return null;
+        }
+        yield fs.copy(selectedTemplatePath, targetPath);
+        projectConfig.name = name;
+        yield updateProjectConfigFile(projectConfig, targetPath);
+        yield preInstallDependencies(targetPath);
+        return { template: selectTemplate, targetPath };
+    });
+}