@mindbase/mindbase 1.0.0

package/src/publish/app.ts

@@ -0,0 +1,316 @@
+import * as clack from '@clack/prompts';
+import { noteBox } from '@mindbase/cli-ui';
+import { resolve } from 'path';
+import { RegistryManager } from './registry/registry-manager.js';
+import {
+  detectWorkspace,
+  scanPackages,
+  analyzeDependencies,
+  bumpVersions,
+  applyVersionChanges,
+  NpmPublisher,
+  queryPackage,
+  type Workspace,
+  type Package,
+  type DependencyAnalysis,
+  type BumpType,
+} from './index.js';
+
+/** 统一取消处理 */
+function handleCancel<T>(result: T | symbol): T {
+  if (clack.isCancel(result)) {
+    clack.cancel('操作已取消');
+    process.exit(0);
+  }
+  return result;
+}
+
+/**
+ * 运行 npmpublish 主流程
+ */
+export async function runApp(scanPath: string, options: { dryRun?: boolean } = {}): Promise<void> {
+  // 阶段 1: 扫描（带进度）
+  const s = clack.spinner();
+  s.start('检测工作空间...');
+  const workspace = await detectWorkspace(scanPath);
+  s.message(`扫描包（${workspace.type} 模式）...`);
+  const packages = await scanPackages(workspace);
+  s.message('分析依赖关系...');
+  const analysis = analyzeDependencies(packages);
+  s.stop(`找到 ${packages.length} 个包`);
+
+  if (packages.length === 0) {
+    clack.log.warn('未找到可发布的包');
+    return;
+  }
+
+  // 展示概览
+  showOverview(packages, analysis);
+
+  // 阶段 2: 主循环
+  let selectedPackages: Package[] = [];
+  let versionChanges = new Map<Package, string>();
+
+  while (true) {
+    const action = handleCancel(
+      await clack.select({
+        message: '选择操作',
+        options: [
+          { value: 'select', label: '选择包', hint: `已选 ${selectedPackages.length} 个` },
+          { value: 'version', label: '版本管理', hint: versionChanges.size > 0 ? `${versionChanges.size} 个变更` : '' },
+          { value: 'publish', label: '发布', hint: options.dryRun ? '(dry-run)' : '' },
+          { value: 'info', label: '查看包信息', hint: '查询 npm registry' },
+          { value: 'quit', label: '退出' },
+        ],
+      })
+    ) as string;
+
+    switch (action) {
+      case 'select':
+        selectedPackages = await selectPackages(packages);
+        // 选中包后重置版本变更
+        versionChanges.clear();
+        break;
+      case 'version':
+        if (selectedPackages.length === 0) {
+          clack.log.warn('请先选择包');
+          break;
+        }
+        versionChanges = await manageVersions(selectedPackages);
+        break;
+      case 'publish':
+        if (selectedPackages.length === 0) {
+          clack.log.warn('请先选择包');
+          break;
+        }
+        await publishPackages(selectedPackages, analysis, versionChanges, options.dryRun);
+        break;
+      case 'info':
+        await showPackageInfo(packages);
+        break;
+      case 'quit':
+        return;
+    }
+  }
+}
+
+/**
+ * 展示工作空间概览
+ */
+function showOverview(packages: Package[], analysis: DependencyAnalysis): void {
+  const overview = packages.map(p => {
+    const priv = p.private ? '(private)' : '';
+    const build = p.hasBuildScript ? '[build]' : '';
+    return `${p.name}@${p.version} ${priv} ${build}`;
+  }).join('\n');
+  const depInfo = analysis.hasCycle
+    ? `⚠ 存在循环依赖: ${analysis.cycles.map(c => c.join(' → ')).join(', ')}`
+    : '无循环依赖';
+  noteBox(overview + `\n\n${depInfo}`, '工作空间概览');
+}
+
+/**
+ * 选择包（支持全选）
+ */
+async function selectPackages(packages: Package[]): Promise<Package[]> {
+  const publicPkgs = packages.filter(p => !p.private);
+  const ALL_VALUE = '__ALL__';
+
+  const selected = handleCancel(
+    await clack.multiselect({
+      message: '选择要操作的包（空格切换，a 全选）',
+      options: [
+        { value: ALL_VALUE, label: '全选', hint: `共 ${publicPkgs.length} 个公开包` },
+        ...publicPkgs.map(p => ({
+          value: p.name,
+          label: `${p.name}@${p.version}`,
+          hint: p.hasBuildScript ? 'has build' : '',
+        })),
+      ],
+      required: true,
+    })
+  ) as string[];
+
+  if (selected.includes(ALL_VALUE)) {
+    return publicPkgs;
+  }
+  return publicPkgs.filter(p => selected.includes(p.name));
+}
+
+/**
+ * 版本管理：单选 bump 类型 → 展示可编辑版本号 → 确认
+ */
+async function manageVersions(packages: Package[]): Promise<Map<Package, string>> {
+  // 单选 bump 类型
+  const bumpType = handleCancel(
+    await clack.select({
+      message: '选择版本递增类型',
+      options: [
+        { value: 'patch', label: 'patch', hint: '补丁版本 (x.y.Z)' },
+        { value: 'minor', label: 'minor', hint: '次版本 (x.Y.0)' },
+        { value: 'major', label: 'major', hint: '主版本 (X.0.0)' },
+      ],
+    })
+  ) as BumpType;
+
+  // 计算新版本
+  const changes = bumpVersions(packages, bumpType);
+
+  // 展示可编辑的版本号（逐个编辑）
+  const finalChanges = new Map<Package, string>();
+
+  for (const [pkg, newVersion] of changes) {
+    const edited = handleCancel(
+      await clack.text({
+        message: `${pkg.name}`,
+        initialValue: newVersion,
+        validate: (v) => {
+          if (!v || !/^\d+\.\d+\.\d+/.test(v)) return '无效版本号';
+        },
+      })
+    ) as string;
+    finalChanges.set(pkg, edited);
+  }
+
+  // 预览
+  const preview = packages.map(p => {
+    const newVer = finalChanges.get(p);
+    return newVer ? `${p.name}: ${p.version} → ${newVer}` : `${p.name}: ${p.version} (不变)`;
+  }).join('\n');
+  noteBox(preview, '版本变更预览');
+
+  // 确认写入
+  const confirmed = handleCancel(
+    await clack.confirm({ message: '确认写入版本变更？' })
+  ) as boolean;
+
+  if (confirmed) {
+    applyVersionChanges(finalChanges);
+    clack.log.success('版本已更新');
+  }
+  return finalChanges;
+}
+
+/**
+ * 发布包（按依赖顺序，带进度）
+ */
+async function publishPackages(
+  packages: Package[],
+  analysis: DependencyAnalysis,
+  versionChanges: Map<Package, string>,
+  dryRun?: boolean,
+): Promise<void> {
+  const publishOrder = analysis.order.filter(p => packages.some(sp => sp.name === p.name));
+
+  const confirmed = handleCancel(
+    await clack.confirm({
+      message: `确认发布 ${publishOrder.length} 个包？${dryRun ? ' (dry-run)' : ''}`,
+    })
+  ) as boolean;
+
+  if (!confirmed) return;
+
+  const publisher = new NpmPublisher('https://registry.npmjs.org/');
+  const s = clack.spinner();
+  s.start('发布中...');
+
+  const results = { success: 0, failed: 0, failures: [] as string[] };
+
+  for (const pkg of publishOrder) {
+    s.message(`发布: ${pkg.name}`);
+    try {
+      const result = await publisher.publish(pkg.path, { dryRun });
+      if (result.success > 0) {
+        results.success++;
+      } else {
+        results.failed++;
+        results.failures.push(`${pkg.name}: ${result.failures[0]?.error || '未知错误'}`);
+      }
+    } catch (err) {
+      results.failed++;
+      results.failures.push(`${pkg.name}: ${err}`);
+    }
+  }
+
+  s.stop(`发布完成: ✓${results.success} ✗${results.failed}`);
+
+  if (results.failures.length > 0) {
+    noteBox(results.failures.join('\n'), '失败详情');
+  }
+}
+
+/**
+ * 查看包信息
+ */
+async function showPackageInfo(packages: Package[]): Promise<void> {
+  const name = handleCancel(
+    await clack.select({
+      message: '选择要查看的包',
+      options: packages.map(p => ({
+        value: p.name,
+        label: p.name,
+        hint: p.version,
+      })),
+    })
+  ) as string;
+
+  const s = clack.spinner();
+  s.start(`查询 ${name}...`);
+  try {
+    const info = await queryPackage(name);
+    s.stop();
+    if (!info.exists) {
+      clack.log.warn(`${name} 尚未发布到 npm`);
+    } else {
+      noteBox([
+        `名称: ${info.name}`,
+        `最新版本: ${info.latestVersion}`,
+        `Beta: ${info.betaVersion || '无'}`,
+        `所有版本: ${info.allVersions.length} 个`,
+        `描述: ${info.description || '无'}`,
+      ].join('\n'), 'npm 包信息');
+    }
+  } catch (err) {
+    s.stop(`查询失败: ${err}`);
+  }
+}
+
+/**
+ * 显示配置
+ */
+export async function showConfig(): Promise<void> {
+  const mgr = new RegistryManager();
+  const registries = mgr.getAllRegistries();
+  noteBox(
+    registries.map(r => `${r.id}: ${r.url}${r.isDefault ? ' (默认)' : ''}`).join('\n'),
+    '注册源配置'
+  );
+}
+
+/**
+ * 交互式选择子命令（不带子命令时）
+ */
+export async function interactiveMenu(): Promise<void> {
+  const action = handleCancel(
+    await clack.select({
+      message: '选择操作',
+      options: [
+        { value: 'publish', label: '发布包', hint: '扫描并发布工作空间中的包' },
+        { value: 'config', label: '查看配置', hint: '显示注册源配置' },
+        { value: 'quit', label: '退出' },
+      ],
+    })
+  ) as string;
+
+  switch (action) {
+    case 'publish': {
+      await runApp(resolve('.'));
+      break;
+    }
+    case 'config':
+      await showConfig();
+      break;
+    case 'quit':
+      break;
+  }
+}

package/src/publish/builder.ts

@@ -0,0 +1,120 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import type { Package } from './types.js';
+
+/**
+ * 构建信息
+ */
+export interface BuildInfo {
+  /** 包名 */
+  name: string;
+  /** 是否有构建脚本 */
+  hasBuildScript: boolean;
+  /** 构建脚本命令 */
+  buildScript?: string;
+  /** 输出目录 */
+  outDir?: string;
+  /** 是否需要构建 */
+  needsBuild: boolean;
+}
+
+/**
+ * 检测包的构建配置
+ */
+export function detectBuildConfig(pkg: Package): BuildInfo {
+  const packageJsonPath = join(pkg.path, 'package.json');
+
+  if (!existsSync(packageJsonPath)) {
+    return {
+      name: pkg.name,
+      hasBuildScript: false,
+      needsBuild: false
+    };
+  }
+
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const scripts = packageJson.scripts || {};
+
+    const hasBuildScript = !!scripts.build;
+    const buildScript = scripts.build;
+
+    // 检测输出目录
+    let outDir: string | undefined;
+    if (packageJson.exports) {
+      // 检查 exports 配置
+      const exports = packageJson.exports;
+      if (typeof exports === 'string') {
+        outDir = exports.split('/')[0];
+      } else if (exports['.'] && typeof exports['.'] === 'string') {
+        outDir = exports['.'].split('/')[0];
+      } else if (exports['./package'] && typeof exports['./package'] === 'object') {
+        outDir = exports['./package'].import?.split('/')[0];
+      }
+    } else if (packageJson.main) {
+      outDir = packageJson.main.split('/')[0];
+    } else if (packageJson.types || packageJson.typings) {
+      outDir = (packageJson.types || packageJson.typings).split('/')[0];
+    }
+
+    // 常见的输出目录
+    const commonOutDirs = ['dist', 'build', 'out', 'lib', 'es'];
+    if (!outDir) {
+      for (const dir of commonOutDirs) {
+        if (existsSync(join(pkg.path, dir))) {
+          outDir = dir;
+          break;
+        }
+      }
+    }
+
+    return {
+      name: pkg.name,
+      hasBuildScript,
+      buildScript,
+      outDir,
+      needsBuild: hasBuildScript && !isBuildOutputExists(pkg, outDir)
+    };
+  } catch {
+    return {
+      name: pkg.name,
+      hasBuildScript: false,
+      needsBuild: false
+    };
+  }
+}
+
+/**
+ * 检查构建输出是否存在
+ */
+function isBuildOutputExists(pkg: Package, outDir?: string): boolean {
+  if (!outDir) return false;
+
+  const outPath = join(pkg.path, outDir);
+  return existsSync(outPath);
+}
+
+/**
+ * 批量检测构建配置
+ */
+export function detectBuildConfigs(packages: Package[]): BuildInfo[] {
+  return packages.map(pkg => detectBuildConfig(pkg));
+}
+
+/**
+ * 过滤需要构建的包
+ */
+export function filterPackagesNeedingBuild(packages: Package[]): Package[] {
+  return packages.filter(pkg => {
+    const info = detectBuildConfig(pkg);
+    return info.needsBuild;
+  });
+}
+
+/**
+ * 获取构建脚本命令
+ */
+export function getBuildScript(pkg: Package): string | undefined {
+  const info = detectBuildConfig(pkg);
+  return info.buildScript;
+}

package/src/publish/dependency.ts

@@ -0,0 +1,144 @@
+import type { Package, DependencyAnalysis } from './types.js';
+
+/**
+ * 分析包之间的依赖关系
+ */
+export function analyzeDependencies(packages: Package[]): DependencyAnalysis {
+  const pkgMap = new Map(packages.map(p => [p.name, p]));
+  const graph = new Map<string, Set<string>>();
+
+  // 构建依赖图
+  for (const pkg of packages) {
+    const deps = new Set<string>();
+
+    // 查找包内部依赖
+    for (const depName of pkg.dependencies) {
+      const depPkg = pkgMap.get(depName);
+      if (depPkg && !depPkg.private && depPkg.name !== pkg.name) {
+        deps.add(depName);
+      }
+    }
+
+    graph.set(pkg.name, deps);
+  }
+
+  // 拓扑排序
+  const order: Package[] = [];
+  const visited = new Set<string>();
+  const temp = new Set<string>();
+  const cycles: string[][] = [];
+
+  function visit(pkgName: string, path: string[]): void {
+    if (temp.has(pkgName)) {
+      // 发现循环依赖
+      const cycleStart = path.indexOf(pkgName);
+      const cycle = [...path.slice(cycleStart), pkgName];
+      cycles.push(cycle);
+      return;
+    }
+
+    if (visited.has(pkgName)) {
+      return;
+    }
+
+    temp.add(pkgName);
+
+    const deps = graph.get(pkgName);
+    if (deps) {
+      for (const dep of deps) {
+        visit(dep, [...path, pkgName]);
+      }
+    }
+
+    temp.delete(pkgName);
+    visited.add(pkgName);
+
+    const pkg = pkgMap.get(pkgName);
+    if (pkg) {
+      order.push(pkg);
+    }
+  }
+
+  for (const pkg of packages) {
+    if (!visited.has(pkg.name)) {
+      visit(pkg.name, []);
+    }
+  }
+
+  // 反转顺序，使依赖最少的最先发布
+  order.reverse();
+
+  return {
+    order,
+    graph,
+    hasCycle: cycles.length > 0,
+    cycles
+  };
+}
+
+/**
+ * 检查是否有循环依赖
+ */
+export function checkCircularDependencies(analysis: DependencyAnalysis): boolean {
+  return analysis.hasCycle;
+}
+
+/**
+ * 获取依赖树（用于显示）
+ */
+export function getDependencyTree(
+  packages: Package[],
+  analysis: DependencyAnalysis
+): Array<{ pkg: Package; deps: Package[] }> {
+  const pkgMap = new Map(packages.map(p => [p.name, p]));
+
+  return analysis.order.map(pkg => {
+    const depNames = analysis.graph.get(pkg.name) || new Set();
+    const deps = Array.from(depNames)
+      .map(name => pkgMap.get(name))
+      .filter((p): p is Package => !!p);
+
+    return { pkg, deps };
+  });
+}
+
+/**
+ * 按依赖层级分组
+ */
+export function groupByLevel(
+  packages: Package[],
+  analysis: DependencyAnalysis
+): Package[][] {
+  const levels: Package[][] = [];
+  const placed = new Set<string>();
+
+  const pkgMap = new Map(packages.map(p => [p.name, p]));
+
+  // 找出没有内部依赖的包（第一层）
+  const findLevel = (): Package[] => {
+    const level: Package[] = [];
+
+    for (const pkg of analysis.order) {
+      if (placed.has(pkg.name)) continue;
+
+      const depNames = analysis.graph.get(pkg.name) || new Set();
+      const internalDeps = Array.from(depNames).filter(name => pkgMap.has(name));
+
+      // 所有内部依赖都已放置
+      if (internalDeps.every(dep => placed.has(dep))) {
+        level.push(pkg);
+        placed.add(pkg.name);
+      }
+    }
+
+    return level;
+  };
+
+  while (placed.size < analysis.order.length) {
+    const level = findLevel();
+    if (level.length === 0) break;
+    levels.push(level);
+  }
+
+  return levels;
+}

package/src/publish/detector.ts

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import type { Workspace, WorkspaceType } from './types.js';
+
+/**
+ * 检测工作空间类型
+ */
+export async function detectWorkspace(rootPath: string): Promise<Workspace> {
+  const packageJsonPath = join(rootPath, 'package.json');
+
+  if (!existsSync(packageJsonPath)) {
+    return {
+      type: 'single',
+      rootPath,
+      patterns: ['package.json'],
+      isNpmWorkspace: false
+    };
+  }
+
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+  const workspacesConfig = packageJson.workspaces;
+
+  let type: WorkspaceType = 'single';
+  let patterns: string[] = ['package.json'];
+  let isNpmWorkspace = false;
+
+  if (workspacesConfig) {
+    isNpmWorkspace = true;
+    if (Array.isArray(workspacesConfig)) {
+      patterns = workspacesConfig;
+      type = 'workspace';
+    } else if (workspacesConfig.packages && Array.isArray(workspacesConfig.packages)) {
+      patterns = workspacesConfig.packages;
+      type = 'workspace';
+    } else {
+      // npm workspaces without packages array
+      patterns = ['**/package.json'];
+      type = 'workspace';
+    }
+  } else if (packageJson.name === '@root/workspace' || existsSync(join(rootPath, 'pnpm-workspace.yaml'))) {
+    // 检测 pnpm workspace
+    type = 'monorepo';
+    patterns = ['**/package.json'];
+  } else if (existsSync(join(rootPath, 'lerna.json'))) {
+    // 检测 lerna monorepo
+    type = 'monorepo';
+    const lernaConfig = JSON.parse(readFileSync(join(rootPath, 'lerna.json'), 'utf-8'));
+    patterns = lernaConfig.packages || ['packages/*'];
+  }
+
+  return {
+    type,
+    rootPath,
+    patterns,
+    isNpmWorkspace
+  };
+}
+
+/**
+ * 检查包是否已准备好发布
+ */
+export function checkPublishReadiness(pkg: any): {
+  ready: boolean;
+  issues: string[];
+} {
+  const issues: string[] = [];
+
+  if (!pkg.name) {
+    issues.push('缺少包名');
+  }
+
+  if (!pkg.version) {
+    issues.push('缺少版本号');
+  }
+
+  if (pkg.private) {
+    issues.push('私有包，不能发布');
+  }
+
+  // 检查是否有必要的元数据
+  if (!pkg.description) {
+    issues.push('缺少描述信息');
+  }
+
+  if (!pkg.repository && !pkg.license) {
+    issues.push('缺少仓库信息或许可证');
+  }
+
+  return {
+    ready: issues.length === 0,
+    issues
+  };
+}