@mindbase/mindbase 1.0.0

package/src/publish/index.ts

@@ -0,0 +1,66 @@
+export type {
+  WorkspaceType,
+  Workspace,
+  Package,
+  DependencyAnalysis,
+  PublishProgress,
+  PublishOptions,
+  PublishResult
+} from './types.js';
+
+export {
+  detectWorkspace,
+  checkPublishReadiness
+} from './detector.js';
+
+export {
+  scanPackages,
+  getPackageDependencies,
+  findPackageDependencies
+} from './scanner.js';
+
+export {
+  analyzeDependencies,
+  checkCircularDependencies,
+  getDependencyTree,
+  groupByLevel
+} from './dependency.js';
+
+export {
+  bumpVersion,
+  bumpVersions,
+  updatePackageVersion,
+  applyVersionChanges,
+  suggestBumpType,
+  parseVersion,
+  compareVersions,
+  isValidVersion,
+  type BumpType
+} from './version.js';
+
+export {
+  detectBuildConfig,
+  detectBuildConfigs,
+  filterPackagesNeedingBuild,
+  getBuildScript,
+  type BuildInfo
+} from './builder.js';
+
+export {
+  RegistryManager,
+  registryManager,
+  type RegistryConfig,
+  type Publisher
+} from './registry/registry-manager.js';
+
+export { NpmPublisher } from './registry/adapters/npm.js';
+
+// 重新导出 npm 查询功能
+export {
+  NpmPackageQuery,
+  quickQuery as queryPackage,
+  packageExists,
+  getLatestVersion,
+  type PackageQueryResult,
+  type QueryOptions
+} from './npm-query.js';

package/src/publish/npm-query.ts

@@ -0,0 +1,244 @@
+import semver from 'semver';
+
+/**
+ * NPM 包查询结果
+ */
+export interface PackageQueryResult {
+  /** 包是否存在 */
+  exists: boolean;
+  /** 包名 */
+  name: string;
+  /** 包描述 */
+  description?: string;
+  /** 分发标签（latest, beta, next 等） */
+  distTags: { [tag: string]: string };
+  /** 所有版本号 */
+  allVersions: string[];
+  /** 最新稳定版 */
+  latestVersion: string;
+  /** Beta 版本 */
+  betaVersion?: string;
+  /** Next 版本 */
+  nextVersion?: string;
+  /** 稳定版本列表 */
+  stableVersions: string[];
+  /** 预发布版本列表 */
+  prereleaseVersions: string[];
+  /** 创建时间 */
+  createdAt?: string;
+  /** 最后修改时间 */
+  modifiedAt?: string;
+}
+
+/**
+ * 查询选项
+ */
+export interface QueryOptions {
+  /** 请求超时时间（毫秒） */
+  timeout?: number;
+  /** 是否使用缓存 */
+  cache?: boolean;
+  /** 缓存存活时间（毫秒） */
+  cacheTTL?: number;
+}
+
+/**
+ * 缓存项
+ */
+interface CacheItem {
+  data: PackageQueryResult;
+  timestamp: number;
+}
+
+/**
+ * NPM 包查询服务
+ */
+export class NpmPackageQuery {
+  private baseUrl = 'https://registry.npmjs.org';
+  private cache = new Map<string, CacheItem>();
+  private options: Required<QueryOptions>;
+
+  constructor(options: QueryOptions = {}) {
+    this.options = {
+      timeout: 10000,
+      cache: true,
+      cacheTTL: 300000, // 5 分钟
+      ...options
+    };
+  }
+
+  /**
+   * 查询包信息
+   */
+  async query(packageName: string): Promise<PackageQueryResult> {
+    // 检查缓存
+    if (this.options.cache) {
+      const cached = this.cache.get(packageName);
+      if (cached && Date.now() - cached.timestamp < this.options.cacheTTL) {
+        return cached.data;
+      }
+    }
+
+    try {
+      const result = await this.fetchPackageInfo(packageName);
+
+      // 更新缓存
+      if (this.options.cache) {
+        this.cache.set(packageName, {
+          data: result,
+          timestamp: Date.now()
+        });
+      }
+
+      return result;
+    } catch (error) {
+      throw new Error(`查询包 '${packageName}' 失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * 获取分发标签
+   */
+  async getDistTags(packageName: string): Promise<{ [tag: string]: string }> {
+    const info = await this.query(packageName);
+    return info.distTags;
+  }
+
+  /**
+   * 获取所有版本
+   */
+  async getAllVersions(packageName: string): Promise<string[]> {
+    const info = await this.query(packageName);
+    return info.allVersions;
+  }
+
+  /**
+   * 获取指定标签的版本
+   */
+  async getTagVersion(packageName: string, tag: string): Promise<string | undefined> {
+    const distTags = await this.getDistTags(packageName);
+    return distTags[tag];
+  }
+
+  /**
+   * 批量查询
+   */
+  async bulkQuery(packageNames: string[]): Promise<Map<string, PackageQueryResult>> {
+    const results = new Map<string, PackageQueryResult>();
+    const promises = packageNames.map(async (name) => {
+      try {
+        const result = await this.query(name);
+        results.set(name, result);
+      } catch {
+        // 查询失败时返回不存在的结果
+        results.set(name, {
+          exists: false,
+          name,
+          distTags: {},
+          allVersions: [],
+          latestVersion: '',
+          stableVersions: [],
+          prereleaseVersions: []
+        });
+      }
+    });
+
+    await Promise.all(promises);
+    return results;
+  }
+
+  /**
+   * 清除缓存
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * 从 NPM registry 获取包信息
+   */
+  private async fetchPackageInfo(packageName: string): Promise<PackageQueryResult> {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+
+    try {
+      const response = await fetch(`${this.baseUrl}/${packageName}`, {
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        if (response.status === 404) {
+          return {
+            exists: false,
+            name: packageName,
+            distTags: {},
+            allVersions: [],
+            latestVersion: '',
+            stableVersions: [],
+            prereleaseVersions: []
+          };
+        }
+        throw new Error(`HTTP 请求失败: ${response.status}`);
+      }
+
+      const packageData = await response.json() as any;
+      const distTags = packageData['dist-tags'] || {};
+      const allVersions = Object.keys(packageData.versions || {});
+
+      // 分类版本
+      const stableVersions: string[] = [];
+      const prereleaseVersions: string[] = [];
+
+      for (const version of allVersions) {
+        if (semver.prerelease(version)) {
+          prereleaseVersions.push(version);
+        } else {
+          stableVersions.push(version);
+        }
+      }
+
+      return {
+        exists: true,
+        name: packageData.name,
+        description: packageData.description,
+        distTags,
+        allVersions,
+        latestVersion: distTags.latest || '',
+        betaVersion: distTags.beta,
+        nextVersion: distTags.next,
+        stableVersions,
+        prereleaseVersions,
+        createdAt: packageData.time?.created,
+        modifiedAt: packageData.time?.modified
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+/**
+ * 快速查询（静态方法，不使用缓存）
+ */
+export async function quickQuery(packageName: string): Promise<PackageQueryResult> {
+  const query = new NpmPackageQuery({ cache: false });
+  return query.query(packageName);
+}
+
+/**
+ * 查询包是否存在
+ */
+export async function packageExists(packageName: string): Promise<boolean> {
+  const result = await quickQuery(packageName);
+  return result.exists;
+}
+
+/**
+ * 获取包的最新版本
+ */
+export async function getLatestVersion(packageName: string): Promise<string | null> {
+  const result = await quickQuery(packageName);
+  return result.latestVersion || null;
+}

package/src/publish/registry/adapters/npm.ts

@@ -0,0 +1,128 @@
+import { execSync } from 'child_process';
+import fsExtra from 'fs-extra';
+const { readJsonSync } = fsExtra;
+import { join } from 'path';
+import type { Publisher } from '../registry-manager.js';
+import type { PublishOptions, PublishResult } from '../../types.js';
+import type { PackageQueryResult } from '../../npm-query.js';
+
+/**
+ * NPM 发布器
+ */
+export class NpmPublisher implements Publisher {
+  constructor(
+    private registryUrl: string,
+    private queryFn?: (packageName: string) => Promise<PackageQueryResult>
+  ) {}
+
+  /**
+   * 发布包
+   */
+  async publish(pkgPath: string, options: PublishOptions = {}): Promise<PublishResult> {
+    try {
+      const args = ['publish'];
+
+      if (options.dryRun) {
+        args.push('--dry-run');
+      }
+
+      if (options.registryId) {
+        // 使用指定的注册源
+        const registry = this.getRegistryUrl(options.registryId);
+        args.push('--registry', registry);
+      } else if (this.registryUrl !== 'https://registry.npmjs.org/') {
+        args.push('--registry', this.registryUrl);
+      }
+
+      // 执行发布命令
+      execSync(`npm publish ${args.join(' ')}`, {
+        cwd: pkgPath,
+        stdio: 'pipe'
+      });
+
+      return {
+        success: 1,
+        failed: 0,
+        published: [this.getPackageName(pkgPath)],
+        failures: []
+      };
+    } catch (error) {
+      return {
+        success: 0,
+        failed: 1,
+        published: [],
+        failures: [{
+          name: this.getPackageName(pkgPath),
+          error: error instanceof Error ? error.message : String(error)
+        }]
+      };
+    }
+  }
+
+  /**
+   * 检查包是否存在
+   */
+  async exists(packageName: string): Promise<boolean> {
+    if (!this.queryFn) {
+      // 默认使用 fetch
+      try {
+        const response = await fetch(`${this.registryUrl}${packageName}`);
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+
+    try {
+      const result = await this.queryFn(packageName);
+      return result.exists;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 获取包信息
+   */
+  async getPackageInfo(packageName: string): Promise<any> {
+    if (!this.queryFn) {
+      try {
+        const response = await fetch(`${this.registryUrl}${packageName}`);
+        if (!response.ok) {
+          throw new Error(`包 ${packageName} 不存在`);
+        }
+        return response.json();
+      } catch {
+        throw new Error(`获取包信息失败: ${packageName}`);
+      }
+    }
+
+    const result = await this.queryFn(packageName);
+    if (!result.exists) {
+      throw new Error(`包 ${packageName} 不存在`);
+    }
+
+    return result;
+  }
+
+  /**
+   * 获取包名
+   */
+  private getPackageName(pkgPath: string): string {
+    try {
+      const packageJson = readJsonSync(join(pkgPath, 'package.json'));
+      return packageJson.name || '';
+    } catch {
+      return '';
+    }
+  }
+
+  /**
+   * 获取注册源 URL
+   */
+  private getRegistryUrl(registryId: string): string {
+    // 这里可以根据 registryId 返回不同的 URL
+    // 简化实现，直接返回默认的
+    return this.registryUrl;
+  }
+}

package/src/publish/registry/registry-manager.ts

@@ -0,0 +1,107 @@
+import type { PublishOptions, PublishResult } from '../types.js';
+
+/**
+ * 注册源配置
+ */
+export interface RegistryConfig {
+  /** 注册源 ID */
+  id: string;
+  /** 注册源名称 */
+  name: string;
+  /** 注册源 URL */
+  url: string;
+  /** 是否是默认 */
+  isDefault?: boolean;
+}
+
+/**
+ * 发布器接口
+ */
+export interface Publisher {
+  /** 发布包 */
+  publish(pkgPath: string, options: PublishOptions): Promise<PublishResult>;
+  /** 检查包是否存在 */
+  exists(packageName: string): Promise<boolean>;
+  /** 获取包信息 */
+  getPackageInfo(packageName: string): Promise<any>;
+}
+
+/**
+ * 注册源管理器
+ */
+export class RegistryManager {
+  private registries: Map<string, RegistryConfig> = new Map();
+  private publishers: Map<string, Publisher> = new Map();
+
+  constructor() {
+    // 默认 npm 注册源
+    this.addRegistry({
+      id: 'npm',
+      name: 'npm',
+      url: 'https://registry.npmjs.org/',
+      isDefault: true
+    });
+  }
+
+  /**
+   * 添加注册源
+   */
+  addRegistry(config: RegistryConfig): void {
+    this.registries.set(config.id, config);
+  }
+
+  /**
+   * 获取注册源配置
+   */
+  getRegistry(id: string): RegistryConfig | undefined {
+    return this.registries.get(id);
+  }
+
+  /**
+   * 获取所有注册源
+   */
+  getAllRegistries(): RegistryConfig[] {
+    return Array.from(this.registries.values());
+  }
+
+  /**
+   * 获取默认注册源
+   */
+  getDefaultRegistry(): RegistryConfig {
+    return this.registries.get('npm')!;
+  }
+
+  /**
+   * 注册发布器
+   */
+  registerPublisher(id: string, publisher: Publisher): void {
+    this.publishers.set(id, publisher);
+  }
+
+  /**
+   * 获取发布器
+   */
+  getPublisher(id?: string): Publisher {
+    const registryId = id || 'npm';
+    const publisher = this.publishers.get(registryId);
+
+    if (!publisher) {
+      throw new Error(`未找到注册源: ${registryId}`);
+    }
+
+    return publisher;
+  }
+
+  /**
+   * 发布包
+   */
+  async publish(pkgPath: string, options: PublishOptions = {}): Promise<PublishResult> {
+    const registryId = options.registryId || 'npm';
+    const publisher = this.getPublisher(registryId);
+
+    return publisher.publish(pkgPath, options);
+  }
+}
+
+// 创建全局实例
+export const registryManager = new RegistryManager();

package/src/publish/scanner.ts

@@ -0,0 +1,90 @@
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, relative } from 'path';
+import { glob } from 'glob';
+import type { Workspace, Package } from './types.js';
+import { checkPublishReadiness } from './detector.js';
+
+/**
+ * 扫描工作空间中的包
+ */
+export async function scanPackages(workspace: Workspace): Promise<Package[]> {
+  const packages: Package[] = [];
+
+  if (workspace.type === 'single') {
+    const pkg = scanPackage(workspace.rootPath);
+    if (pkg) {
+      packages.push(pkg);
+    }
+  } else {
+    // 使用 glob 匹配所有 package.json
+    const patternList = workspace.patterns.map(p =>
+      join(workspace.rootPath, p, 'package.json')
+    );
+
+    const files = await glob(patternList.join(' '), {
+      cwd: workspace.rootPath,
+      absolute: true
+    });
+
+    for (const file of files) {
+      const pkgDir = join(file, '..');
+      const pkg = scanPackage(pkgDir);
+      if (pkg && !pkg.private) {
+        packages.push(pkg);
+      }
+    }
+  }
+
+  return packages;
+}
+
+/**
+ * 扫描单个包
+ */
+function scanPackage(pkgPath: string): Package | null {
+  const packageJsonPath = join(pkgPath, 'package.json');
+
+  if (!existsSync(packageJsonPath)) {
+    return null;
+  }
+
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+
+    return {
+      name: packageJson.name || '',
+      path: pkgPath,
+      relativePath: relative(process.cwd(), pkgPath),
+      version: packageJson.version || '0.0.0',
+      private: packageJson.private || false,
+      description: packageJson.description,
+      hasBuildScript: !!(packageJson.scripts && packageJson.scripts.build),
+      dependencies: Object.keys(packageJson.dependencies || {}),
+      devDependencies: Object.keys(packageJson.devDependencies || {})
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 获取包的依赖项
+ */
+export function getPackageDependencies(pkg: Package): string[] {
+  return [...pkg.dependencies, ...pkg.devDependencies];
+}
+
+/**
+ * 查找包之间的依赖关系
+ */
+export function findPackageDependencies(
+  packages: Package[],
+  targetPkg: Package
+): Package[] {
+  const deps = getPackageDependencies(targetPkg);
+  const pkgMap = new Map(packages.map(p => [p.name, p]));
+
+  return deps
+    .map(name => pkgMap.get(name))
+    .filter((p): p is Package => !!p && !p.private);
+}