@coze-arch/rush-publish-plugin 0.0.1-alpha.6255b0

package/lib/action/release/package.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPublishConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const get_rush_config_1 = require("../../utils/get-rush-config");
+const fs_1 = require("../../utils/fs");
+/**
+ * 更新依赖版本
+ */
+const updateDependencyVersions = async (packageJson) => {
+    const rushConfiguration = (0, get_rush_config_1.getRushConfiguration)();
+    const { dependencies } = packageJson;
+    if (dependencies) {
+        for (const [dep, ver] of Object.entries(dependencies)) {
+            const project = rushConfiguration.getProjectByName(dep);
+            if (/^workspace:/.test(ver) && project) {
+                dependencies[dep] = project.packageJson.version;
+            }
+        }
+    }
+    return Promise.resolve(packageJson);
+};
+const applyCozePublishConfig = async (packageJson) => {
+    const { cozePublishConfig } = packageJson;
+    if (cozePublishConfig) {
+        const keys = Object.keys(cozePublishConfig);
+        for (const key of keys) {
+            packageJson[key] = cozePublishConfig[key];
+        }
+    }
+    return Promise.resolve(packageJson);
+};
+const applyPublishConfig = async (project) => {
+    const jobs = [
+        updateDependencyVersions,
+        applyCozePublishConfig,
+    ];
+    const packageJsonPath = path_1.default.join(project.projectFolder, 'package.json');
+    let packageJson = await (0, fs_1.readJsonFile)(packageJsonPath);
+    for (const job of jobs) {
+        packageJson = await job(packageJson);
+    }
+    await (0, fs_1.writeJsonFile)(packageJsonPath, packageJson);
+};
+exports.applyPublishConfig = applyPublishConfig;
+//# sourceMappingURL=package.js.map

package/lib/action/release/plan.d.ts

@@ -0,0 +1,8 @@
+import { type ReleaseManifest } from './types';
+export declare enum ReleaseType {
+    ALPHA = "alpha",
+    BETA = "beta",
+    LATEST = "latest"
+}
+export declare const calReleaseType: (version: string) => ReleaseType;
+export declare const checkReleasePlan: (releaseManifests: ReleaseManifest[], branchName: string) => boolean;

package/lib/action/release/plan.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkReleasePlan = exports.calReleaseType = exports.ReleaseType = void 0;
+var ReleaseType;
+(function (ReleaseType) {
+    ReleaseType["ALPHA"] = "alpha";
+    ReleaseType["BETA"] = "beta";
+    ReleaseType["LATEST"] = "latest";
+})(ReleaseType || (exports.ReleaseType = ReleaseType = {}));
+const calReleaseType = (version) => {
+    const tag = version.includes('alpha')
+        ? ReleaseType.ALPHA
+        : version.includes('beta')
+            ? ReleaseType.BETA
+            : ReleaseType.LATEST;
+    return tag;
+};
+exports.calReleaseType = calReleaseType;
+const calReleasePlan = (releaseManifests) => {
+    const plan = releaseManifests.map(r => (0, exports.calReleaseType)(r.version));
+    if (plan.some(p => p === ReleaseType.LATEST)) {
+        return ReleaseType.LATEST;
+    }
+    if (plan.some(p => p === ReleaseType.BETA)) {
+        return ReleaseType.BETA;
+    }
+    return ReleaseType.ALPHA;
+};
+const checkReleasePlan = (releaseManifests, branchName) => {
+    const releasePlan = calReleasePlan(releaseManifests);
+    if (releasePlan === ReleaseType.LATEST && branchName !== 'main') {
+        throw new Error('For LATEST release, should be on main branch only.');
+    }
+    return true;
+};
+exports.checkReleasePlan = checkReleasePlan;
+//# sourceMappingURL=plan.js.map

package/lib/action/release/release.d.ts

@@ -0,0 +1,2 @@
+import { type ReleaseOptions, type ReleaseManifest } from './types';
+export declare const releasePackages: (releaseManifests: ReleaseManifest[], releaseOptions: ReleaseOptions) => Promise<void>;

package/lib/action/release/release.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePackages = void 0;
+const logger_1 = require("../../utils/logger");
+const exec_1 = require("../../utils/exec");
+const package_1 = require("./package");
+/**
+ * 发布包
+ */
+const publishPackage = async (project, releaseOptions) => {
+    const { dryRun, registry } = releaseOptions;
+    const token = process.env.NODE_AUTH_TOKEN;
+    const { version } = project.packageJson;
+    const tag = version.includes('alpha')
+        ? 'alpha'
+        : version.includes('beta')
+            ? 'beta'
+            : 'latest';
+    const args = [`NODE_AUTH_TOKEN=${token}`, 'npm', 'publish', `--tag ${tag}`];
+    if (dryRun) {
+        args.push('--dry-run');
+    }
+    if (registry) {
+        args.push(`--registry=${registry}`);
+    }
+    await (0, exec_1.exec)(args.join(' '), {
+        cwd: project.projectFolder,
+    });
+    logger_1.logger.success(`- Published ${project.packageName}@${version}`);
+};
+const releasePackage = async (releaseManifest, releaseOptions) => {
+    const { project } = releaseManifest;
+    const { packageName } = project;
+    logger_1.logger.info(`Preparing release for package: ${packageName}`);
+    await (0, package_1.applyPublishConfig)(project);
+    await publishPackage(project, releaseOptions);
+};
+const buildProjects = async (releaseManifests) => {
+    const packageNames = releaseManifests.map(manifest => manifest.project.packageName);
+    const buildCommands = `rush build ${packageNames.map(name => `--to ${name}`).join(' ')}`;
+    await (0, exec_1.exec)(buildCommands);
+};
+const releasePackages = async (releaseManifests, releaseOptions) => {
+    await buildProjects(releaseManifests);
+    await Promise.all(releaseManifests.map(async (manifest) => {
+        await releasePackage(manifest, releaseOptions);
+    }));
+};
+exports.releasePackages = releasePackages;
+//# sourceMappingURL=release.js.map

package/lib/action/release/types.d.ts

@@ -0,0 +1,14 @@
+import { type RushConfigurationProject } from '@rushstack/rush-sdk';
+export interface ReleaseOptions {
+    commit: string;
+    dryRun?: boolean;
+    registry: string;
+}
+export interface PackageToPublish {
+    packageName: string;
+    version: string;
+}
+export interface ReleaseManifest {
+    project: RushConfigurationProject;
+    version: string;
+}

package/lib/action/release/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/generate-changelog/generate-changelog.d.ts

@@ -0,0 +1,49 @@
+interface ChangeLogComment {
+    comment: string;
+    author?: string;
+    commit?: string;
+    customFields?: Record<string, string>;
+}
+interface ChangeLogEntry {
+    version: string;
+    tag: string;
+    date: string;
+    comments: {
+        major?: ChangeLogComment[];
+        minor?: ChangeLogComment[];
+        patch?: ChangeLogComment[];
+        dependency?: ChangeLogComment[];
+        none?: ChangeLogComment[];
+    };
+}
+export interface ChangeLog {
+    name: string;
+    entries: ChangeLogEntry[];
+}
+interface Change {
+    packageName: string;
+    comment: string;
+    type: 'none' | 'dependency' | 'patch' | 'minor' | 'major';
+    customFields?: Record<string, string>;
+}
+export interface ChangeFile {
+    changes: Change[];
+    packageName: string;
+    email?: string;
+}
+interface GenerateChangelogOptions {
+    packageName: string;
+    version: string;
+    commingChanges: ChangeFile[];
+    previousChangelog?: ChangeLog;
+    defaultChangelog?: string;
+    tag?: string;
+}
+/**
+ * Merge and generate changelog
+ */
+export declare const generateChangelog: ({ commingChanges, previousChangelog, version, packageName, tag, defaultChangelog, }: GenerateChangelogOptions) => {
+    changelog: ChangeLog;
+    report: string;
+};
+export {};

package/lib/generate-changelog/generate-changelog.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateChangelog = void 0;
+const semver_1 = __importDefault(require("semver"));
+const dayjs_1 = __importDefault(require("dayjs"));
+/**
+ * Convert change type to corresponding title
+ */
+const getChangeTypeTitle = (type) => {
+    switch (type) {
+        case 'major':
+            return '### Breaking Changes';
+        case 'minor':
+            return '### New Features';
+        case 'patch':
+            return '### Bug Fixes';
+        case 'dependency':
+            return '### Dependencies';
+        case 'none':
+            return '### Other Changes';
+        default:
+            return '';
+    }
+};
+/**
+ * Generate changelog for a single version
+ */
+const generateVersionChangelog = ({ version, changes, tag, defaultChangelog, }) => {
+    // Group changes by type
+    const groupedChanges = changes.length > 0
+        ? changes.reduce((acc, change) => {
+            const { type, comment, customFields } = change;
+            if (!acc[type]) {
+                acc[type] = [];
+            }
+            const node = acc[type];
+            if (node.some(existing => existing.comment === comment) === false) {
+                node.push({
+                    comment,
+                    customFields,
+                });
+            }
+            return acc;
+        }, {})
+        : { none: [{ comment: defaultChangelog }] };
+    return {
+        version,
+        tag,
+        date: (0, dayjs_1.default)().toISOString(),
+        comments: groupedChanges,
+    };
+};
+/**
+ * Convert changelog to Markdown format
+ */
+const changelogToMarkdown = (changelog) => {
+    const lines = [];
+    lines.push(`# ${changelog.name}`);
+    lines.push('');
+    changelog.entries.forEach(entry => {
+        lines.push(`## ${entry.version} - ${(0, dayjs_1.default)(entry.date).format('YYYY-MM-DD')}`);
+        lines.push('');
+        // Output different types of changes in fixed order
+        const typeOrder = [
+            'major',
+            'minor',
+            'patch',
+            'dependency',
+            'none',
+        ];
+        typeOrder.forEach(type => {
+            const changes = entry.comments[type];
+            if (changes?.length) {
+                lines.push(getChangeTypeTitle(type));
+                lines.push('');
+                changes.forEach(change => {
+                    lines.push(`- ${change.comment}`);
+                    // Add custom fields to changelog if they exist
+                    if (change.customFields) {
+                        Object.entries(change.customFields).forEach(([key, value]) => {
+                            lines.push(`  - ${key}: ${value}`);
+                        });
+                    }
+                });
+                lines.push('');
+            }
+        });
+        lines.push('');
+    });
+    return lines.join('\n');
+};
+/**
+ * Merge and generate changelog
+ */
+const generateChangelog = ({ commingChanges, previousChangelog, version, packageName, tag, defaultChangelog = 'Publish for noop', }) => {
+    // Create new changelog entry
+    const newEntry = generateVersionChangelog({
+        version,
+        changes: commingChanges.flatMap(r => r.changes),
+        tag: tag || 'HEAD',
+        defaultChangelog,
+    });
+    const allEntries = (previousChangelog ? [newEntry, ...previousChangelog.entries] : [newEntry]).sort((a, b) => {
+        // Handle invalid version numbers
+        if (!semver_1.default.valid(a.version) || !semver_1.default.valid(b.version)) {
+            return 0;
+        }
+        // Use semver.rcompare for descending sort (newer versions first)
+        return semver_1.default.rcompare(a.version, b.version);
+    });
+    // Merge with existing changelog
+    const changelog = {
+        name: packageName,
+        entries: allEntries,
+    };
+    // Convert to markdown
+    const markdown = changelogToMarkdown(changelog);
+    return {
+        changelog,
+        report: markdown,
+    };
+};
+exports.generateChangelog = generateChangelog;
+//# sourceMappingURL=generate-changelog.js.map

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const commander_1 = require("commander");
+const release_1 = require("./action/release");
+const publish_1 = require("./action/publish");
+const change_1 = require("./action/change");
+const main = () => {
+    const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../package.json'), 'utf8'));
+    const program = new commander_1.Command();
+    program
+        .name(packageJson.name)
+        .description(packageJson.description)
+        .version(packageJson.version)
+        .showSuggestionAfterError(true)
+        .showHelpAfterError(true);
+    const actions = [change_1.installAction, release_1.installAction, publish_1.installAction];
+    actions.forEach(a => {
+        a(program);
+    });
+    program.parse();
+};
+main();
+//# sourceMappingURL=index.js.map

package/lib/types.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from 'commander';
+export type InstallAction = (program: Command) => void;

package/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/utils/exec.d.ts

@@ -0,0 +1,7 @@
+import { type ExecOptions } from 'shelljs';
+export interface ExecResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export declare const exec: (cmd: string, options?: ExecOptions) => Promise<ExecResult>;

package/lib/utils/exec.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exec = void 0;
+const shelljs_1 = require("shelljs");
+class ExecError extends Error {
+    constructor(result) {
+        super(result.stderr || result.stdout);
+        this.code = result.code;
+        this.stderr = result.stderr;
+        this.stdout = result.stdout;
+    }
+}
+const exec = (cmd, options = { silent: true }) => new Promise((r, j) => {
+    (0, shelljs_1.exec)(cmd, options, (code, stdout, stderr) => {
+        if (code === 0) {
+            r({ code, stdout, stderr });
+        }
+        else {
+            j(new ExecError({ code, stderr, stdout }));
+        }
+    });
+});
+exports.exec = exec;
+//# sourceMappingURL=exec.js.map

package/lib/utils/fs.d.ts

@@ -0,0 +1,4 @@
+export declare const readJsonFile: <T>(path: string) => Promise<T>;
+export declare const writeJsonFile: (path: string, data: unknown) => Promise<void>;
+export declare const isFileExists: (path: string) => Promise<boolean>;
+export declare const isDirExists: (path: string) => Promise<boolean>;

package/lib/utils/fs.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDirExists = exports.isFileExists = exports.writeJsonFile = exports.readJsonFile = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const readJsonFile = async (path) => {
+    const content = await promises_1.default.readFile(path, 'utf8');
+    return JSON.parse(content);
+};
+exports.readJsonFile = readJsonFile;
+const writeJsonFile = async (path, data) => {
+    await promises_1.default.writeFile(path, JSON.stringify(data, null, 2), 'utf8');
+};
+exports.writeJsonFile = writeJsonFile;
+const isFileExists = async (path) => promises_1.default
+    .access(path)
+    .then(() => true)
+    .catch(() => false);
+exports.isFileExists = isFileExists;
+const isDirExists = async (path) => promises_1.default
+    .access(path)
+    .then(() => true)
+    .catch(() => false);
+exports.isDirExists = isDirExists;
+//# sourceMappingURL=fs.js.map

package/lib/utils/get-rush-config.d.ts

@@ -0,0 +1,2 @@
+import { RushConfiguration } from '@rushstack/rush-sdk';
+export declare const getRushConfiguration: (useCache?: boolean) => RushConfiguration;

package/lib/utils/get-rush-config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRushConfiguration = void 0;
+const rush_sdk_1 = require("@rushstack/rush-sdk");
+exports.getRushConfiguration = (() => {
+    let rushConfiguration = null;
+    return (useCache = true) => {
+        if (!useCache) {
+            rushConfiguration = null;
+        }
+        return (rushConfiguration || (rushConfiguration = rush_sdk_1.RushConfiguration.loadFromDefaultLocation({
+            startingFolder: process.cwd(),
+        })));
+    };
+})();
+//# sourceMappingURL=get-rush-config.js.map

package/lib/utils/git.d.ts

@@ -0,0 +1,19 @@
+export declare const getChangedFilesFromCached: () => Promise<string[]>;
+/**
+ * 获取当前分支名称
+ * @returns string
+ */
+export declare const getCurrentBranchName: () => Promise<string>;
+export declare const isMainBranch: () => Promise<boolean>;
+export declare const getChangedFiles: () => Promise<string[]>;
+/**
+ * 确保没有未提交的变更
+ */
+export declare const ensureNotUncommittedChanges: () => Promise<boolean>;
+/**
+ * 获取当前 Git 仓库设置的 origin 远程源地址
+ * @param cwd 当前工作目录
+ * @returns origin 远程源地址
+ */
+export declare const getCurrentOrigin: (cwd?: string) => Promise<string | undefined>;
+export declare const convertGitSchemaToHttp: (gitUrl: string) => string;

package/lib/utils/git.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertGitSchemaToHttp = exports.getCurrentOrigin = exports.ensureNotUncommittedChanges = exports.getChangedFiles = exports.isMainBranch = exports.getCurrentBranchName = exports.getChangedFilesFromCached = void 0;
+const exec_1 = require("./exec");
+const serializeFilesName = (output) => output
+    .split('\n')
+    .map(line => {
+    if (line) {
+        const trimmedLine = line.trim();
+        return trimmedLine;
+    }
+    return '';
+})
+    .filter(line => line && line.length > 0);
+const getChangedFilesFromCached = async () => {
+    const output = await (0, exec_1.exec)('git diff --name-only --diff-filter=ACMR --cached');
+    if (!output) {
+        return [];
+    }
+    return serializeFilesName(output.stdout);
+};
+exports.getChangedFilesFromCached = getChangedFilesFromCached;
+/**
+ * 获取当前分支名称
+ * @returns string
+ */
+const getCurrentBranchName = async () => {
+    const { stdout } = await (0, exec_1.exec)('git rev-parse --abbrev-ref HEAD');
+    return stdout.trim();
+};
+exports.getCurrentBranchName = getCurrentBranchName;
+const isMainBranch = async () => {
+    const currentBranchName = await (0, exports.getCurrentBranchName)();
+    return currentBranchName === 'main';
+};
+exports.isMainBranch = isMainBranch;
+const getChangedFiles = async () => {
+    const output = await (0, exec_1.exec)('git diff --name-only --diff-filter=ACMR');
+    return serializeFilesName(output.stdout);
+};
+exports.getChangedFiles = getChangedFiles;
+/**
+ * 确保没有未提交的变更
+ */
+const ensureNotUncommittedChanges = async () => {
+    const changedFiles = (await Promise.all([(0, exports.getChangedFilesFromCached)(), (0, exports.getChangedFiles)()])).flat();
+    if (changedFiles.length > 0) {
+        throw new Error('There are uncommitted changes in the working tree, please commit them first.');
+    }
+    return true;
+};
+exports.ensureNotUncommittedChanges = ensureNotUncommittedChanges;
+/**
+ * 获取当前 Git 仓库设置的 origin 远程源地址
+ * @param cwd 当前工作目录
+ * @returns origin 远程源地址
+ */
+const getCurrentOrigin = async (cwd = process.cwd()) => {
+    try {
+        const { stdout } = await (0, exec_1.exec)('git remote get-url origin', { cwd });
+        return stdout.trim();
+    }
+    catch (error) {
+        return undefined;
+    }
+};
+exports.getCurrentOrigin = getCurrentOrigin;
+const convertGitSchemaToHttp = (gitUrl) => gitUrl.replace('git@', 'https://').replace(':', '/').replace('.git', '');
+exports.convertGitSchemaToHttp = convertGitSchemaToHttp;
+//# sourceMappingURL=git.js.map

package/lib/utils/logger.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 日志工具
+ *
+ * 提供统一的日志输出接口，支持不同级别的日志，包括彩色输出
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    SUCCESS = 4,
+    NONE = 5
+}
+/**
+ * 设置全局日志级别
+ * @param level 日志级别
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/**
+ * 获取当前日志级别
+ * @returns 当前日志级别
+ */
+export declare function getLogLevel(): LogLevel;
+/**
+ * 导出的日志工具
+ */
+export declare const logger: {
+    /**
+     * 调试日志
+     * @param message 日志消息
+     * @param showPrefix 是否显示前缀，默认为 true
+     */
+    debug(message: string, showPrefix?: boolean): void;
+    /**
+     * 信息日志
+     * @param message 日志消息
+     * @param showPrefix 是否显示前缀，默认为 true
+     */
+    info(message: string, showPrefix?: boolean): void;
+    /**
+     * 警告日志
+     * @param message 日志消息
+     * @param showPrefix 是否显示前缀，默认为 true
+     */
+    warn(message: string, showPrefix?: boolean): void;
+    /**
+     * 错误日志
+     * @param message 日志消息
+     * @param showPrefix 是否显示前缀，默认为 true
+     */
+    error(message: string, showPrefix?: boolean): void;
+    /**
+     * 成功日志
+     * @param message 日志消息
+     * @param showPrefix 是否显示前缀，默认为 true
+     */
+    success(message: string, showPrefix?: boolean): void;
+};