@deot/dev-releaser 1.1.0

package/README.md

@@ -0,0 +1,6 @@
+# @deot/dev-releaser
+
+用于发包流程, 自动生成changelog, tags....
+
+- 默认`dryRun`
+- 使用`dependencies`，非`peerDependencies`。主要考虑仅安装`@deot/dev-releaser`即可

package/dist/index.cjs.js

@@ -0,0 +1,559 @@
+'use strict';
+
+var chalk = require('chalk');
+var devShared = require('@deot/dev-shared');
+var path = require('node:path');
+var fs = require('fs-extra');
+var node_module = require('node:module');
+var parser = require('conventional-commits-parser');
+var semver = require('semver');
+var inquirer = require('inquirer');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+const cwd = process.cwd();
+const require$ = node_module.createRequire(cwd);
+const { prompt } = inquirer;
+const HASH = '-hash-';
+const SUFFIX = '🐒💨🙊';
+const parserOptions = {
+    noteKeywords: ['BREAKING CHANGE', 'Breaking Change']
+};
+const reBreaking = new RegExp(`(${parserOptions.noteKeywords.join(')|(')})`);
+class Release {
+    packageDir;
+    packageName;
+    packageFolderName;
+    packageOptions;
+    packageRelation;
+    config;
+    changeLog;
+    version;
+    commits;
+    commandOptions;
+    constructor(config, commandOptions) {
+        const { packageDir, packageRelation } = devShared.Locals.impl();
+        if (typeof config === 'string') {
+            let packageFolderName = config;
+            let packageDir$ = path__namespace.resolve(packageDir, packageFolderName);
+            config = {
+                dir: packageDir$,
+                name: packageFolderName
+            };
+        }
+        this.packageDir = config.dir;
+        this.packageName = devShared.Locals.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 } = devShared.Locals.impl();
+        const { packageFolderName, packageName, commandOptions } = this;
+        let params = ['tag', '--list', `'${packageName}@*'`, '--sort', '-v:refname'];
+        const { stdout: tags } = await devShared.Shell.exec('git', params);
+        const [latestTag] = tags.split('\n');
+        devShared.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 devShared.Shell.exec('git', params);
+        let skipGetLog = false;
+        if (latestTag) {
+            const log1 = await devShared.Shell.exec('git', ['rev-parse', latestTag]);
+            const log2 = await devShared.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 devShared.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) {
+            devShared.Logger.log(chalk.red(`No Commits Found.`));
+        }
+        else {
+            devShared.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) {
+                devShared.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 } = devShared.Locals.impl();
+        const logPath = path__namespace.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) {
+            devShared.Logger.log(chalk.magenta(`MERGE COMMITS: `)
+                + chalk.bold(`${commits.length}`) + ` Commits. `
+                + 'merge ' + chalk.yellow(source) + ' into ' + chalk.green(packageName));
+        }
+        else {
+            devShared.Logger.log(``);
+        }
+        const changeLog = this.rebuildChangeLog(commits$);
+        if (changeLog) {
+            this.commits = commits$;
+            this.changeLog = changeLog;
+        }
+        else if (commits.length) {
+            devShared.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;
+        devShared.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) {
+            devShared.Logger.log(chalk.yellow(`Skipping package.json Update`));
+            return;
+        }
+        devShared.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__namespace.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) {
+            devShared.Logger.log(chalk.yellow(`New ChangeLog:`) + `\n${newLog}`);
+            return;
+        }
+        devShared.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) {
+            devShared.Logger.log(chalk.yellow('Skipping Test'));
+            return;
+        }
+        else {
+            devShared.Logger.log(chalk.yellow('Test...'));
+        }
+        await devShared.Shell.exec(`npm run test -- --package-name ${this.packageName}`);
+    }
+    async build() {
+        if (!this.isChanged())
+            return;
+        const { commandOptions } = this;
+        if (commandOptions.dryRun) {
+            devShared.Logger.log(chalk.yellow('Skipping Build'));
+            return;
+        }
+        else {
+            devShared.Logger.log(chalk.yellow('Build...'));
+        }
+        await devShared.Shell.exec(`npm run build -- --package-name ${this.packageName}`);
+    }
+    async publish() {
+        if (!this.isChanged())
+            return;
+        const { commandOptions, packageDir } = this;
+        if (commandOptions.dryRun || !commandOptions.publish) {
+            devShared.Logger.log(chalk.yellow(`Skipping Publish`));
+            return;
+        }
+        devShared.Logger.log(chalk.cyan(`\n Publishing to NPM`));
+        await devShared.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) {
+            devShared.Logger.log(chalk.yellow(`Skipping Git Tag`));
+            return;
+        }
+        const tagName = `${packageName}@${packageOptions.version}`;
+        devShared.Logger.log(chalk.blue(`\n Tagging`) + chalk.grey(`${tagName}`));
+        await devShared.Shell.spawn('git', ['tag', tagName], {
+            cwd: packageDir
+        });
+    }
+    async process() {
+        const { workspace } = devShared.Locals.impl();
+        const { packageName, packageDir, packageFolderName } = this;
+        if (!packageDir || !fs.pathExists(packageDir)) {
+            throw new RangeError(`Could not find directory for package: ${packageFolderName}`);
+        }
+        devShared.Logger.log(chalk.cyan(`Releasing ${packageName}`) + ' from ' + chalk.grey(`${workspace}/${packageFolderName}`));
+        await this.parseCommits();
+        return this;
+    }
+}
+const release = (options, commandOptions) => {
+    return new Release(options, commandOptions);
+};
+
+const run = (options) => devShared.Utils.autoCatch(async () => {
+    options = {
+        dryRun: true,
+        tag: true,
+        publish: true,
+        commit: true,
+        push: true,
+        ...options
+    };
+    const locals = devShared.Locals.impl();
+    if (options.dryRun) {
+        devShared.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(() => release(packageFolderName, options).process())
+            .then((instance) => {
+            instances[packageFolderName] = instance;
+        });
+        return preProcess;
+    }, Promise.resolve());
+    devShared.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$ = devShared.Locals.getPackageFolderName(i);
+            let instance$ = instances[packageFolderName$];
+            if (instance$.commits.length > 0) {
+                instance.updateCommits(instance$.commits, instance$.packageName);
+            }
+        });
+        if (instance.commits.length) {
+            preProcess = preProcess
+                .then(() => devShared.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());
+    devShared.Logger.log(chalk.blue(`\n---------------------\n`));
+    const isChanged = Object.keys(relationVerisons).length;
+    if (!isChanged) {
+        devShared.Logger.log(chalk.magenta(`COMMIT: `) + 'Nothing Chanaged Found.');
+    }
+    else if (options.dryRun || !options.commit) {
+        devShared.Logger.log(chalk.magenta(`COMMIT: `) + chalk.yellow(`Skipping Git Commit`) + `\n${message}`);
+    }
+    else {
+        devShared.Logger.log(chalk.magenta(`CHANGED: `) + `pnpm-lock.yaml`);
+        await devShared.Shell.spawn('npx', ['pnpm', 'install', '--lockfile-only']);
+        devShared.Logger.log(chalk.magenta(`COMMIT: `) + `CHANGELOG.md, package.json, pnpm-lock.yaml`);
+        await devShared.Shell.spawn('git', ['add', process.cwd()]);
+        await devShared.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());
+    devShared.Logger.log(chalk.blue(`\n---------------------\n`));
+    if (options.dryRun || !options.push) {
+        devShared.Logger.log(chalk.magenta(`FINISH: `) + 'Skipping Git Push');
+    }
+    else if (!isChanged) {
+        devShared.Logger.log(chalk.magenta(`FINISH: `) + 'Nothing Chanaged.');
+    }
+    else {
+        await devShared.Shell.spawn('git', ['push']);
+        await devShared.Shell.spawn('git', ['push', '--tags']);
+    }
+    if (options.dryRun) {
+        devShared.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) {
+            devShared.Logger.error('发布失败');
+        }
+        else {
+            devShared.Logger.error(e);
+        }
+        process.exit(1);
+    }
+});
+
+exports.run = run;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Options } from '@deot/dev-shared';
+
+export declare const run: (options: Options) => Promise<any>;
+
+export { }

package/dist/index.es.js

@@ -0,0 +1,538 @@
+import chalk from 'chalk';
+import { Locals, Shell, Logger, Utils } from '@deot/dev-shared';
+import * as path from 'node:path';
+import fs from 'fs-extra';
+import { createRequire } from 'node:module';
+import parser from 'conventional-commits-parser';
+import semver from 'semver';
+import inquirer from 'inquirer';
+
+const cwd = process.cwd();
+const require$ = createRequire(cwd);
+const { prompt } = inquirer;
+const HASH = '-hash-';
+const SUFFIX = '🐒💨🙊';
+const parserOptions = {
+    noteKeywords: ['BREAKING CHANGE', 'Breaking Change']
+};
+const reBreaking = new RegExp(`(${parserOptions.noteKeywords.join(')|(')})`);
+class Release {
+    packageDir;
+    packageName;
+    packageFolderName;
+    packageOptions;
+    packageRelation;
+    config;
+    changeLog;
+    version;
+    commits;
+    commandOptions;
+    constructor(config, commandOptions) {
+        const { packageDir, packageRelation } = Locals.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 = Locals.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 } = Locals.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 } = Locals.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 } = Locals.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 release = (options, commandOptions) => {
+    return new Release(options, commandOptions);
+};
+
+const run = (options) => Utils.autoCatch(async () => {
+    options = {
+        dryRun: true,
+        tag: true,
+        publish: true,
+        commit: true,
+        push: true,
+        ...options
+    };
+    const locals = Locals.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(() => release(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$ = Locals.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);
+    }
+});
+
+export { run };

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@deot/dev-releaser",
+  "version": "1.1.0",
+  "main": "dist/index.es.js",
+  "module": "dist/index.es.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@deot/dev-extract": "^1.1.0",
+    "@deot/dev-shared": "^1.1.0",
+    "conventional-commits-parser": "^3.2.4",
+    "semver": "^7.3.8"
+  }
+}