alemonjs 2.1.87 → 2.1.89

package/bin/README.md

@@ -100,6 +100,28 @@ alemonc version update
 
 读取本地 `package.json`，查找所有 `alemonjs` 和 `@alemonjs/*` 依赖，检查并更新到最新版本。
 
+#### publish — 智能发布当前包
+
+```sh
+alemonc publish
+alemonc publish patch
+alemonc publish --dry-run
+```
+
+行为说明：
+
+- 默认会查询 git tag 历史作为版本基线
+- 不传参数时：
+  - 如果本地版本高于最新 tag，直接发布本地版本
+  - 否则自动按最新 tag `patch +1`
+- 传 `patch/minor/major/prepatch/preminor/premajor/prerelease` 时会自动递增
+- 传具体版本号时会直接以该版本发布
+- 默认先执行 `npm run build`
+- 默认发布内容是 `lib/`、`package.json`、`README.md`
+- 如果项目配置了 `.npmignore` 或 `package.json.files`，则切换为 npm 文件选择规则
+- 最终把产物提交到 git `release` 分支，并推送对应 tag
+- 默认要求 git 工作区干净，发布成功后会自动提交源码中的 `package.json` 版本变更
+
 ---
 
 ### 项目诊断

package/bin/alemonc.js

@@ -6,6 +6,7 @@ import { versionUpdate } from './versionUpdate.js';
 import { info } from './info.js';
 import { platformAdd, platformRemove, platformList } from './platform.js';
 import { login } from './login.js';
+import { publish } from './publish.js';
 import { Command } from 'commander';
 const program = new Command();
 
@@ -74,6 +75,24 @@ program
     versionUpdate();
   });
 
+program
+  .command('publish [release]')
+  .description('智能发布当前包到 git release 仓库，支持 patch/minor/major 或直接指定版本号')
+  .option('--tag <tag>', 'git 标签通道，默认 stable 为 latest，预发布为 next')
+  .option('--preid <preid>', '预发布标识，默认 beta', 'beta')
+  .option('--branch <branch>', '发布目标分支，默认 release')
+  .option('--dry-run', '只执行检查和打包，不真正发布')
+  .option('--skip-build', '跳过构建')
+  .option('--no-git-checks', '跳过 git 干净工作区检查及发布后自动提交源码版本')
+  .action(async (release, options) => {
+    try {
+      await publish(release, options);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
 program
   .command('info')
   .description('输出项目诊断信息')
@@ -118,4 +137,4 @@ program
     program.help();
   });
 
-program.parse(process.argv);
+program.parseAsync(process.argv);

package/bin/publish.js

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import { join } from 'path';
+import os from 'os';
+import { execSync, spawnSync } from 'child_process';
+
+const RELEASE_TYPES = new Set(['patch', 'minor', 'major', 'prepatch', 'preminor', 'premajor', 'prerelease']);
+const SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+const DEFAULT_PUBLISH_FILES = ['lib', 'package.json', 'README.md'];
+
+function readPackageJson() {
+  const pkgPath = join(process.cwd(), 'package.json');
+
+  if (!fs.existsSync(pkgPath)) {
+    throw new Error('未找到 package.json');
+  }
+
+  return {
+    pkgPath,
+    pkg: JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+  };
+}
+
+function runCommand(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    shell: false,
+    ...options
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`命令执行失败: ${command} ${args.join(' ')}`);
+  }
+}
+
+function getCommandOutput(command) {
+  return execSync(command, {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore']
+  }).trim();
+}
+
+function hasCommand(command) {
+  const result = spawnSync(command, ['--version'], {
+    cwd: process.cwd(),
+    stdio: 'ignore'
+  });
+
+  return !result.error;
+}
+
+function isGitRepo() {
+  try {
+    return getCommandOutput('git rev-parse --is-inside-work-tree') === 'true';
+  } catch {
+    return false;
+  }
+}
+
+function ensureCleanGit() {
+  const status = getCommandOutput('git status --porcelain');
+  if (status) {
+    throw new Error('工作区存在未提交改动，请先提交或使用 --no-git-checks 跳过检查');
+  }
+}
+
+function parseVersion(version) {
+  const matched = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+  if (!matched) {
+    throw new Error(`非法版本号: ${version}`);
+  }
+
+  return {
+    major: Number(matched[1]),
+    minor: Number(matched[2]),
+    patch: Number(matched[3]),
+    prerelease: matched[4] ?? null
+  };
+}
+
+function compareVersions(a, b) {
+  const av = parseVersion(a);
+  const bv = parseVersion(b);
+
+  for (const key of ['major', 'minor', 'patch']) {
+    if (av[key] > bv[key]) return 1;
+    if (av[key] < bv[key]) return -1;
+  }
+
+  if (av.prerelease === bv.prerelease) return 0;
+  if (av.prerelease === null) return 1;
+  if (bv.prerelease === null) return -1;
+
+  return av.prerelease.localeCompare(bv.prerelease);
+}
+
+function incrementVersion(baseVersion, releaseType, preid = 'beta') {
+  const parsed = parseVersion(baseVersion);
+
+  if (releaseType === 'patch') {
+    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+  }
+
+  if (releaseType === 'minor') {
+    return `${parsed.major}.${parsed.minor + 1}.0`;
+  }
+
+  if (releaseType === 'major') {
+    return `${parsed.major + 1}.0.0`;
+  }
+
+  if (releaseType === 'prepatch') {
+    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}-${preid}.0`;
+  }
+
+  if (releaseType === 'preminor') {
+    return `${parsed.major}.${parsed.minor + 1}.0-${preid}.0`;
+  }
+
+  if (releaseType === 'premajor') {
+    return `${parsed.major + 1}.0.0-${preid}.0`;
+  }
+
+  if (releaseType === 'prerelease') {
+    if (parsed.prerelease) {
+      const next = parsed.prerelease.match(/^(.*?)(\d+)$/);
+      if (next) {
+        return `${parsed.major}.${parsed.minor}.${parsed.patch}-${next[1]}${Number(next[2]) + 1}`;
+      }
+
+      return `${parsed.major}.${parsed.minor}.${parsed.patch}-${parsed.prerelease}.1`;
+    }
+
+    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}-${preid}.0`;
+  }
+
+  throw new Error(`不支持的发布类型: ${releaseType}`);
+}
+
+function resolveTargetVersion(localVersion, remoteVersion, release, preid) {
+  if (!release) {
+    if (!remoteVersion) {
+      return localVersion;
+    }
+
+    if (compareVersions(localVersion, remoteVersion) > 0) {
+      return localVersion;
+    }
+
+    return incrementVersion(remoteVersion, 'patch', preid);
+  }
+
+  if (RELEASE_TYPES.has(release)) {
+    const base = remoteVersion && compareVersions(remoteVersion, localVersion) > 0 ? remoteVersion : localVersion;
+    return incrementVersion(base, release, preid);
+  }
+
+  if (SEMVER_RE.test(release)) {
+    return release;
+  }
+
+  throw new Error(`无法识别的发布参数: ${release}`);
+}
+
+function updateVersion(pkgPath, pkg, version) {
+  pkg.version = version;
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+}
+
+function getPackResult(cwd = process.cwd()) {
+  const output = execSync('npm pack --json --dry-run', {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+    maxBuffer: 20 * 1024 * 1024
+  }).trim();
+
+  const result = JSON.parse(output);
+  if (!Array.isArray(result) || result.length === 0 || !Array.isArray(result[0]?.files)) {
+    throw new Error('无法解析 npm pack 文件清单');
+  }
+
+  return result[0];
+}
+
+function hasNpmPublishRules(pkg) {
+  if (fs.existsSync(join(process.cwd(), '.npmignore'))) {
+    return true;
+  }
+
+  return Array.isArray(pkg.files) && pkg.files.length > 0;
+}
+
+function getDefaultPublishFiles() {
+  return DEFAULT_PUBLISH_FILES.filter(file => fs.existsSync(join(process.cwd(), file)));
+}
+
+function warnDefaultPublishState(pkg, publishFiles) {
+  const hasLibDir = fs.existsSync(join(process.cwd(), 'lib'));
+  const mainField = typeof pkg.main === 'string' ? pkg.main : '';
+
+  if (!hasLibDir && mainField.startsWith('./lib/')) {
+    console.warn(`警告: 缺少 lib/ 目录，但 package.json main 指向 ${mainField}，将继续发布`);
+  }
+
+  if (publishFiles.length === 0) {
+    console.warn('警告: 默认发布规则下没有匹配到任何文件');
+  }
+}
+
+function copyPublishFiles(files) {
+  const publishDir = fs.mkdtempSync(join(os.tmpdir(), 'alemon-publish-'));
+
+  for (const item of files) {
+    const relativePath = typeof item === 'string' ? item : item.path;
+    const sourcePath = join(process.cwd(), relativePath);
+    const targetPath = join(publishDir, relativePath);
+
+    if (!fs.existsSync(sourcePath)) {
+      continue;
+    }
+
+    if (fs.statSync(sourcePath).isDirectory()) {
+      fs.mkdirSync(join(targetPath, '..'), { recursive: true });
+      fs.cpSync(sourcePath, targetPath, { recursive: true });
+      continue;
+    }
+
+    fs.mkdirSync(join(targetPath, '..'), { recursive: true });
+    fs.copyFileSync(sourcePath, targetPath);
+  }
+
+  return publishDir;
+}
+
+function removeDirContents(dirPath) {
+  for (const entry of fs.readdirSync(dirPath)) {
+    if (entry === '.git') {
+      continue;
+    }
+
+    fs.rmSync(join(dirPath, entry), { recursive: true, force: true });
+  }
+}
+
+function copyDirContents(sourceDir, targetDir) {
+  for (const entry of fs.readdirSync(sourceDir)) {
+    fs.cpSync(join(sourceDir, entry), join(targetDir, entry), { recursive: true });
+  }
+}
+
+function ensureGitRepo() {
+  if (!isGitRepo()) {
+    throw new Error('当前目录不是 git 仓库，无法执行 git 发布');
+  }
+}
+
+function remoteBranchExists(branch) {
+  const result = spawnSync('git', ['ls-remote', '--exit-code', '--heads', 'origin', branch], {
+    cwd: process.cwd(),
+    stdio: 'ignore'
+  });
+
+  return result.status === 0;
+}
+
+function localBranchExists(branch) {
+  const result = spawnSync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+    cwd: process.cwd(),
+    stdio: 'ignore'
+  });
+
+  return result.status === 0;
+}
+
+function createReleaseWorktree(branch) {
+  const worktreeDir = fs.mkdtempSync(join(os.tmpdir(), 'alemon-worktree-'));
+
+  if (remoteBranchExists(branch)) {
+    runCommand('git', ['fetch', 'origin', branch]);
+    runCommand('git', ['worktree', 'add', '-B', branch, worktreeDir, `origin/${branch}`]);
+  } else if (localBranchExists(branch)) {
+    runCommand('git', ['worktree', 'add', worktreeDir, branch]);
+  } else {
+    runCommand('git', ['worktree', 'add', '-b', branch, worktreeDir]);
+  }
+
+  return worktreeDir;
+}
+
+function cleanupWorktree(worktreeDir) {
+  if (!worktreeDir) {
+    return;
+  }
+
+  spawnSync('git', ['worktree', 'remove', '--force', worktreeDir], {
+    cwd: process.cwd(),
+    stdio: 'ignore'
+  });
+  fs.rmSync(worktreeDir, { recursive: true, force: true });
+}
+
+export async function publish(release, options = {}) {
+  if (!hasCommand('git')) {
+    throw new Error('未找到 git，请先安装 git');
+  }
+
+  if (!hasCommand('npm')) {
+    throw new Error('未找到 npm，请先安装 Node.js/npm');
+  }
+
+  const { pkgPath, pkg } = readPackageJson();
+  const packageName = pkg.name;
+  const localVersion = String(pkg.version || '').trim();
+
+  if (!packageName) {
+    throw new Error('package.json 缺少 name');
+  }
+
+  if (!SEMVER_RE.test(localVersion)) {
+    throw new Error(`当前 package.json 版本号非法: ${localVersion}`);
+  }
+
+  console.log(`发布包: ${packageName}`);
+  console.log(`本地版本: ${localVersion}`);
+
+  ensureGitRepo();
+
+  const releaseBranch = options.branch || 'release';
+  const remoteVersion = getCommandOutput(`git tag --list "v*" --sort=-v:refname | head -n 1`).replace(/^v/, '');
+  if (remoteVersion) {
+    console.log(`最新 git tag: v${remoteVersion}`);
+  } else {
+    console.log('最新 git tag: 无，将按首次发布处理');
+  }
+
+  if (options.gitChecks !== false && isGitRepo()) {
+    ensureCleanGit();
+  }
+
+  const targetVersion = resolveTargetVersion(localVersion, remoteVersion, release, options.preid);
+  const distTag = options.tag || (targetVersion.includes('-') ? 'next' : 'latest');
+  const gitTagName = distTag === 'latest' ? `v${targetVersion}` : `v${targetVersion}-${distTag}`;
+  console.log(`目标版本: ${targetVersion}`);
+  console.log(`发布分支: ${releaseBranch}`);
+  console.log(`git 标签: ${gitTagName}`);
+
+  if (targetVersion !== localVersion) {
+    updateVersion(pkgPath, pkg, targetVersion);
+    console.log(`已更新 package.json 版本: ${localVersion} -> ${targetVersion}`);
+  }
+
+  let publishDir = null;
+  let worktreeDir = null;
+  try {
+    if (!options.skipBuild) {
+      if (pkg.scripts?.build) {
+        console.log('执行构建...');
+        runCommand('npm', ['run', 'build']);
+      } else {
+        console.log('未定义 build 脚本，跳过构建');
+      }
+    } else {
+      console.log('已跳过构建');
+    }
+
+    const useNpmRules = hasNpmPublishRules(pkg);
+    const publishFiles = useNpmRules ? getPackResult().files : getDefaultPublishFiles();
+
+    if (!useNpmRules) {
+      warnDefaultPublishState(pkg, publishFiles);
+    }
+
+    publishDir = copyPublishFiles(publishFiles);
+
+    console.log(`发布规则: ${useNpmRules ? 'npm' : 'default'}`);
+    console.log(`发布文件数: ${publishFiles.length}`);
+
+    if (options.dryRun) {
+      console.log('dry-run 模式，不会真正推送到 git');
+      return;
+    }
+
+    console.log('准备 release worktree...');
+    worktreeDir = createReleaseWorktree(releaseBranch);
+    removeDirContents(worktreeDir);
+    copyDirContents(publishDir, worktreeDir);
+
+    runCommand('git', ['-C', worktreeDir, 'add', '-A']);
+    const hasChanges = spawnSync('git', ['-C', worktreeDir, 'diff', '--cached', '--quiet']).status !== 0;
+    if (!hasChanges) {
+      console.log('release 分支无文件变化，跳过提交');
+    } else {
+      runCommand('git', ['-C', worktreeDir, 'commit', '-m', `release: ${gitTagName}`]);
+      runCommand('git', ['-C', worktreeDir, 'push', 'origin', `HEAD:${releaseBranch}`]);
+      console.log(`已推送到分支: ${releaseBranch}`);
+    }
+
+    runCommand('git', ['tag', '-f', gitTagName]);
+    runCommand('git', ['push', 'origin', gitTagName, '--force']);
+    console.log(`发布完成: ${packageName}@${targetVersion}`);
+  } catch (error) {
+    if (targetVersion !== localVersion) {
+      updateVersion(pkgPath, pkg, localVersion);
+      console.log(`已回滚 package.json 版本到 ${localVersion}`);
+    }
+    throw error;
+  } finally {
+    if (publishDir) {
+      fs.rmSync(publishDir, { recursive: true, force: true });
+    }
+    cleanupWorktree(worktreeDir);
+  }
+
+  if (options.gitChecks !== false && isGitRepo()) {
+    runCommand('git', ['add', 'package.json']);
+    runCommand('git', ['commit', '-m', `release: ${gitTagName}`]);
+    console.log(`已记录源码版本变更: ${gitTagName}`);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.87",
+  "version": "2.1.89",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",