@chatbi-v/core 3.0.0 → 3.1.1

package/dist/semver/index.cjs

@@ -0,0 +1,449 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/semver/index.ts
+var semver_exports = {};
+__export(semver_exports, {
+  checkCompatibility: () => checkCompatibility,
+  clean: () => clean,
+  coerce: () => coerce,
+  compareVersions: () => compareVersions,
+  detectConflicts: () => detectConflicts,
+  flattenDependencies: () => flattenDependencies,
+  getMajorMinorPatch: () => getMajorMinorPatch,
+  getVersionType: () => getVersionType,
+  isBreakingChange: () => isBreakingChange,
+  isPrerelease: () => isPrerelease,
+  isValidRange: () => isValidRange,
+  isValidVersion: () => isValidVersion,
+  isZeroVersion: () => isZeroVersion,
+  maxSatisfying: () => maxSatisfying,
+  minSatisfying: () => minSatisfying,
+  parseRange: () => parseRange,
+  parseVersion: () => parseVersion,
+  resolveDependencies: () => resolveDependencies,
+  satisfiesVersion: () => satisfiesVersion,
+  satisfyVersions: () => satisfyVersions,
+  selectBestVersion: () => selectBestVersion
+});
+module.exports = __toCommonJS(semver_exports);
+
+// src/semver/DependencyNegotiation.ts
+var import_semver2 = __toESM(require("semver"), 1);
+
+// src/semver/SemverResolver.ts
+var import_semver = __toESM(require("semver"), 1);
+function parseVersion(version) {
+  const parsed = import_semver.default.valid(version);
+  if (!parsed) return null;
+  const v = new import_semver.default.SemVer(version);
+  return {
+    major: v.major,
+    minor: v.minor,
+    patch: v.patch,
+    prerelease: v.prerelease.map(String),
+    build: v.build.map(String),
+    version: v.version,
+    raw: version
+  };
+}
+function parseRange(range) {
+  const parsed = import_semver.default.validRange(range);
+  if (!parsed) return null;
+  return new import_semver.default.Range(range);
+}
+function isValidVersion(version) {
+  return import_semver.default.valid(version) !== null;
+}
+function isValidRange(range) {
+  return import_semver.default.validRange(range) !== null;
+}
+function coerce(version) {
+  const coerced = import_semver.default.coerce(version);
+  if (!coerced) return null;
+  return parseVersion(coerced.version);
+}
+function clean(version) {
+  return import_semver.default.clean(version);
+}
+function compareVersions(v1, v2) {
+  return import_semver.default.compare(v1, v2);
+}
+function satisfyVersions(range, versions) {
+  return versions.filter((v) => import_semver.default.satisfies(v, range));
+}
+function maxSatisfying(range, versions) {
+  return import_semver.default.maxSatisfying(versions, range);
+}
+function minSatisfying(range, versions) {
+  return import_semver.default.minSatisfying(versions, range);
+}
+
+// src/semver/DependencyNegotiation.ts
+function resolveDependencies(plugins) {
+  const resolved = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  const warnings = [];
+  const allDependencies = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    for (const dep of plugin.dependencies) {
+      if (!allDependencies.has(dep.id)) {
+        allDependencies.set(dep.id, []);
+      }
+      allDependencies.get(dep.id).push({
+        pluginId: plugin.id,
+        range: dep.version,
+        optional: dep.optional ?? false
+      });
+    }
+  }
+  for (const [depId, requests] of allDependencies) {
+    if (requests.length === 1) {
+      const req = requests[0];
+      const version = resolveSingleDependency(depId, req.range);
+      if (version) {
+        resolved.set(depId, {
+          id: depId,
+          version,
+          resolvedFrom: req.range,
+          compatible: true
+        });
+      } else if (!req.optional) {
+        warnings.push(
+          `\u65E0\u6CD5\u89E3\u6790\u4F9D\u8D56 ${depId} (${req.range}) from ${req.pluginId}`
+        );
+      }
+    } else {
+      const negotiationResult = negotiateVersion(depId, requests);
+      if (negotiationResult.version) {
+        resolved.set(depId, {
+          id: depId,
+          version: negotiationResult.version,
+          resolvedFrom: negotiationResult.resolvedFrom,
+          compatible: negotiationResult.compatible
+        });
+      }
+      if (negotiationResult.conflict) {
+        conflicts.push(negotiationResult.conflict);
+      }
+    }
+  }
+  const cycleWarnings = detectCycles(plugins);
+  warnings.push(...cycleWarnings);
+  return {
+    dependencies: Array.from(resolved.values()),
+    conflicts,
+    warnings
+  };
+}
+function resolveSingleDependency(depId, range) {
+  const parsed = parseRange(range);
+  if (!parsed) {
+    if (import_semver2.default.valid(range)) {
+      return range;
+    }
+    return null;
+  }
+  return null;
+}
+function negotiateVersion(depId, requests) {
+  const ranges = requests.map((r) => r.range);
+  const requestedBy = requests.map((r) => r.pluginId);
+  const exactVersions = requests.filter((r) => import_semver2.default.valid(r.range));
+  if (exactVersions.length > 1) {
+    const versions = [...new Set(exactVersions.map((r) => r.range))];
+    if (versions.length > 1) {
+      let allCompatible = true;
+      for (let i = 0; i < versions.length; i++) {
+        for (let j = i + 1; j < versions.length; j++) {
+          if (!import_semver2.default.satisfies(versions[i], `^${versions[j]}`) && !import_semver2.default.satisfies(versions[j], `^${versions[i]}`)) {
+            allCompatible = false;
+            break;
+          }
+        }
+      }
+      if (!allCompatible) {
+        return {
+          compatible: false,
+          conflict: {
+            dependency: depId,
+            versions,
+            requestedBy,
+            message: `\u4F9D\u8D56 ${depId} \u5B58\u5728\u4E0D\u53EF\u8C03\u548C\u7684\u7248\u672C\u51B2\u7A81: ${versions.join(" vs ")}`
+          }
+        };
+      }
+    }
+  }
+  const sortedRanges = [...ranges].sort((a, b) => {
+    const aParsed = parseRange(a);
+    const bParsed = parseRange(b);
+    if (!aParsed || !bParsed) return 0;
+    const aMajor = aParsed.set?.[0]?.[0]?.semver?.major ?? 0;
+    const bMajor = bParsed.set?.[0]?.[0]?.semver?.major ?? 0;
+    return bMajor - aMajor;
+  });
+  return {
+    version: sortedRanges[0],
+    resolvedFrom: sortedRanges[0],
+    compatible: true
+  };
+}
+function selectBestVersion(versions, range) {
+  if (!parseRange(range)) {
+    return versions.includes(range) ? range : null;
+  }
+  return maxSatisfying(range, versions);
+}
+function detectConflicts(deps) {
+  const conflicts = [];
+  const depMap = /* @__PURE__ */ new Map();
+  for (const dep of deps) {
+    if (!depMap.has(dep.id)) {
+      depMap.set(dep.id, []);
+    }
+    depMap.get(dep.id).push({ pluginId: dep.id, version: dep.version });
+  }
+  for (const [depId, requests] of depMap) {
+    if (requests.length > 1) {
+      const versions = requests.map((r) => r.version);
+      const uniqueVersions = [...new Set(versions)];
+      if (uniqueVersions.length > 1) {
+        let allCompatible = true;
+        for (let i = 0; i < uniqueVersions.length; i++) {
+          for (let j = i + 1; j < uniqueVersions.length; j++) {
+            if (!import_semver2.default.satisfies(uniqueVersions[i], uniqueVersions[j]) && !import_semver2.default.satisfies(uniqueVersions[j], uniqueVersions[i])) {
+              allCompatible = false;
+              break;
+            }
+          }
+        }
+        if (!allCompatible) {
+          conflicts.push({
+            dependency: depId,
+            versions: uniqueVersions,
+            requestedBy: requests.map((r) => r.pluginId),
+            message: `\u4F9D\u8D56 ${depId} \u7248\u672C\u51B2\u7A81: ${uniqueVersions.join(" vs ")}`
+          });
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function detectCycles(plugins) {
+  const warnings = [];
+  const graph = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    graph.set(
+      plugin.id,
+      plugin.dependencies.map((d) => d.id)
+    );
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const dfs = (node, path) => {
+    if (recursionStack.has(node)) {
+      const cycleStart = path.indexOf(node);
+      const cycle = [...path.slice(cycleStart), node].join(" -> ");
+      warnings.push(`\u5FAA\u73AF\u4F9D\u8D56\u68C0\u6D4B: ${cycle}`);
+      return true;
+    }
+    if (visited.has(node)) return false;
+    visited.add(node);
+    recursionStack.add(node);
+    const deps = graph.get(node) || [];
+    for (const dep of deps) {
+      if (dfs(dep, [...path, node])) {
+        return true;
+      }
+    }
+    recursionStack.delete(node);
+    return false;
+  };
+  for (const plugin of plugins) {
+    dfs(plugin.id, []);
+  }
+  return warnings;
+}
+function flattenDependencies(plugins) {
+  const allDeps = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    for (const dep of plugin.dependencies) {
+      if (!allDeps.has(dep.id)) {
+        allDeps.set(dep.id, dep);
+      }
+    }
+  }
+  return Array.from(allDeps.values());
+}
+
+// src/semver/VersionCompatibility.ts
+var import_semver3 = __toESM(require("semver"), 1);
+function satisfiesVersion(version, range) {
+  return import_semver3.default.satisfies(version, range);
+}
+function checkCompatibility(current, required) {
+  if (!import_semver3.default.satisfies(current, required)) {
+    const currentParsed2 = parseVersion(current);
+    const requiredParsed2 = parseRange(required);
+    if (!currentParsed2 || !requiredParsed2) {
+      return {
+        compatible: false,
+        reason: "\u7248\u672C\u89E3\u6790\u5931\u8D25",
+        severity: "major"
+      };
+    }
+    const reqSet = requiredParsed2.set;
+    const reqParts = reqSet?.[0] || [];
+    if (reqParts.length > 0) {
+      const reqMajor = reqParts[0]?.semver?.major ?? 0;
+      const reqMinor = reqParts[0]?.semver?.minor ?? 0;
+      if (currentParsed2.major !== reqMajor) {
+        return {
+          compatible: false,
+          reason: `\u4E3B\u7248\u672C\u4E0D\u517C\u5BB9: \u5F53\u524D ${currentParsed2.major}, \u8981\u6C42 ${reqMajor}`,
+          severity: "major"
+        };
+      }
+      if (currentParsed2.minor < reqMinor) {
+        return {
+          compatible: false,
+          reason: `\u6B21\u7248\u672C\u4E0D\u517C\u5BB9: \u5F53\u524D ${currentParsed2.minor}, \u8981\u6C42 ${reqMinor}`,
+          severity: "minor"
+        };
+      }
+    }
+    return {
+      compatible: false,
+      reason: "\u7248\u672C\u4E0D\u6EE1\u8DB3\u8303\u56F4\u8981\u6C42",
+      severity: "patch"
+    };
+  }
+  const currentParsed = parseVersion(current);
+  if (!currentParsed) {
+    return { compatible: true, severity: "none" };
+  }
+  const requiredParsed = parseRange(required);
+  if (requiredParsed && requiredParsed.set.length > 0) {
+    const reqSemVer = requiredParsed.set[0]?.[0]?.semver;
+    if (reqSemVer) {
+      const reqMajor = reqSemVer.major ?? 0;
+      const reqMinor = reqSemVer.minor ?? 0;
+      const reqPatch = reqSemVer.patch ?? 0;
+      if (currentParsed.major > reqMajor) {
+        return { compatible: true, severity: "major" };
+      }
+      if (currentParsed.major < reqMajor) {
+        return {
+          compatible: false,
+          reason: `\u4E3B\u7248\u672C\u4F4E\u4E8E\u8981\u6C42`,
+          severity: "major"
+        };
+      }
+      if (currentParsed.minor > reqMinor) {
+        return { compatible: true, severity: "minor" };
+      }
+      if (currentParsed.minor < reqMinor) {
+        return {
+          compatible: false,
+          reason: `\u6B21\u7248\u672C\u4F4E\u4E8E\u8981\u6C42`,
+          severity: "minor"
+        };
+      }
+      if (currentParsed.patch >= reqPatch) {
+        return { compatible: true, severity: "patch" };
+      }
+      return {
+        compatible: false,
+        reason: `\u8865\u4E01\u7248\u672C\u4F4E\u4E8E\u8981\u6C42`,
+        severity: "patch"
+      };
+    }
+  }
+  return { compatible: true, severity: "none" };
+}
+function getMajorMinorPatch(version) {
+  const parsed = parseVersion(version);
+  if (!parsed) return null;
+  return {
+    major: parsed.major,
+    minor: parsed.minor,
+    patch: parsed.patch
+  };
+}
+function isBreakingChange(current, next) {
+  const currentParsed = parseVersion(current);
+  const nextParsed = parseVersion(next);
+  if (!currentParsed || !nextParsed) {
+    return false;
+  }
+  return nextParsed.major !== currentParsed.major;
+}
+function isPrerelease(version) {
+  const parsed = parseVersion(version);
+  return parsed ? parsed.prerelease.length > 0 : false;
+}
+function isZeroVersion(version) {
+  const parsed = parseVersion(version);
+  return parsed ? parsed.major === 0 : false;
+}
+function getVersionType(version) {
+  if (isZeroVersion(version)) return "zero";
+  if (isPrerelease(version)) return "prerelease";
+  if (isValidVersion2(version)) return "release";
+  return "invalid";
+}
+function isValidVersion2(version) {
+  return import_semver3.default.valid(version) !== null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkCompatibility,
+  clean,
+  coerce,
+  compareVersions,
+  detectConflicts,
+  flattenDependencies,
+  getMajorMinorPatch,
+  getVersionType,
+  isBreakingChange,
+  isPrerelease,
+  isValidRange,
+  isValidVersion,
+  isZeroVersion,
+  maxSatisfying,
+  minSatisfying,
+  parseRange,
+  parseVersion,
+  resolveDependencies,
+  satisfiesVersion,
+  satisfyVersions,
+  selectBestVersion
+});

package/dist/semver/index.d.cts

@@ -0,0 +1,192 @@
+import { D as Dependency } from '../plugin-port-CHRPxDOi.cjs';
+import { Range } from 'semver';
+import 'zod';
+
+/** 依赖冲突 */
+interface Conflict {
+    dependency: string;
+    versions: string[];
+    requestedBy: string[];
+    message: string;
+}
+/** 解析后的依赖 */
+interface ResolvedDependency {
+    id: string;
+    version: string;
+    resolvedFrom: string;
+    compatible: boolean;
+}
+/** 依赖解析结果 */
+interface ResolvedDependencies {
+    dependencies: ResolvedDependency[];
+    conflicts: Conflict[];
+    warnings: string[];
+}
+/** 插件依赖输入 */
+interface PluginDependencyInput {
+    id: string;
+    dependencies: Dependency[];
+}
+/**
+ * 解析依赖
+ * @param plugins 插件列表及其依赖
+ * @returns 解析后的依赖结果
+ */
+declare function resolveDependencies(plugins: PluginDependencyInput[]): ResolvedDependencies;
+/**
+ * 从可用版本列表中选择最佳版本
+ * @param versions 可用版本列表
+ * @param range 版本范围
+ * @returns 最佳版本，不存在返回 null
+ */
+declare function selectBestVersion(versions: string[], range: string): string | null;
+/**
+ * 检测依赖冲突
+ * @param deps 依赖列表
+ * @returns 冲突列表
+ */
+declare function detectConflicts(deps: Dependency[]): Conflict[];
+/**
+ * 简化依赖图
+ * @param plugins 插件列表
+ * @returns 扁平化的依赖列表
+ */
+declare function flattenDependencies(plugins: PluginDependencyInput[]): Dependency[];
+
+/**
+ * Semver 版本解析器
+ * @description 提供语义版本解析、验证和转换功能，基于 semver 库
+ */
+
+/** 解析后的语义版本 */
+interface SemverVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string[];
+    build: string[];
+    version: string;
+    raw: string;
+}
+/**
+ * 解析精确版本字符串
+ * @param version 版本字符串 (如 "1.2.3", "1.0.0-alpha")
+ * @returns 解析后的版本对象，解析失败返回 null
+ */
+declare function parseVersion(version: string): SemverVersion | null;
+/**
+ * 解析版本范围字符串
+ * @param range 版本范围 (如 "^1.0.0", "~1.2.3", ">=1.0.0 <2.0.0")
+ * @returns 解析后的范围对象，解析失败返回 null
+ */
+declare function parseRange(range: string): Range | null;
+/**
+ * 验证是否为有效的精确版本
+ * @param version 版本字符串
+ * @returns 是否有效
+ */
+declare function isValidVersion(version: string): boolean;
+/**
+ * 验证是否为有效的版本范围
+ * @param range 版本范围字符串
+ * @returns 是否有效
+ */
+declare function isValidRange(range: string): boolean;
+/**
+ * 强制转换版本字符串为标准格式
+ * @param version 版本字符串 (如 "v2", "2", "1.2")
+ * @returns 转换后的版本 (如 "2.0.0", "1.2.0")
+ */
+declare function coerce(version: string): SemverVersion | null;
+/**
+ * 清理版本字符串
+ * @param version 版本字符串
+ * @returns 清理后的版本，失败返回 null
+ */
+declare function clean(version: string): string | null;
+/**
+ * 比较两个版本
+ * @param v1 版本1
+ * @param v2 版本2
+ * @returns -1: v1 < v2, 0: v1 == v2, 1: v1 > v2
+ */
+declare function compareVersions(v1: string, v2: string): number;
+/**
+ * 获取版本范围的所有可满足版本
+ * @param range 版本范围
+ * @param versions 可用版本列表
+ * @returns 满足范围的版本列表
+ */
+declare function satisfyVersions(range: string, versions: string[]): string[];
+/**
+ * 获取范围内的最高版本
+ * @param range 版本范围
+ * @param versions 可用版本列表
+ * @returns 最高版本，不存在返回 null
+ */
+declare function maxSatisfying(range: string, versions: string[]): string | null;
+/**
+ * 获取范围内的最低版本
+ * @param range 版本范围
+ * @param versions 可用版本列表
+ * @returns 最低版本，不存在返回 null
+ */
+declare function minSatisfying(range: string, versions: string[]): string | null;
+
+/** 兼容性检查结果 */
+interface CompatibilityResult {
+    compatible: boolean;
+    reason?: string;
+    severity: 'none' | 'patch' | 'minor' | 'major';
+}
+/**
+ * 检查版本是否满足版本范围
+ * @param version 精确版本 (如 "1.2.3")
+ * @param range 版本范围 (如 "^1.0.0")
+ * @returns 是否满足
+ */
+declare function satisfiesVersion(version: string, range: string): boolean;
+/**
+ * 检查两个版本之间的兼容性
+ * @param current 当前版本
+ * @param required 要求的版本
+ * @returns 兼容性结果
+ */
+declare function checkCompatibility(current: string, required: string): CompatibilityResult;
+/**
+ * 获取版本的主版本号、次版本号、补丁号
+ * @param version 版本字符串
+ * @returns 分解后的版本号对象
+ */
+declare function getMajorMinorPatch(version: string): {
+    major: number;
+    minor: number;
+    patch: number;
+} | null;
+/**
+ * 检测是否为破坏性变更
+ * @param current 当前版本
+ * @param next 下一个版本
+ * @returns 是否为破坏性变更 (主版本变化)
+ */
+declare function isBreakingChange(current: string, next: string): boolean;
+/**
+ * 检查是否为预发布版本
+ * @param version 版本字符串
+ * @returns 是否为预发布版本
+ */
+declare function isPrerelease(version: string): boolean;
+/**
+ * 检查是否为零版本 (0.x.x)
+ * @param version 版本字符串
+ * @returns 是否为零版本
+ */
+declare function isZeroVersion(version: string): boolean;
+/**
+ * 获取版本类型
+ * @param version 版本字符串
+ * @returns 版本类型: release, prerelease, zero
+ */
+declare function getVersionType(version: string): 'release' | 'prerelease' | 'zero' | 'invalid';
+
+export { type CompatibilityResult, type Conflict, type PluginDependencyInput, type ResolvedDependencies, type ResolvedDependency, type SemverVersion, checkCompatibility, clean, coerce, compareVersions, detectConflicts, flattenDependencies, getMajorMinorPatch, getVersionType, isBreakingChange, isPrerelease, isValidRange, isValidVersion, isZeroVersion, maxSatisfying, minSatisfying, parseRange, parseVersion, resolveDependencies, satisfiesVersion, satisfyVersions, selectBestVersion };