@deot/dev-cli 1.0.8 → 1.1.1

package/dist/index.es.js

@@ -1,1132 +1,11 @@
 import { program } from 'commander';
 import { createRequire } from 'node:module';
-import chalk from 'chalk';
-import ora from 'ora';
-import { Utils, Logger, Shell } from '@deot/dev-shared';
-import * as path from 'node:path';
-import { resolve } from 'node:path';
-import fs from 'fs-extra';
-import inquirer from 'inquirer';
-import autocomplete from 'inquirer-autocomplete-prompt';
-import typescript from '@rollup/plugin-typescript';
-import { nodeResolve } from '@rollup/plugin-node-resolve';
-import commonjs from '@rollup/plugin-commonjs';
-import replace from '@rollup/plugin-replace';
-import { rollup } from 'rollup';
-import { Extractor, ExtractorConfig } from '@microsoft/api-extractor';
-import parser from 'conventional-commits-parser';
-import semver from 'semver';
-
-const cwd = process.cwd();
-const require$$2 = createRequire(cwd);
-class Shared {
-    static config;
-    static getNormalizePackage = (dataMap) => {
-        Object.keys(dataMap).forEach(packageName => {
-            const relations = dataMap[packageName];
-            relations.forEach((packageName$) => {
-                if (dataMap[packageName$].includes(packageName)) {
-                    throw new Error(`${packageName} ${packageName$} deps loop`);
-                }
-            });
-        });
-        const needUseMap = Object.keys(dataMap).reduce((pre, key) => (pre[key] = 0, pre), {});
-        const queue = [];
-        for (let key in dataMap) {
-            const dependencies = dataMap[key];
-            dependencies.forEach((dependency) => {
-                needUseMap[dependency] += 1;
-            });
-        }
-        for (let key in needUseMap) {
-            if (needUseMap[key] === 0) {
-                queue.push(key);
-            }
-        }
-        const result = [];
-        while (queue.length > 0) {
-            const node = queue.shift();
-            if (!node)
-                return [];
-            result.push(node);
-            const dependencies = dataMap[node];
-            for (let i = 0; i < dependencies.length; i++) {
-                const dependency = dependencies[i];
-                needUseMap[dependency] -= 1;
-                if (needUseMap[dependency] === 0) {
-                    queue.push(dependency);
-                }
-            }
-        }
-        return result.reverse();
-    };
-    static getPackageName = (packageFolderName$) => {
-        const { workspace, packageFolderName, packageName } = Shared.impl();
-        if (!workspace
-            || !packageFolderName$
-            || packageFolderName$ === packageFolderName) {
-            return packageName;
-        }
-        else {
-            return `${packageName}-${packageFolderName$.replace(new RegExp(`${packageName}-?`), '')}`;
-        }
-    };
-    static getPackageFolderName = (packageName$) => {
-        const { workspace, packageFolderName, packageName } = Shared.impl();
-        if (!workspace)
-            return '';
-        if (packageName$ === packageName)
-            return packageFolderName;
-        return packageName$?.replace(new RegExp(`${packageName}-?`), '');
-    };
-    static impl() {
-        if (Shared.config)
-            return Shared.config;
-        const rootPackageOptions = require$$2(`${cwd}/package.json`);
-        let workspace = 'packages';
-        let isMonorepo = fs.existsSync(path.resolve(cwd, workspace));
-        workspace = isMonorepo ? workspace : '';
-        const packageFolderName = isMonorepo ? 'index' : '';
-        const packageDir = path.resolve(cwd, workspace);
-        const packageOptions = require$$2(path.resolve(packageDir, packageFolderName, 'package.json'));
-        const packageName = packageOptions.name;
-        const packageVersion = packageOptions.version;
-        const packageFolderNames = !isMonorepo ? [] : fs
-            .readdirSync(packageDir)
-            .reduce((pre, file) => {
-            const fullpath = path.resolve(packageDir, file);
-            const stat = fs.statSync(fullpath);
-            if (!(/(^_|tpl)/.test(file))
-                && stat.isDirectory()) {
-                pre.push(file);
-            }
-            return pre;
-        }, []);
-        const packageOptionsMap = packageFolderNames.reduce((pre, packageFolderName$) => {
-            pre[packageFolderName$] = require$$2(path.resolve(packageDir, packageFolderName$, 'package.json'));
-            return pre;
-        }, {});
-        const packageDirsMap = packageFolderNames.reduce((pre, packageFolderName$) => {
-            pre[packageFolderName$] = path.resolve(packageDir, packageFolderName$);
-            return pre;
-        }, {});
-        const packageRelation = packageFolderNames.reduce((pre, packageFolderName$) => {
-            let packagesOptions = packageOptionsMap[packageFolderName$];
-            let deps = {
-                ...(packagesOptions.dependencies || {}),
-                ...(packagesOptions.devDependencies || {}),
-            };
-            pre[packagesOptions.name] = Object.keys(deps).filter(i => new RegExp(`${packageName}`).test(i));
-            return pre;
-        }, {});
-        const normalizePackageNames = Shared.getNormalizePackage(packageRelation);
-        const normalizePackageFolderNames = normalizePackageNames
-            .map(i => i.replace(new RegExp(`${packageName}-?`), '') || packageFolderName);
-        const homepage = (rootPackageOptions.repository || packageOptions.repository || {}).url || '';
-        const config = {
-            cwd,
-            workspace,
-            homepage: homepage.replace(/(.*)(https?:\/\/.*)(#|\.git)/, '$2'),
-            packageFolderName,
-            packageDir,
-            packageOptions,
-            packageName,
-            packageVersion,
-            packageFolderNames,
-            packageOptionsMap,
-            packageDirsMap,
-            packageRelation,
-            normalizePackageNames,
-            normalizePackageFolderNames
-        };
-        Shared.config = config;
-        return config;
-    }
-}
-
-const run$5 = (options) => Utils.autoCatch(async () => {
-    const locals = Shared.impl();
-    const { workspace, packageFolderNames } = locals;
-    if (!workspace) {
-        return Logger.log(`<link> Monorepo Supported Only.`);
-    }
-    if (typeof options.dryRun === 'undefined') {
-        options.dryRun = process.env.NODE_ENV === 'UNIT';
-    }
-    const command = `npx pnpm link ./${workspace}/`;
-    if (options.dryRun)
-        return Shell.spawn(`echo ${command}`);
-    const spinner = ora(`Links ...\n`);
-    spinner.start();
-    await Promise.all(packageFolderNames.map(i => {
-        return Shell.spawn(`${command}${i}`);
-    }));
-    spinner.stop();
-    Logger.log(`${chalk.green('Links Success')}`);
-});
-
-const { prompt: prompt$2, registerPrompt: registerPrompt$1, Separator } = inquirer;
-const getOptions$1 = async () => {
-    const { packageFolderNames } = Shared.impl();
-    const question = [
-        {
-            type: 'list',
-            name: 'mode',
-            message: 'Select Mode:',
-            choices: [
-                new Separator('选择添加的类型：'),
-                'dependent',
-                'package'
-            ],
-            default: 'package'
-        },
-        {
-            type: 'autocomplete',
-            message: 'Select Package To Install:',
-            when: (answers) => answers.mode === 'dependent',
-            name: 'packageFolderName',
-            default: 'index',
-            source: (_, input) => {
-                input = input || '';
-                return new Promise(($resolve => {
-                    let filter = input
-                        ? packageFolderNames.filter(item => item.includes(input))
-                        : packageFolderNames;
-                    $resolve(filter);
-                }));
-            }
-        },
-        {
-            type: 'input',
-            name: 'dependentName',
-            message: 'Input Dependent Name',
-            default: '',
-            when: (answers) => answers.mode === 'dependent',
-            validate: (answer) => {
-                if (!answer) {
-                    return '请输入需要添加的模块名';
-                }
-                return true;
-            }
-        },
-        {
-            type: 'list',
-            name: 'args',
-            when: (answers) => answers.mode === 'dependent',
-            message: 'Select Install Mode:',
-            choices: [
-                '-S',
-                '-D',
-                '-O'
-            ]
-        },
-        {
-            type: 'input',
-            name: 'packageFolderName',
-            message: 'Input Package Name',
-            default: '',
-            when: (answers) => answers.mode === 'package',
-            validate: (answer) => {
-                if (!answer) {
-                    return '请输入需要添加的包名';
-                }
-                if (packageFolderNames.includes(answer) || answer === 'dev') {
-                    return '包名已存在';
-                }
-                return true;
-            }
-        }
-    ];
-    registerPrompt$1('autocomplete', autocomplete);
-    let result = await prompt$2(question);
-    if (result.mode == 'dependent') {
-        result.packageName = Shared.getPackageName(result.packageFolderName);
-    }
-    if (result.mode == 'package') {
-        result.packageName = Shared.getPackageName(result.packageFolderName);
-    }
-    result.args = [result.args];
-    return result;
-};
-
-const run$4 = (options) => Utils.autoCatch(async () => {
-    const locals = Shared.impl();
-    const { workspace, packageDir } = locals;
-    if (!workspace) {
-        return Logger.log(`<add> Monorepo Supported Only.`);
-    }
-    if (typeof options.dryRun === 'undefined') {
-        options.dryRun = process.env.NODE_ENV === 'UNIT';
-    }
-    const { mode, dependentName, args, packageFolderName, packageName } = await getOptions$1();
-    let command = mode === 'dependent'
-        ? `npx pnpm add --filter ${packageName} ${dependentName} ${args.join(' ')}`
-        : `npx pnpm link ./${workspace}/${packageFolderName}`;
-    if (options.dryRun)
-        return Shell.spawn(`echo "${command}"`);
-    const spinner = ora(`${command}\n`).start();
-    await Shell.spawn(command);
-    spinner.stop();
-    if (mode === 'package') {
-        let dir = resolve(packageDir);
-        fs.outputFileSync(`${dir}/${packageFolderName}/README.md`, '// TODO');
-        fs.outputFileSync(`${dir}/${packageFolderName}/src/index.ts`, '// TODO');
-        fs.outputFileSync(`${dir}/${packageFolderName}/__tests__/index.spec.ts`, '// TODO');
-        fs.outputFileSync(`${dir}/${packageFolderName}/package.json`, JSON.stringify({
-            name: packageName,
-            version: '1.0.0',
-            main: 'dist/index.js',
-            types: "dist/index.d.ts",
-            type: "module",
-            files: [
-                "dist"
-            ],
-            license: 'MIT',
-            publishConfig: {
-                access: 'public'
-            },
-            dependencies: {}
-        }, null, 2));
-        fs.outputFileSync(`${dir}/${packageFolderName}/api-extractor.json`, JSON.stringify({
-            extends: "../../api-extractor.json",
-            mainEntryPointFilePath: `./dist/${workspace}/${packageFolderName}/src/index.d.ts`,
-            dtsRollup: {
-                publicTrimmedFilePath: "./dist/index.d.ts"
-            }
-        }, null, 2));
-    }
-    await Shell.spawn(command);
-});
-
-const ALL_PACKAGE = 'All Packages';
-const { prompt: prompt$1, registerPrompt } = inquirer;
-const getOptions = async () => {
-    const isDev = process.env.NODE_ENV === 'development';
-    const { packageFolderNames } = Shared.impl();
-    const packages$ = [ALL_PACKAGE, ...packageFolderNames];
-    const question = [
-        {
-            type: 'autocomplete',
-            message: `Select Package To ${isDev ? 'Develop' : 'Test'}:`,
-            name: 'packageFolderName',
-            default: 'cli',
-            source: (_, input) => {
-                input = input || '';
-                return new Promise(($resolve => {
-                    let filter = input
-                        ? packages$.filter(item => item.includes(input))
-                        : packages$;
-                    $resolve(filter);
-                }));
-            }
-        },
-        {
-            type: 'confirm',
-            message: 'Watch Mode?',
-            name: 'watch',
-            when: () => !isDev,
-            default: (answers) => {
-                return answers.packageFolderName !== ALL_PACKAGE;
-            }
-        }
-    ];
-    registerPrompt('autocomplete', autocomplete);
-    let result = await prompt$1(question);
-    result.packageFolderName = result.packageFolderName == ALL_PACKAGE
-        ? undefined
-        : result.packageFolderName;
-    result.watch = result.watch || isDev;
-    return result;
-};
-
-const run$3 = (options) => Utils.autoCatch(async () => {
-    const locals = Shared.impl();
-    if (typeof options.dryRun === 'undefined') {
-        options.dryRun = process.env.NODE_ENV === 'UNIT';
-    }
-    if (locals.workspace && !options.packageName) {
-        const promptOptions = await getOptions();
-        options = {
-            ...options,
-            ...promptOptions
-        };
-    }
-    const { cwd, workspace, packageOptionsMap, packageDirsMap } = locals;
-    const { packageName, watch, dryRun } = options;
-    options.packageFolderName = Shared.getPackageFolderName(options.packageName) || options.packageFolderName;
-    options.workspace = workspace;
-    const packageOptions = packageOptionsMap[options.packageFolderName];
-    const packageDir = packageDirsMap[options.packageFolderName];
-    if (workspace
-        && cwd !== packageDir
-        && packageOptions?.scripts?.['test']) {
-        await Shell.spawn(`npm`, ['run', 'test']);
-        return;
-    }
-    if (!options.packageFolderName)
-        delete options.packageFolderName;
-    if (!options.workspace)
-        delete options.workspace;
-    delete options.packageName;
-    const command = `cross-env NODE_ENV=${process.env.NODE_ENV || 'TEST'} TEST_OPTIONS=${encodeURIComponent(JSON.stringify(options))} jest `
-        + ([
-            '--passWithNoTests',
-            `${watch ? '--watchAll' : ''}`
-        ].join(' '));
-    if (dryRun)
-        return Shell.spawn(`echo ${command}`);
-    await Shell.spawn(command);
-    if (!watch)
-        return;
-    Logger.log(packageName || '', '测试已通过');
-}, {
-    onError: (e) => {
-        if (typeof e === 'number' && e === 1) {
-            Logger.error('测试未通过');
-        }
-        else {
-            Logger.error(e);
-        }
-        process.exit(1);
-    }
-});
-
-const run$2 = (options) => Utils.autoCatch(async () => {
-    const locals = Shared.impl();
-    if (typeof options.dryRun === 'undefined') {
-        options.dryRun = process.env.NODE_ENV === 'UNIT';
-    }
-    if (options.dryRun)
-        return Shell.spawn(`echo development`);
-    const { cwd, workspace, packageOptionsMap, packageDirsMap } = locals;
-    const { packageName } = options;
-    const getPackageFolderName = Shared.getPackageFolderName(packageName);
-    const packageOptions = packageOptionsMap[getPackageFolderName];
-    const packageDir = packageDirsMap[getPackageFolderName];
-    options.watch = true;
-    if (!workspace
-        && packageName
-        && packageName !== '**'
-        && cwd !== packageDir
-        && packageOptions?.scripts?.['dev']) {
-        await Shell.spawn(`npm`, ['run', 'dev']);
-        return;
-    }
-    await Shell.spawn(`cross-env`, [
-        'NODE_ENV=development',
-        'npm',
-        'run',
-        'test',
-        '--',
-        packageName ? `--package-name ${packageName}` : ''
-    ]);
-});
-
-const require$$1 = createRequire(import.meta.url);
-class Builder {
-    packageDir;
-    packageName;
-    packageOptions;
-    config;
-    commandOptions;
-    constructor(config, commandOptions) {
-        const { workspace, packageDir, packageName } = Shared.impl();
-        if (typeof config === 'string') {
-            let packageFolderName = config;
-            let packageDir$ = path.resolve(packageDir, packageFolderName);
-            config = {
-                dir: packageDir$,
-                name: packageFolderName || 'index',
-                input: packageDir$ + '/src/index.ts',
-                output: [
-                    {
-                        file: packageDir$ + '/dist/index.es.js',
-                        format: 'es',
-                        exports: 'named',
-                        sourcemap: false
-                    },
-                    {
-                        file: packageDir$ + '/dist/index.iife.js',
-                        format: 'iife',
-                        name: packageName,
-                    },
-                    {
-                        file: packageDir$ + '/dist/index.cjs.js',
-                        format: 'cjs'
-                    }
-                ].filter(i => {
-                    return commandOptions.output.includes(i.format);
-                })
-            };
-        }
-        this.packageDir = path.resolve(packageDir, workspace ? `./${config.name}` : '');
-        this.packageName = config.name === 'index'
-            ? packageName
-            : `${packageName}-${config.name}`;
-        this.packageOptions = require$$1(`${this.packageDir}/package.json`);
-        this.config = config;
-        this.commandOptions = commandOptions;
-    }
-    async process() {
-        const { cwd, workspace } = Shared.impl();
-        const { packageOptions, packageName, packageDir } = this;
-        if (workspace
-            && packageOptions?.scripts?.build
-            && packageDir !== cwd) {
-            await Shell.spawn(`npm`, ['run', 'build'], {
-                cwd: packageDir
-            });
-            return;
-        }
-        const spinner = ora(`${packageName} Build ...`);
-        try {
-            spinner.start();
-            await fs.emptyDir(`${packageDir}/dist`);
-            const stats = await this.buildSources();
-            await this.buildTypes();
-            spinner.stop();
-            Logger.log(`${chalk.cyan(`${packageName}`)}: ${chalk.green('Success')}`);
-            stats.forEach((stat) => {
-                Logger.log(`${chalk.green(stat.format.toUpperCase())}: ${Utils.formatBytes(stat.size)}`);
-            });
-        }
-        catch (e) {
-            Logger.log('Error!', e);
-            throw e;
-        }
-    }
-    async buildSources() {
-        const { workspace } = Shared.impl();
-        const { name, input, output } = this.config;
-        const { packageOptions } = this;
-        const external = Object
-            .keys({
-            ...packageOptions.dependencies,
-            ...packageOptions.peerDependencies
-        })
-            .map(i => new RegExp(`^${i}$`));
-        const source = workspace ? `${workspace}/${name}/**/*` : 'src/**/*';
-        const shims = workspace ? `${workspace}/shims.d.ts` : 'shims.d.ts';
-        const outDir = workspace ? `${workspace}/${name}/dist` : 'dist';
-        const builder = await rollup({
-            input,
-            external: [
-                /^node:/,
-                /^[a-zA-Z@]/,
-                ...external
-            ],
-            plugins: [
-                typescript({
-                    include: [source, shims],
-                    exclude: ['dist'],
-                    compilerOptions: {
-                        rootDir: '.',
-                        outDir,
-                        declaration: true
-                    }
-                }),
-                commonjs({ extensions: ['.js', '.ts'] }),
-                nodeResolve(),
-                replace({
-                    '1.0.6': `'${packageOptions.version}'`,
-                    false: 'false',
-                    true: true
-                })
-            ]
-        });
-        await Promise.all(output.map(builder.write));
-        const stats = [];
-        await output.reduce((pre, cur, index) => {
-            pre
-                .then(() => fs.stat(cur.file))
-                .then((stat) => {
-                stats[index] = {
-                    format: cur.format,
-                    size: stat.size
-                };
-            });
-            return pre;
-        }, Promise.resolve());
-        return stats;
-    }
-    async buildTypes() {
-        const { workspace } = Shared.impl();
-        const { packageDir, packageOptions } = this;
-        if (workspace && packageOptions?.scripts?.['build:types']) {
-            await Shell.spawn(`npm`, ['run', 'build:types'], {
-                cwd: packageDir
-            });
-            return;
-        }
-        const config = path.resolve(packageDir, `api-extractor.json`);
-        if (fs.existsSync(config)) {
-            const result = Extractor.invoke(ExtractorConfig.loadFileAndPrepare(config), {
-                localBuild: true,
-                showVerboseMessages: false
-            });
-            if (!result.succeeded) {
-                Logger.error(`API Extractor completed with ${result.errorCount} errors and ${result.warningCount} warnings`);
-                process.exitCode = 1;
-            }
-        }
-        await fs.remove(`${packageDir}/dist/${workspace || 'src'}`);
-    }
-}
-const builder = (options, commandOptions) => {
-    return new Builder(options, commandOptions);
-};
-
-const run$1 = (options) => Utils.autoCatch(async () => {
-    const locals = Shared.impl();
-    if (typeof options.dryRun === 'undefined') {
-        options.dryRun = process.env.NODE_ENV === 'UNIT';
-    }
-    const { normalizePackageFolderNames } = Shared.impl();
-    let packageFolderName = Shared.getPackageFolderName(options.packageName || '**');
-    let inputs = [];
-    if (locals.workspace && packageFolderName === '**') {
-        inputs = normalizePackageFolderNames;
-    }
-    else {
-        inputs = [packageFolderName];
-    }
-    if (options.dryRun)
-        return Shell.spawn(`echo ${inputs.join(' ')}`);
-    await inputs
-        .reduce((preProcess, packageFolderName$) => {
-        preProcess = preProcess.then(() => builder(packageFolderName$, options).process());
-        return preProcess;
-    }, Promise.resolve());
-}, {
-    onError: (e) => {
-        if (typeof e === 'number' && e === 1) {
-            Logger.error('编译未通过');
-        }
-        else {
-            Logger.error(e);
-        }
-        process.exit(1);
-    }
-});
-
-const require$ = createRequire(import.meta.url);
-const { prompt } = inquirer;
-const HASH = '-hash-';
-const SUFFIX = '🐒💨🙊';
-const parserOptions = {
-    noteKeywords: ['BREAKING CHANGE', 'Breaking Change']
-};
-const reBreaking = new RegExp(`(${parserOptions.noteKeywords.join(')|(')})`);
-class Releaser {
-    packageDir;
-    packageName;
-    packageFolderName;
-    packageOptions;
-    packageRelation;
-    config;
-    changeLog;
-    version;
-    commits;
-    commandOptions;
-    constructor(config, commandOptions) {
-        const { packageDir, packageRelation } = Shared.impl();
-        if (typeof config === 'string') {
-            let packageFolderName = config;
-            let packageDir$ = path.resolve(packageDir, packageFolderName);
-            config = {
-                dir: packageDir$,
-                name: packageFolderName
-            };
-        }
-        this.packageDir = config.dir;
-        this.packageName = Shared.getPackageName(config.name);
-        this.packageFolderName = config.name;
-        this.packageOptions = require$(`${this.packageDir}/package.json`);
-        this.packageRelation = packageRelation[this.packageName] || [];
-        this.config = config;
-        this.commits = [];
-        this.changeLog = '';
-        this.version = '';
-        this.commandOptions = commandOptions;
-    }
-    async parseCommits() {
-        const { workspace } = Shared.impl();
-        const { packageFolderName, packageName, commandOptions } = this;
-        let params = ['tag', '--list', `'${packageName}@*'`, '--sort', '-v:refname'];
-        const { stdout: tags } = await Shell.exec('git', params);
-        const [latestTag] = tags.split('\n');
-        Logger.log(chalk.yellow(`Last Release Tag`) + `: ${latestTag || '<none>'}`);
-        params = ['--no-pager', 'log', `${latestTag}..HEAD`, `--format=%B%n${HASH}%n%H${SUFFIX}`];
-        let { stdout } = await Shell.exec('git', params);
-        let skipGetLog = false;
-        if (latestTag) {
-            const log1 = await Shell.exec('git', ['rev-parse', latestTag]);
-            const log2 = await Shell.exec('git', ['--no-pager', 'log', '-1', '--format=%H']);
-            if (log1.stdout === log2.stdout) {
-                skipGetLog = true;
-            }
-        }
-        if (!skipGetLog && !stdout) {
-            if (latestTag) {
-                params.splice(2, 1, `${latestTag}`);
-            }
-            else {
-                params.splice(2, 1, 'HEAD');
-            }
-            ({ stdout } = await Shell.exec('git', params));
-        }
-        const allowTypes = ['feat', `fix`, `break change`, `style`, `perf`, `types`, `refactor`, `chore`];
-        const rePlugin = new RegExp(`^(${allowTypes.join('|')})${workspace ? `\\(${packageFolderName}\\)` : '(\\(.+\\))?'}: .*`, 'i');
-        const allCommits = stdout.split(SUFFIX);
-        const commits = allCommits
-            .filter((commit) => {
-            const chunk = commit.trim();
-            return chunk && rePlugin.test(chunk);
-        })
-            .map((commit) => {
-            const node = parser.sync(commit);
-            const body = (node.body || node.footer);
-            if (!node.type)
-                node.type = parser.sync(node.header?.replace(/\(.+\)!?:/, ':') || '').type;
-            if (!node.hash)
-                node.hash = commit.split(HASH).pop()?.trim();
-            node.breaking = reBreaking.test(body) || /!:/.test(node.header);
-            node.effect = false;
-            node.custom = false;
-            return node;
-        });
-        if (!commits.length) {
-            Logger.log(chalk.red(`No Commits Found.`));
-        }
-        else {
-            Logger.log(chalk.yellow(`Found `)
-                + chalk.bold(`${allCommits.length}`)
-                + ` Commits, `
-                + chalk.bold(`${commits.length}`)
-                + ' Commits Valid');
-        }
-        const { skipUpdatePackage } = commandOptions;
-        if (commits.length && skipUpdatePackage) {
-            let skip = false;
-            if (typeof skipUpdatePackage === 'boolean' && skipUpdatePackage) {
-                let result = await prompt([
-                    {
-                        type: 'confirm',
-                        name: 'skip',
-                        message: `Skip Update（${this.packageName}@${this.packageOptions.version}）：`,
-                        default: true
-                    }
-                ]);
-                skip = result.skip;
-            }
-            else if (typeof skipUpdatePackage === 'string'
-                && (skipUpdatePackage === '**'
-                    || skipUpdatePackage.split(',').includes(this.packageName))) {
-                skip = true;
-            }
-            if (skip) {
-                Logger.log(chalk.red(`Skipping Update\n`));
-                return;
-            }
-        }
-        await this.updateVersion();
-        await this.updateCommits(commits);
-        const { forceUpdatePackage } = commandOptions;
-        if (!commits.length && forceUpdatePackage) {
-            let force = false;
-            if (typeof forceUpdatePackage === 'boolean' && forceUpdatePackage) {
-                let result = await prompt([
-                    {
-                        type: 'confirm',
-                        name: 'force',
-                        message: `Force Update（${this.packageName}@${this.packageOptions.version}）：`,
-                        default: true
-                    }
-                ]);
-                force = result.force;
-            }
-            else if (typeof forceUpdatePackage === 'string'
-                && (forceUpdatePackage === '**'
-                    || forceUpdatePackage.split(',').includes(this.packageName))) {
-                force = true;
-            }
-            if (force) {
-                const oldVersion = this.packageOptions.version;
-                const versionChanged = `\`${oldVersion}\` -> \`${this.version}\``;
-                this.commits = [
-                    {
-                        type: 'chore',
-                        header: `chore(${this.packageFolderName || 'release'}): force-publish ${versionChanged}`,
-                        hash: '',
-                        effect: false,
-                        breaking: false,
-                        custom: true
-                    }
-                ];
-                this.changeLog = `### Force Update Package\n\n- ${versionChanged}`.trim();
-            }
-        }
-    }
-    rebuildChangeLog(commits) {
-        const { packageDir } = this;
-        const { homepage, workspace } = Shared.impl();
-        const logPath = path.resolve(packageDir, './CHANGELOG.md');
-        const logFile = fs.existsSync(logPath) ? fs.readFileSync(logPath, 'utf-8') : '';
-        const notes = {
-            breaking: [],
-            features: [],
-            fixes: [],
-            updates: []
-        };
-        const closeRegxp = /\(?(closes? )\(?#((\d+))\)/ig;
-        const pullRegxp = /(?<!closes? )\((#(\d+))\)/ig;
-        for (const commit of commits) {
-            const { effect, breaking, hash, header, type } = commit;
-            const ref = !hash || pullRegxp.test(header)
-                ? ''
-                : ` ([${hash?.substring(0, 7)}](${homepage}/commit/${hash}))`;
-            let message = header?.trim();
-            if (workspace && !effect) {
-                message = message.replace(/\(.+\)!?:/, ':');
-            }
-            message = message
-                .replace(pullRegxp, `[$1](${homepage}/pull/$2)`)
-                .replace(closeRegxp, `[$1$2](${homepage}/issues/$2)`) + ref;
-            if (breaking) {
-                notes.breaking.push(message);
-            }
-            else if (type === 'fix') {
-                notes.fixes.push(message);
-            }
-            else if (type === 'feat') {
-                notes.features.push(message);
-            }
-            else {
-                notes.updates.push(message);
-            }
-        }
-        Object.keys(notes).forEach(i => {
-            notes[i] = notes[i].filter((j) => {
-                return !logFile.includes(j);
-            });
-        });
-        const parts = [
-            notes.breaking.length ? `### Breaking Changes\n\n- ${notes.breaking.join('\n- ')}`.trim() : '',
-            notes.fixes.length ? `### Bugfixes\n\n- ${notes.fixes.join('\n- ')}`.trim() : '',
-            notes.features.length ? `### Features\n\n- ${notes.features.join('\n- ')}`.trim() : '',
-            notes.updates.length ? `### Updates\n\n- ${notes.updates.join('\n- ')}`.trim() : ''
-        ].filter(Boolean);
-        const newLog = parts.join('\n\n');
-        return !parts.length || logFile.includes(newLog)
-            ? ''
-            : newLog;
-    }
-    async updateVersion() {
-        const { packageOptions, commits, commandOptions } = this;
-        const { version } = packageOptions;
-        let newVersion = '';
-        if (commandOptions.customVersion) {
-            newVersion = commandOptions.customVersion;
-            if (!(/\d+.\d+.\d+/.test(newVersion)) || version === newVersion) {
-                let result = await prompt([
-                    {
-                        type: 'input',
-                        name: 'version',
-                        message: `Custom Update Version（${this.packageName}@${version}）：`,
-                        default: '',
-                        validate: (answer) => {
-                            if (!(/\d+.\d+.\d+/.test(answer))) {
-                                return 'Version Should Be Like x.x.x';
-                            }
-                            if (answer === version) {
-                                return 'Version Should Be Diff Than Before';
-                            }
-                            return true;
-                        }
-                    }
-                ]);
-                newVersion = result.version;
-            }
-        }
-        else {
-            const intersection = [
-                commandOptions.major && 'major',
-                commandOptions.minor && 'minor',
-                commandOptions.patch && 'patch'
-            ].filter(i => !!i);
-            if (intersection.length) {
-                newVersion = semver.inc(version, intersection[0]) || '';
-            }
-            else {
-                const types = new Set(commits.map(({ type }) => type));
-                const breaking = commits.some((commit) => !!commit.breaking);
-                const level = breaking
-                    ? 'major'
-                    : types.has('feat')
-                        ? 'minor'
-                        : 'patch';
-                newVersion = semver.inc(version, level) || '';
-            }
-        }
-        this.version = newVersion;
-    }
-    isChanged() {
-        return !!this.commits.length;
-    }
-    async updateCommits(commits, source) {
-        if (!commits.length)
-            return;
-        const { packageName } = this;
-        const olds = this.commits.map(i => JSON.stringify(i));
-        const newCommits = commits
-            .filter(i => {
-            return !olds.includes(JSON.stringify(i));
-        })
-            .map(j => {
-            return {
-                ...j,
-                effect: !!source
-            };
-        });
-        if (newCommits.length && this.commits.length) {
-            this.commits = this.commits.filter(i => !i.custom);
-        }
-        const commits$ = this.commits.concat(newCommits);
-        if (source) {
-            Logger.log(chalk.magenta(`MERGE COMMITS: `)
-                + chalk.bold(`${commits.length}`) + ` Commits. `
-                + 'merge ' + chalk.yellow(source) + ' into ' + chalk.green(packageName));
-        }
-        else {
-            Logger.log(``);
-        }
-        const changeLog = this.rebuildChangeLog(commits$);
-        if (changeLog) {
-            this.commits = commits$;
-            this.changeLog = changeLog;
-        }
-        else if (commits.length) {
-            Logger.log(chalk.red(`${commits.length} Commits Already Exists.`));
-        }
-    }
-    async updatePackageOptions(relationVerisons = {}) {
-        if (!this.isChanged())
-            return;
-        const { packageDir, packageOptions, commandOptions } = this;
-        const { dependencies, devDependencies } = packageOptions;
-        const newVersion = this.version;
-        Logger.log(chalk.yellow(`New Version: `) + `${newVersion}`);
-        packageOptions.version = newVersion;
-        if (Object.keys(this.packageRelation).length) {
-            for (let packageName$ in relationVerisons) {
-                let newVersion$ = relationVerisons[packageName$];
-                if (dependencies?.[packageName$]) {
-                    dependencies[packageName$] = newVersion$;
-                }
-                if (devDependencies?.[packageName$]) {
-                    devDependencies[packageName$] = newVersion$;
-                }
-            }
-        }
-        if (commandOptions.dryRun) {
-            Logger.log(chalk.yellow(`Skipping package.json Update`));
-            return;
-        }
-        Logger.log(chalk.yellow(`Updating `) + 'package.json');
-        fs.outputFileSync(`${packageDir}/package.json`, JSON.stringify(packageOptions, null, 2));
-    }
-    async updateChangelog() {
-        if (!this.isChanged())
-            return;
-        const { packageName, packageDir, packageOptions, commandOptions } = this;
-        const title = `# ${packageName} ChangeLog`;
-        const [date] = new Date().toISOString().split('T');
-        const logPath = path.resolve(packageDir, './CHANGELOG.md');
-        const logFile = fs.existsSync(logPath) ? fs.readFileSync(logPath, 'utf-8') : '';
-        const oldNotes = logFile.startsWith(title) ? logFile.slice(title.length).trim() : logFile;
-        const parts = [
-            `## v${packageOptions.version}`,
-            `_${date}_`,
-            this.changeLog
-        ].filter(Boolean);
-        const newLog = parts.join('\n\n');
-        if (commandOptions.dryRun) {
-            Logger.log(chalk.yellow(`New ChangeLog:`) + `\n${newLog}`);
-            return;
-        }
-        Logger.log(chalk.yellow(`Updating `) + `CHANGELOG.md`);
-        let content = [title, newLog, oldNotes].filter(Boolean).join('\n\n');
-        if (!content.endsWith('\n'))
-            content += '\n';
-        fs.writeFileSync(logPath, content, 'utf-8');
-    }
-    async test() {
-        if (!this.isChanged())
-            return;
-        const { commandOptions } = this;
-        if (commandOptions.dryRun) {
-            Logger.log(chalk.yellow('Skipping Test'));
-            return;
-        }
-        else {
-            Logger.log(chalk.yellow('Test...'));
-        }
-        await Shell.exec(`npm run test -- --package-name ${this.packageName}`);
-    }
-    async build() {
-        if (!this.isChanged())
-            return;
-        const { commandOptions } = this;
-        if (commandOptions.dryRun) {
-            Logger.log(chalk.yellow('Skipping Build'));
-            return;
-        }
-        else {
-            Logger.log(chalk.yellow('Build...'));
-        }
-        await Shell.exec(`npm run build -- --package-name ${this.packageName}`);
-    }
-    async publish() {
-        if (!this.isChanged())
-            return;
-        const { commandOptions, packageDir } = this;
-        if (commandOptions.dryRun || !commandOptions.publish) {
-            Logger.log(chalk.yellow(`Skipping Publish`));
-            return;
-        }
-        Logger.log(chalk.cyan(`\n Publishing to NPM`));
-        await Shell.spawn('npm', ['publish', '--no-git-checks', '--access', 'public'], {
-            cwd: packageDir
-        });
-    }
-    async tag() {
-        if (!this.isChanged())
-            return;
-        const { commandOptions, packageDir } = this;
-        const { packageName, packageOptions } = this;
-        if (commandOptions.dryRun || !commandOptions.tag) {
-            Logger.log(chalk.yellow(`Skipping Git Tag`));
-            return;
-        }
-        const tagName = `${packageName}@${packageOptions.version}`;
-        Logger.log(chalk.blue(`\n Tagging`) + chalk.grey(`${tagName}`));
-        await Shell.spawn('git', ['tag', tagName], {
-            cwd: packageDir
-        });
-    }
-    async process() {
-        const { workspace } = Shared.impl();
-        const { packageName, packageDir, packageFolderName } = this;
-        if (!packageDir || !fs.pathExists(packageDir)) {
-            throw new RangeError(`Could not find directory for package: ${packageFolderName}`);
-        }
-        Logger.log(chalk.cyan(`Releasing ${packageName}`) + ' from ' + chalk.grey(`${workspace}/${packageFolderName}`));
-        await this.parseCommits();
-        return this;
-    }
-}
-const releaser = (options, commandOptions) => {
-    return new Releaser(options, commandOptions);
-};
-
-const run = (options) => Utils.autoCatch(async () => {
-    const locals = Shared.impl();
-    if (options.dryRun) {
-        Logger.log(chalk.magenta(`DRY RUN: `)
-            + 'No files will be modified.');
-    }
-    let inputs = [];
-    if (locals.workspace) {
-        inputs = locals.normalizePackageFolderNames;
-    }
-    else {
-        inputs = [''];
-    }
-    const instances = {};
-    await inputs
-        .reduce((preProcess, packageFolderName) => {
-        preProcess = preProcess
-            .then(() => releaser(packageFolderName, options).process())
-            .then((instance) => {
-            instances[packageFolderName] = instance;
-        });
-        return preProcess;
-    }, Promise.resolve());
-    Logger.log(chalk.blue(`---------------------\n`));
-    let message = `chore(release): publish\n\n`;
-    let relationVerisons = {};
-    await inputs.reduce((preProcess, packageFolderName) => {
-        const instance = instances[packageFolderName];
-        instance.packageRelation.forEach(i => {
-            let packageFolderName$ = Shared.getPackageFolderName(i);
-            let instance$ = instances[packageFolderName$];
-            if (instance$.commits.length > 0) {
-                instance.updateCommits(instance$.commits, instance$.packageName);
-            }
-        });
-        if (instance.commits.length) {
-            preProcess = preProcess
-                .then(() => Logger.log(chalk.magenta(`CHANGED: `) + instance.packageName))
-                .then(() => instance.test())
-                .then(() => instance.build())
-                .then(() => instance.updatePackageOptions(relationVerisons))
-                .then(() => instance.updateChangelog())
-                .then(() => {
-                message += `- ${instance.packageName}@${instance.packageOptions.version}\n`;
-                relationVerisons[instance.packageName] = `^${instance.packageOptions.version}`;
-            });
-        }
-        return preProcess;
-    }, Promise.resolve());
-    Logger.log(chalk.blue(`\n---------------------\n`));
-    const isChanged = Object.keys(relationVerisons).length;
-    if (!isChanged) {
-        Logger.log(chalk.magenta(`COMMIT: `) + 'Nothing Chanaged Found.');
-    }
-    else if (options.dryRun || !options.commit) {
-        Logger.log(chalk.magenta(`COMMIT: `) + chalk.yellow(`Skipping Git Commit`) + `\n${message}`);
-    }
-    else {
-        Logger.log(chalk.magenta(`CHANGED: `) + `pnpm-lock.yaml`);
-        await Shell.spawn('npx', ['pnpm', 'install', '--lockfile-only']);
-        Logger.log(chalk.magenta(`COMMIT: `) + `CHANGELOG.md, package.json, pnpm-lock.yaml`);
-        await Shell.spawn('git', ['add', process.cwd()]);
-        await Shell.spawn('git', ['commit', '--m', `'${message}'`]);
-    }
-    await inputs
-        .reduce((preProcess, packageFolderName) => {
-        const instance = instances[packageFolderName];
-        preProcess = preProcess
-            .then(() => instance.publish())
-            .then(() => instance.tag());
-        return preProcess;
-    }, Promise.resolve());
-    Logger.log(chalk.blue(`\n---------------------\n`));
-    if (options.dryRun || !options.push) {
-        Logger.log(chalk.magenta(`FINISH: `) + 'Skipping Git Push');
-    }
-    else if (!isChanged) {
-        Logger.log(chalk.magenta(`FINISH: `) + 'Nothing Chanaged.');
-    }
-    else {
-        await Shell.spawn('git', ['push']);
-        await Shell.spawn('git', ['push', '--tags']);
-    }
-    if (options.dryRun) {
-        Logger.log(chalk.green('NO DRY RUN WAY: ')
-            + chalk.grey(`npm run release -- --no-dry-run\n`));
-    }
-}, {
-    onError: (e) => {
-        if (typeof e === 'number' && e === 1) {
-            Logger.error('发布失败');
-        }
-        else {
-            Logger.error(e);
-        }
-        process.exit(1);
-    }
-});
+import * as Releaser from '@deot/dev-releaser';
+import * as Builder from '@deot/dev-builder';
+import * as Tester from '@deot/dev-tester';
+import * as Adder from '@deot/dev-adder';
+import * as Linker from '@deot/dev-linker';
+import * as Dever from '@deot/dev-dever';
 
 const require = createRequire(import.meta.url);
 program
@@ -1138,28 +17,28 @@ program
     .alias('l')
     .description('pnpm link')
     .option('--dry-run [boolean]', 'Dry Run')
-    .action(run$5);
+    .action(Linker.run);
 program
     .command('add')
     .alias('a')
     .description('add dep or create package')
     .option('--dry-run [boolean]', 'Dry Run')
-    .action(run$4);
+    .action(Adder.run);
 program
     .command('dev')
     .alias('d')
     .description('dev')
     .option('-p, --package-name <string>', 'Select PackageName')
     .option('--dry-run [boolean]', 'Dry Run')
-    .action(run$2);
+    .action(Dever.run);
 program
     .command('build')
     .alias('b')
     .description('build')
     .option('-p, --package-name <string>', 'Select packageName')
-    .option('--output <string>', 'Output', 'es,cjs')
+    .option('--formats <string>', 'Formats(Output)', 'es,cjs')
     .option('--dry-run [boolean]', 'Dry Run')
-    .action(run$1);
+    .action(Builder.run);
 program
     .command('release')
     .alias('r')
@@ -1175,7 +54,8 @@ program
     .option('--patch [boolean]', 'Patch')
     .option('--major [boolean]', 'Major')
     .option('--minor [boolean]', 'Minor')
-    .action(run);
+    .option('--keep-last-tag [boolean]', 'Clean Tags, Keep Only Last Tag')
+    .action(Releaser.run);
 program
     .command('test')
     .alias('t')
@@ -1183,7 +63,7 @@ program
     .option('-p, --package-name <string>', 'Select PackageName')
     .option('-w, --watch [boolean]', 'Watch Test')
     .option('--dry-run [boolean]', 'Dry Run')
-    .action(run$3);
+    .action(Tester.run);
 program.parse(process.argv);
 if (!program.args.length) {
     program.help();