@chongyan/autospec 1.0.1

package/scripts/evolution/marketplace.js

@@ -0,0 +1,317 @@
+/**
+ * Marketplace - 插件市场集成
+ *
+ * 实现插件市场发布接口、搜索/安装、生成兼容 Claude Code 的 plugin.json
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import {
+  GLOBAL_AUTOSPEC_DIR,
+  KNOWLEDGE_SCOPE
+} from '../install/constants.js';
+import { getLatestSkillVersion, listSkillVersions, getVersionHistory } from './version-manager.js';
+
+/**
+ * 获取市场目录
+ * @returns {string} 市场目录
+ */
+function getMarketplaceDir() {
+  return path.join(os.homedir(), '.claude/autospec/marketplace');
+}
+
+/**
+ * 获取市场索引文件路径
+ * @returns {string} 索引文件路径
+ */
+function getMarketplaceIndexPath() {
+  return path.join(getMarketplaceDir(), 'index.json');
+}
+
+/**
+ * 安全地读取 JSON 文件
+ * @param {string} filePath - 文件路径
+ * @param {any} defaultValue - 默认值
+ * @returns {any} 解析后的数据
+ */
+function safeReadJson(filePath, defaultValue = null) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return defaultValue;
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(content);
+  } catch (e) {
+    return defaultValue;
+  }
+}
+
+/**
+ * 安全地写入 JSON 文件
+ * @param {string} filePath - 文件路径
+ * @param {any} data - 数据
+ * @returns {boolean} 是否成功
+ */
+function safeWriteJson(filePath, data) {
+  try {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * 生成 plugin.json（Claude Code 格式）
+ *
+ * @param {string} skillName - 技能名称
+ * @param {Object} options - 选项
+ * @returns {Object} plugin.json 内容
+ */
+export function generatePluginJson(skillName, options = {}) {
+  const { version = '1.0.0', description = '', author = '', namespace = 'autospec' } = options;
+
+  // 获取技能内容
+  const content = getLatestSkillVersion(skillName);
+  const versions = listSkillVersions(skillName);
+
+  // 从技能内容中提取描述
+  let skillDescription = description;
+  if (!skillDescription && content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (match) {
+      const frontmatter = match[1];
+      const descMatch = frontmatter.match(/description:\s*(.+)/);
+      if (descMatch) {
+        skillDescription = descMatch[1].trim();
+      }
+    }
+  }
+
+  return {
+    name: `${namespace}-${skillName}`,
+    version,
+    namespace,
+    description: skillDescription || `${skillName} skill`,
+    skills: [
+      {
+        name: skillName,
+        path: `skills/${skillName}/SKILL.md`,
+        versions: versions.map(v => v.version)
+      }
+    ],
+    author: author || 'AutoSpec User',
+    releasedAt: new Date().toISOString()
+  };
+}
+
+/**
+ * 发布到市场
+ *
+ * @param {string} skillName - 技能名称
+ * @param {Object} options - 选项
+ * @returns {Object} 发布结果 { success, marketplaceUrl }
+ */
+export function publishToMarketplace(skillName, options = {}) {
+  const { version = '1.0.0', description = '', author = '', isPublic = false } = options;
+
+  const marketplaceDir = getMarketplaceDir();
+  const skillMarketplaceDir = path.join(marketplaceDir, skillName);
+
+  try {
+    // 创建技能市场目录
+    if (!fs.existsSync(skillMarketplaceDir)) {
+      fs.mkdirSync(skillMarketplaceDir, { recursive: true });
+    }
+
+    // 获取最新版本内容
+    const content = getLatestSkillVersion(skillName);
+    if (!content) {
+      return { success: false, error: '技能不存在或无法获取内容' };
+    }
+
+    // 写入技能文件
+    const skillPath = path.join(skillMarketplaceDir, 'SKILL.md');
+    fs.writeFileSync(skillPath, content);
+
+    // 生成并写入 plugin.json
+    const pluginJson = generatePluginJson(skillName, { version, description, author });
+    const pluginPath = path.join(skillMarketplaceDir, 'plugin.json');
+    safeWriteJson(pluginPath, pluginJson);
+
+    // 更新市场索引
+    const indexPath = getMarketplaceIndexPath();
+    const index = safeReadJson(indexPath, { skills: [], lastUpdated: null });
+
+    const existingIndex = index.skills.findIndex(s => s.name === skillName);
+    const skillEntry = {
+      name: skillName,
+      version,
+      description: pluginJson.description,
+      author,
+      isPublic,
+      publishedAt: new Date().toISOString()
+    };
+
+    if (existingIndex >= 0) {
+      index.skills[existingIndex] = skillEntry;
+    } else {
+      index.skills.push(skillEntry);
+    }
+
+    index.lastUpdated = new Date().toISOString();
+    safeWriteJson(indexPath, index);
+
+    // 生成市场 URL（本地路径）
+    const marketplaceUrl = `file://${skillMarketplaceDir}`;
+
+    return {
+      success: true,
+      marketplaceUrl,
+      skillName,
+      version
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e.message
+    };
+  }
+}
+
+/**
+ * 从市场安装技能
+ *
+ * @param {string} skillName - 技能名称
+ * @param {Object} options - 选项
+ * @returns {Object} 安装结果 { success, path }
+ */
+export function installFromMarketplace(skillName, options = {}) {
+  const { targetScope = KNOWLEDGE_SCOPE.GLOBAL, orgName = null } = options;
+
+  const marketplaceDir = getMarketplaceDir();
+  const skillMarketplaceDir = path.join(marketplaceDir, skillName);
+  const skillPath = path.join(skillMarketplaceDir, 'SKILL.md');
+
+  if (!fs.existsSync(skillPath)) {
+    return { success: false, error: '市场技能不存在' };
+  }
+
+  try {
+    // 读取市场技能内容
+    const content = fs.readFileSync(skillPath, 'utf-8');
+
+    // 目标目录
+    const targetDir = targetScope === KNOWLEDGE_SCOPE.ORG
+      ? path.join(os.homedir(), '.claude/autospec/orgs', orgName, 'skills')
+      : path.join(os.homedir(), GLOBAL_AUTOSPEC_DIR, 'skills');
+
+    const targetPath = path.join(targetDir, skillName);
+
+    // 创建目标目录
+    if (!fs.existsSync(targetPath)) {
+      fs.mkdirSync(targetPath, { recursive: true });
+    }
+
+    // 写入技能文件
+    const targetSkillPath = path.join(targetPath, 'SKILL.md');
+    fs.writeFileSync(targetSkillPath, content);
+
+    return {
+      success: true,
+      path: targetSkillPath
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e.message
+    };
+  }
+}
+
+/**
+ * 搜索市场技能
+ *
+ * @param {string} query - 搜索关键词
+ * @returns {Array} 搜索结果
+ */
+export function searchMarketplace(query) {
+  const indexPath = getMarketplaceIndexPath();
+  const index = safeReadJson(indexPath, { skills: [] });
+
+  if (!query) {
+    return index.skills;
+  }
+
+  const queryLower = query.toLowerCase();
+
+  return index.skills.filter(skill =>
+    skill.name.toLowerCase().includes(queryLower) ||
+    (skill.description && skill.description.toLowerCase().includes(queryLower))
+  );
+}
+
+/**
+ * 获取市场技能列表
+ *
+ * @returns {Array} 技能列表
+ */
+export function listMarketplaceSkills() {
+  const indexPath = getMarketplaceIndexPath();
+  const index = safeReadJson(indexPath, { skills: [], lastUpdated: null });
+
+  return {
+    skills: index.skills,
+    lastUpdated: index.lastUpdated,
+    count: index.skills.length
+  };
+}
+
+/**
+ * 从市场移除技能
+ *
+ * @param {string} skillName - 技能名称
+ * @returns {Object} 移除结果
+ */
+export function removeFromMarketplace(skillName) {
+  const marketplaceDir = getMarketplaceDir();
+  const skillMarketplaceDir = path.join(marketplaceDir, skillName);
+
+  if (!fs.existsSync(skillMarketplaceDir)) {
+    return { success: false, error: '市场技能不存在' };
+  }
+
+  try {
+    // 删除技能目录
+    fs.rmSync(skillMarketplaceDir, { recursive: true });
+
+    // 更新市场索引
+    const indexPath = getMarketplaceIndexPath();
+    const index = safeReadJson(indexPath, { skills: [], lastUpdated: null });
+
+    index.skills = index.skills.filter(s => s.name !== skillName);
+    index.lastUpdated = new Date().toISOString();
+    safeWriteJson(indexPath, index);
+
+    return { success: true };
+  } catch (e) {
+    return {
+      success: false,
+      error: e.message
+    };
+  }
+}
+
+export default {
+  generatePluginJson,
+  publishToMarketplace,
+  installFromMarketplace,
+  searchMarketplace,
+  listMarketplaceSkills,
+  removeFromMarketplace
+};

package/scripts/evolution/version-manager.js

@@ -0,0 +1,371 @@
+/**
+ * Version Manager - 版本管理器
+ *
+ * 实现版本标签管理、回滚逻辑、历史查询
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import {
+  GLOBAL_AUTOSPEC_DIR,
+  KNOWLEDGE_SCOPE
+} from '../install/constants.js';
+
+/**
+ * 获取全局技能目录
+ * @returns {string} 全局技能目录
+ */
+function getGlobalSkillsDir() {
+  return path.join(os.homedir(), GLOBAL_AUTOSPEC_DIR, 'skills');
+}
+
+/**
+ * 获取组织技能目录
+ * @param {string} orgName - 组织名称
+ * @returns {string} 组织技能目录
+ */
+function getOrgSkillsDir(orgName) {
+  return path.join(os.homedir(), '.claude/autospec/orgs', orgName, 'skills');
+}
+
+/**
+ * 安全地读取 JSON 文件
+ * @param {string} filePath - 文件路径
+ * @param {any} defaultValue - 默认值
+ * @returns {any} 解析后的数据
+ */
+function safeReadJson(filePath, defaultValue = null) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return defaultValue;
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(content);
+  } catch (e) {
+    return defaultValue;
+  }
+}
+
+/**
+ * 安全地写入 JSON 文件
+ * @param {string} filePath - 文件路径
+ * @param {any} data - 数据
+ * @returns {boolean} 是否成功
+ */
+function safeWriteJson(filePath, data) {
+  try {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * 解析版本号
+ * @param {string} version - 版本号字符串
+ * @returns {Object} 解析结果 { major, minor, patch, raw }
+ */
+function parseVersion(version) {
+  const match = version.match(/^v?(\d+)\.(\d+)\.(\d+)$/);
+  if (match) {
+    return {
+      major: parseInt(match[1], 10),
+      minor: parseInt(match[2], 10),
+      patch: parseInt(match[3], 10),
+      raw: version
+    };
+  }
+  return { major: 0, minor: 0, patch: 0, raw: version };
+}
+
+/**
+ * 比较版本号
+ * @param {string} v1 - 版本1
+ * @param {string} v2 - 版本2
+ * @returns {number} -1: v1 < v2, 0: v1 = v2, 1: v1 > v2
+ */
+function compareVersions(v1, v2) {
+  const p1 = parseVersion(v1);
+  const p2 = parseVersion(v2);
+
+  if (p1.major !== p2.major) return p1.major - p2.major;
+  if (p1.minor !== p2.minor) return p1.minor - p2.minor;
+  return p1.patch - p2.patch;
+}
+
+/**
+ * 获取技能版本目录
+ * @param {string} skillName - 技能名称
+ * @param {string} scope - 作用域
+ * @param {string} orgName - 组织名称
+ * @returns {string} 技能版本目录
+ */
+function getSkillVersionDir(skillName, scope, orgName = null) {
+  const baseDir = scope === KNOWLEDGE_SCOPE.ORG
+    ? getOrgSkillsDir(orgName)
+    : getGlobalSkillsDir();
+
+  return path.join(baseDir, skillName);
+}
+
+/**
+ * 发布技能新版本
+ *
+ * @param {string} skillName - 技能名称
+ * @param {string} content - 技能内容
+ * @param {Object} options - 选项
+ * @returns {Object} 发布结果 { success, version, path }
+ */
+export function publishSkillVersion(skillName, content, options = {}) {
+  const { scope = KNOWLEDGE_SCOPE.GLOBAL, orgName = null, version = null, message = '' } = options;
+
+  const versionDir = getSkillVersionDir(skillName, scope, orgName);
+
+  // 确定版本号
+  const newVersion = version || getNextVersion(skillName, scope, orgName);
+  const versionPath = path.join(versionDir, `v${newVersion}`);
+
+  try {
+    // 创建版本目录
+    if (!fs.existsSync(versionPath)) {
+      fs.mkdirSync(versionPath, { recursive: true });
+    }
+
+    // 写入技能文件
+    const skillFilePath = path.join(versionPath, 'SKILL.md');
+    fs.writeFileSync(skillFilePath, content);
+
+    // 更新版本历史
+    const historyFilePath = path.join(versionDir, 'versions.json');
+    const history = safeReadJson(historyFilePath, { versions: [], latest: null });
+
+    history.versions = history.versions || [];
+    history.versions.push({
+      version: newVersion,
+      releasedAt: new Date().toISOString(),
+      message: message || `Release v${newVersion}`
+    });
+    history.latest = newVersion;
+
+    safeWriteJson(historyFilePath, history);
+
+    // 更新 latest 符号链接
+    const latestLink = path.join(versionDir, 'latest');
+    if (fs.existsSync(latestLink)) {
+      fs.unlinkSync(latestLink);
+    }
+    // 注意：符号链接创建可能需要管理员权限，这里用副本代替
+    fs.copyFileSync(skillFilePath, path.join(versionDir, 'SKILL.md'));
+
+    return {
+      success: true,
+      version: newVersion,
+      path: skillFilePath
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e.message
+    };
+  }
+}
+
+/**
+ * 获取下一个版本号
+ * @param {string} skillName - 技能名称
+ * @param {string} scope - 作用域
+ * @param {string} orgName - 组织名称
+ * @returns {string} 下一个版本号
+ */
+function getNextVersion(skillName, scope, orgName = null) {
+  const versionDir = getSkillVersionDir(skillName, scope, orgName);
+  const historyFilePath = path.join(versionDir, 'versions.json');
+  const history = safeReadJson(historyFilePath, { versions: [] });
+
+  if (!history.versions || history.versions.length === 0) {
+    return '1.0.0';
+  }
+
+  // 获取最新版本
+  const latestVersion = history.versions[history.versions.length - 1].version;
+  const parsed = parseVersion(latestVersion);
+
+  // 递增 patch 版本
+  parsed.patch += 1;
+
+  return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+}
+
+/**
+ * 回滚到指定版本
+ *
+ * @param {string} skillName - 技能名称
+ * @param {string} targetVersion - 目标版本
+ * @param {Object} options - 选项
+ * @returns {Object} 回滚结果 { success, version }
+ */
+export function rollbackSkillVersion(skillName, targetVersion, options = {}) {
+  const { scope = KNOWLEDGE_SCOPE.GLOBAL, orgName = null } = options;
+
+  const versionDir = getSkillVersionDir(skillName, scope, orgName);
+  const versionPath = path.join(versionDir, `v${targetVersion}`);
+  const skillFilePath = path.join(versionPath, 'SKILL.md');
+
+  if (!fs.existsSync(skillFilePath)) {
+    return { success: false, error: `版本 v${targetVersion} 不存在` };
+  }
+
+  try {
+    // 读取目标版本内容
+    const content = fs.readFileSync(skillFilePath, 'utf-8');
+
+    // 写入当前版本（覆盖 latest）
+    const latestPath = path.join(versionDir, 'SKILL.md');
+    fs.writeFileSync(latestPath, content);
+
+    // 记录回滚历史
+    const historyFilePath = path.join(versionDir, 'versions.json');
+    const history = safeReadJson(historyFilePath, { versions: [], latest: null });
+
+    history.versions.push({
+      version: targetVersion,
+      action: 'rollback',
+      rolledBackAt: new Date().toISOString()
+    });
+    history.latest = targetVersion;
+
+    safeWriteJson(historyFilePath, history);
+
+    return {
+      success: true,
+      version: targetVersion
+    };
+  } catch (e) {
+    return {
+      success: false,
+      error: e.message
+    };
+  }
+}
+
+/**
+ * 获取版本历史
+ *
+ * @param {string} skillName - 技能名称
+ * @param {Object} options - 选项
+ * @returns {Object} 版本历史
+ */
+export function getVersionHistory(skillName, options = {}) {
+  const { scope = KNOWLEDGE_SCOPE.GLOBAL, orgName = null } = options;
+
+  const versionDir = getSkillVersionDir(skillName, scope, orgName);
+  const historyFilePath = path.join(versionDir, 'versions.json');
+
+  return safeReadJson(historyFilePath, { versions: [], latest: null });
+}
+
+/**
+ * 获取所有版本列表
+ *
+ * @param {string} skillName - 技能名称
+ * @param {Object} options - 选项
+ * @returns {Array} 版本列表
+ */
+export function listSkillVersions(skillName, options = {}) {
+  const { scope = KNOWLEDGE_SCOPE.GLOBAL, orgName = null } = options;
+
+  const versionDir = getSkillVersionDir(skillName, scope, orgName);
+
+  if (!fs.existsSync(versionDir)) {
+    return [];
+  }
+
+  const entries = fs.readdirSync(versionDir, { withFileTypes: true });
+  const versions = [];
+
+  for (const entry of entries) {
+    if (entry.isDirectory() && entry.name.startsWith('v')) {
+      const versionPath = path.join(versionDir, entry.name, 'SKILL.md');
+      if (fs.existsSync(versionPath)) {
+        const stats = fs.statSync(versionPath);
+        versions.push({
+          version: entry.name.substring(1), // 去掉 'v' 前缀
+          path: versionPath,
+          releasedAt: stats.mtime.toISOString()
+        });
+      }
+    }
+  }
+
+  // 按版本号排序
+  return versions.sort((a, b) => compareVersions(b.version, a.version));
+}
+
+/**
+ * 获取指定版本内容
+ *
+ * @param {string} skillName - 技能名称
+ * @param {string} version - 版本号
+ * @param {Object} options - 选项
+ * @returns {string|null} 技能内容
+ */
+export function getSkillVersion(skillName, version, options = {}) {
+  const { scope = KNOWLEDGE_SCOPE.GLOBAL, orgName = null } = options;
+
+  const versionDir = getSkillVersionDir(skillName, scope, orgName);
+  const skillFilePath = path.join(versionDir, `v${version}`, 'SKILL.md');
+
+  try {
+    if (fs.existsSync(skillFilePath)) {
+      return fs.readFileSync(skillFilePath, 'utf-8');
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 获取最新版本内容
+ *
+ * @param {string} skillName - 技能名称
+ * @param {Object} options - 选项
+ * @returns {string|null} 技能内容
+ */
+export function getLatestSkillVersion(skillName, options = {}) {
+  const { scope = KNOWLEDGE_SCOPE.GLOBAL, orgName = null } = options;
+
+  const versionDir = getSkillVersionDir(skillName, scope, orgName);
+  const latestPath = path.join(versionDir, 'SKILL.md');
+
+  try {
+    if (fs.existsSync(latestPath)) {
+      return fs.readFileSync(latestPath, 'utf-8');
+    }
+
+    // 尝试从 versions.json 获取最新版本
+    const history = getVersionHistory(skillName, { scope, orgName });
+    if (history.latest) {
+      return getSkillVersion(skillName, history.latest, { scope, orgName });
+    }
+
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+export default {
+  publishSkillVersion,
+  rollbackSkillVersion,
+  getVersionHistory,
+  listSkillVersions,
+  getSkillVersion,
+  getLatestSkillVersion
+};