6aspec 2.0.0-dev.2

package/lib/cli.js

@@ -0,0 +1,318 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const installer = require('./installer');
+
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+const WHITE = '\x1b[37m';
+const MAGENTA = '\x1b[35m';
+
+const CONFIG_FILE = '.6aspec/init.json';
+
+const TOOLS = [
+  { id: 'cursor', name: 'Cursor', desc: 'Cursor IDE 配置' },
+  { id: 'claude', name: 'Claude Code', desc: 'Claude Code CLI 配置' },
+];
+
+// ─── Welcome Screen ──────────────────────────────────────────────────
+
+function buildWelcomeScreen() {
+  const logo = [
+    `${CYAN}        ████        ${RESET}`,
+    `${CYAN}      ░░    ░░      ${RESET}`,
+    `${CYAN}        ████        ${RESET}`,
+    `${CYAN}        ████        ${RESET}`,
+    `${CYAN}        ████        ${RESET}`,
+    `${CYAN}      ░░    ░░      ${RESET}`,
+    `${CYAN}        ████        ${RESET}`,
+  ];
+
+  const right = [
+    `${BOLD}${WHITE}Welcome to 6Aspec${RESET}`,
+    `${DIM}A lightweight spec-driven framework${RESET}`,
+    ``,
+    `${YELLOW}This setup will configure:${RESET}`,
+    `  ${GREEN}•${RESET} Agent Skills for AI tools`,
+    `  ${GREEN}•${RESET} /6aspec:* slash commands`,
+    ``,
+    `${YELLOW}Quick start after setup:${RESET}`,
+  ];
+
+  const brownCmds = [
+    `  ${GREEN}/6aspec:brown:new${RESET}        Create a change`,
+    `  ${GREEN}/6aspec:brown:continue${RESET}   Next artifact`,
+    `  ${GREEN}/6aspec:brown:implement${RESET}  Implement tasks`,
+  ];
+
+  const greenCmds = [
+    `  ${GREEN}/6aspec:green:new${RESET}        Create a module`,
+    `  ${GREEN}/6aspec:green:continue${RESET}   Next artifact`,
+    `  ${GREEN}/6aspec:green:execute-task${RESET} Execute tasks`,
+  ];
+
+  const footer = `${DIM}Press Enter to select tools...${RESET}`;
+
+  const lines = [];
+  lines.push('');
+
+  const totalRight = [...right, ``, `  ${MAGENTA}Brownfield (existing project):${RESET}`, ...brownCmds, ``, `  ${MAGENTA}Greenfield (new project):${RESET}`, ...greenCmds];
+
+  const maxLines = Math.max(logo.length, totalRight.length);
+
+  for (let i = 0; i < maxLines; i++) {
+    const l = i < logo.length ? logo[i] : '                    ';
+    const r = i < totalRight.length ? totalRight[i] : '';
+    lines.push(`    ${l}    ${r}`);
+  }
+
+  lines.push('');
+  lines.push(`    ${' '.repeat(20)}    ${footer}`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// ─── Interactive Tool Selection (pure readline, no deps) ────────────
+
+function waitForEnter() {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question('', () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+function selectTools(preSelected) {
+  return new Promise((resolve) => {
+    const selected = TOOLS.map((t) => preSelected.includes(t.id));
+    let cursor = 0;
+
+    const raw = process.stdin.isTTY;
+    if (raw) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    function render() {
+      // Move cursor up to re-render (clear previous lines)
+      const totalLines = TOOLS.length + 4;
+      process.stdout.write(`\x1b[${totalLines}A\x1b[J`);
+      draw();
+    }
+
+    function draw() {
+      console.log('');
+      console.log(`${BOLD}  Select tools to initialize:${RESET}  ${DIM}(↑↓ move, Enter select, Tab confirm)${RESET}`);
+      console.log('');
+      TOOLS.forEach((tool, i) => {
+        const check = selected[i] ? `${GREEN}◉${RESET}` : `○`;
+        const pointer = i === cursor ? `${CYAN}❯${RESET}` : ' ';
+        const locked = preSelected.includes(tool.id) && selected[i] ? ` ${DIM}(installed)${RESET}` : '';
+        console.log(`  ${pointer} ${check}  ${tool.name} ${DIM}- ${tool.desc}${RESET}${locked}`);
+      });
+      console.log('');
+    }
+
+    draw();
+
+    function onKey(key) {
+      if (key === '\u001b[A') {
+        // Up
+        cursor = (cursor - 1 + TOOLS.length) % TOOLS.length;
+        render();
+      } else if (key === '\u001b[B') {
+        // Down
+        cursor = (cursor + 1) % TOOLS.length;
+        render();
+      } else if (key === '\r' || key === '\n') {
+        // Enter = toggle select
+        selected[cursor] = !selected[cursor];
+        render();
+      } else if (key === '\t') {
+        // Tab = confirm
+        cleanup();
+        const result = TOOLS.filter((_, i) => selected[i]).map((t) => t.id);
+        resolve(result);
+      } else if (key === '\u0003') {
+        // Ctrl+C
+        cleanup();
+        process.exit(0);
+      }
+    }
+
+    function cleanup() {
+      process.stdin.removeListener('data', onKey);
+      if (raw) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+    }
+
+    process.stdin.on('data', onKey);
+  });
+}
+
+// ─── Config Management ──────────────────────────────────────────────
+
+function readConfig(targetDir) {
+  const configPath = path.join(targetDir, CONFIG_FILE);
+  if (fs.existsSync(configPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+function writeConfig(targetDir, tools) {
+  const configPath = path.join(targetDir, CONFIG_FILE);
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const config = {
+    version: require('../package.json').version,
+    tools,
+    updatedAt: new Date().toISOString(),
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  return config;
+}
+
+// ─── Parse non-interactive --tool flag ──────────────────────────────
+
+function parseToolFlag(args) {
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === '--tool' || args[i] === '-t') && args[i + 1]) {
+      return args[i + 1].split(',').map((s) => s.trim().toLowerCase());
+    }
+  }
+  return null;
+}
+
+// ─── Commands ───────────────────────────────────────────────────────
+
+async function init(args) {
+  const targetDir = process.cwd();
+  const config = readConfig(targetDir);
+  const preSelected = config ? config.tools : [];
+
+  const toolFlag = parseToolFlag(args);
+
+  let selectedTools;
+
+  if (toolFlag) {
+    // Non-interactive mode
+    const valid = toolFlag.filter((t) => TOOLS.some((tt) => tt.id === t));
+    if (valid.length === 0) {
+      throw new Error(`无效的工具: ${toolFlag.join(', ')}。支持: ${TOOLS.map((t) => t.id).join(', ')}`);
+    }
+    selectedTools = [...new Set([...preSelected, ...valid])];
+    console.log(`\n${GREEN}[INFO]${RESET} 非交互模式：初始化 ${selectedTools.join(', ')}`);
+  } else {
+    // Interactive mode
+    process.stdout.write(buildWelcomeScreen());
+    await waitForEnter();
+    selectedTools = await selectTools(preSelected);
+
+    if (selectedTools.length === 0) {
+      console.log(`\n${YELLOW}[WARN]${RESET} 未选择任何工具，退出。`);
+      return;
+    }
+  }
+
+  console.log('');
+
+  // Determine what's new vs existing
+  const newTools = selectedTools.filter((t) => !preSelected.includes(t));
+  const existingTools = selectedTools.filter((t) => preSelected.includes(t));
+
+  if (existingTools.length > 0) {
+    console.log(`${DIM}  Already installed: ${existingTools.join(', ')} (will merge update)${RESET}`);
+  }
+  if (newTools.length > 0) {
+    console.log(`${GREEN}  New install: ${newTools.join(', ')}${RESET}`);
+  }
+  console.log('');
+
+  // Always install shared .6aspec config (merge for existing, copy for new)
+  const isFirstTime = !config;
+  installer.targetDir = targetDir;
+  installer.mergeMode = !isFirstTime;
+  installer.install6aspec();
+
+  // Install each selected tool
+  for (const tool of selectedTools) {
+    const isNew = newTools.includes(tool);
+    installer.mergeMode = !isNew;
+
+    switch (tool) {
+      case 'cursor':
+        installer.installCursor();
+        break;
+      case 'claude':
+        installer.installClaude();
+        break;
+    }
+  }
+
+  // Save config
+  const savedConfig = writeConfig(targetDir, selectedTools);
+  console.log(`\n${GREEN}[SUCCESS]${RESET} 初始化完成！配置已保存到 ${CONFIG_FILE}`);
+  console.log(`${DIM}  工具: ${selectedTools.join(', ')}${RESET}`);
+  console.log(`${DIM}  版本: ${savedConfig.version}${RESET}\n`);
+}
+
+async function update(args) {
+  const targetDir = process.cwd();
+  const config = readConfig(targetDir);
+
+  if (!config || !config.tools || config.tools.length === 0) {
+    throw new Error(
+      '未找到初始化配置。请先运行 6aspec init 进行初始化。'
+    );
+  }
+
+  const tools = config.tools;
+  const pkgVersion = require('../package.json').version;
+
+  console.log(`\n${CYAN}${BOLD}6Aspec Update${RESET}`);
+  console.log(`${DIM}  当前配置版本: ${config.version || 'unknown'}${RESET}`);
+  console.log(`${DIM}  包版本: ${pkgVersion}${RESET}`);
+  console.log(`${DIM}  已安装工具: ${tools.join(', ')}${RESET}`);
+  console.log('');
+
+  // Always merge mode for update
+  installer.targetDir = targetDir;
+  installer.mergeMode = true;
+
+  installer.install6aspec();
+
+  for (const tool of tools) {
+    switch (tool) {
+      case 'cursor':
+        installer.installCursor();
+        break;
+      case 'claude':
+        installer.installClaude();
+        break;
+    }
+  }
+
+  // Update config version
+  const savedConfig = writeConfig(targetDir, tools);
+  console.log(`\n${GREEN}[SUCCESS]${RESET} 更新完成！`);
+  console.log(`${DIM}  版本: ${savedConfig.version}${RESET}\n`);
+}
+
+module.exports = { init, update };

package/lib/installer.js

@@ -0,0 +1,333 @@
+const fs = require('fs');
+const path = require('path');
+
+class Installer {
+  constructor() {
+    // 获取包目录（安装后）
+    this.packageDir = this.findPackageDir();
+    this.targetDir = process.cwd();
+    this.mergeMode = false; // 合并模式标志
+  }
+
+  // 查找包目录（支持本地开发和 npm 安装）
+  findPackageDir() {
+    // 如果是本地开发，直接使用当前目录
+    if (fs.existsSync(path.join(__dirname, '../.6aspec')) || 
+        fs.existsSync(path.join(__dirname, '../.cursor'))) {
+      return path.join(__dirname, '..');
+    }
+    
+    // 如果是 npm 安装，查找 node_modules
+    let current = __dirname;
+    while (current !== path.dirname(current)) {
+      const sixaspecPath = path.join(current, '.6aspec');
+      const cursorPath = path.join(current, '.cursor');
+      if (fs.existsSync(sixaspecPath) || fs.existsSync(cursorPath)) {
+        return current;
+      }
+      current = path.dirname(current);
+    }
+    
+    throw new Error('未找到 .6aspec 或 .cursor 目录，请确保包已正确安装');
+  }
+
+  // 颜色输出
+  log(message, type = 'info') {
+    const colors = {
+      info: '\x1b[32m[INFO]\x1b[0m',
+      warn: '\x1b[33m[WARN]\x1b[0m',
+      error: '\x1b[31m[ERROR]\x1b[0m',
+      success: '\x1b[32m[SUCCESS]\x1b[0m'
+    };
+    console.log(`${colors[type]} ${message}`);
+  }
+
+  // 备份目录
+  backupDir(targetPath) {
+    if (fs.existsSync(targetPath)) {
+      const backupPath = `${targetPath}.backup.${Date.now()}`;
+      this.log(`备份现有配置到: ${backupPath}`, 'warn');
+      this.copyDir(targetPath, backupPath);
+      return backupPath;
+    }
+    return null;
+  }
+
+  // 递归删除目录
+  removeDir(dirPath) {
+    if (fs.existsSync(dirPath)) {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+          this.removeDir(fullPath);
+        } else {
+          fs.unlinkSync(fullPath);
+        }
+      }
+      fs.rmdirSync(dirPath);
+    }
+  }
+
+  // 递归复制目录（完全覆盖模式）
+  copyDir(src, dest) {
+    // 如果目标目录存在，先完全删除（确保完全覆盖）
+    if (fs.existsSync(dest)) {
+      this.removeDir(dest);
+    }
+    
+    // 重新创建目录并复制
+    fs.mkdirSync(dest, { recursive: true });
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        this.copyDir(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  // 智能合并目录（只更新包中存在的文件，保留用户自定义文件）
+  mergeDir(src, dest) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    let updatedCount = 0;
+    let addedCount = 0;
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        const result = this.mergeDir(srcPath, destPath);
+        updatedCount += result.updated;
+        addedCount += result.added;
+      } else {
+        const exists = fs.existsSync(destPath);
+        fs.copyFileSync(srcPath, destPath);
+        if (exists) {
+          updatedCount++;
+        } else {
+          addedCount++;
+        }
+      }
+    }
+
+    return { updated: updatedCount, added: addedCount };
+  }
+
+  // 获取目录中所有文件的相对路径列表
+  getAllFiles(dir, baseDir = dir) {
+    const files = [];
+    if (!fs.existsSync(dir)) {
+      return files;
+    }
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(baseDir, fullPath);
+
+      if (entry.isDirectory()) {
+        files.push(...this.getAllFiles(fullPath, baseDir));
+      } else {
+        files.push(relativePath);
+      }
+    }
+
+    return files;
+  }
+
+  // 安装公共配置 (.6aspec)
+  install6aspec() {
+    this.log('开始安装公共配置 (.6aspec)...');
+    
+    const sourceDir = path.join(this.packageDir, '.6aspec');
+    const targetDir = path.join(this.targetDir, '.6aspec');
+
+    if (!fs.existsSync(sourceDir)) {
+      this.log('未找到 .6aspec 源目录，跳过', 'warn');
+      return;
+    }
+
+    const targetExists = fs.existsSync(targetDir);
+    
+    if (this.mergeMode && targetExists) {
+      // 智能合并模式
+      this.log('使用智能合并模式（保留用户自定义文件）...');
+      
+      // 统计用户自定义文件
+      const sourceFiles = new Set(this.getAllFiles(sourceDir, sourceDir));
+      const targetFiles = this.getAllFiles(targetDir, targetDir);
+      const customFiles = targetFiles.filter(f => !sourceFiles.has(f));
+      
+      if (customFiles.length > 0) {
+        this.log(`检测到 ${customFiles.length} 个用户自定义文件，将保留`, 'info');
+      }
+      
+      const result = this.mergeDir(sourceDir, targetDir);
+      this.log(`更新了 ${result.updated} 个文件，新增了 ${result.added} 个文件`, 'info');
+      
+      if (customFiles.length > 0) {
+        this.log(`保留了 ${customFiles.length} 个用户自定义文件`, 'info');
+      }
+    } else {
+      // 完全覆盖模式
+      if (targetExists) {
+        this.backupDir(targetDir);
+      }
+      this.log('复制公共配置文件...');
+      this.copyDir(sourceDir, targetDir);
+    }
+    
+    this.log('✓ 公共配置安装完成！', 'success');
+  }
+
+  // 安装 Cursor 配置
+  installCursor() {
+    this.log('开始安装 Cursor 配置...');
+    
+    const sourceDir = path.join(this.packageDir, '.cursor');
+    const targetDir = path.join(this.targetDir, '.cursor');
+
+    if (!fs.existsSync(sourceDir)) {
+      throw new Error('未找到 .cursor 源目录');
+    }
+
+    const targetExists = fs.existsSync(targetDir);
+    
+    if (this.mergeMode && targetExists) {
+      // 智能合并模式
+      this.log('使用智能合并模式（保留用户自定义文件）...');
+      
+      // 只复制 commands 目录
+      const commandsSourceDir = path.join(sourceDir, 'commands');
+      if (fs.existsSync(commandsSourceDir)) {
+        const commandsTargetDir = path.join(targetDir, 'commands');
+        const result = this.mergeDir(commandsSourceDir, commandsTargetDir);
+        this.log(`commands: 更新了 ${result.updated} 个文件，新增了 ${result.added} 个文件`, 'info');
+      }
+    } else {
+      // 完全覆盖模式
+      if (targetExists) {
+        this.backupDir(targetDir);
+      }
+      this.log('复制 Cursor 配置文件...');
+      
+      // 创建目标目录
+      if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+      }
+      
+      // 只复制 commands 目录
+      const commandsSourceDir = path.join(sourceDir, 'commands');
+      if (fs.existsSync(commandsSourceDir)) {
+        const commandsTargetDir = path.join(targetDir, 'commands');
+        this.copyDir(commandsSourceDir, commandsTargetDir);
+      }
+    }
+    
+    this.log('✓ Cursor 配置安装完成！', 'success');
+  }
+
+  // 安装 Claude 配置
+  installClaude() {
+    this.log('开始安装 Claude 配置...');
+    
+    const sourceDir = path.join(this.packageDir, '.claude');
+    const targetDir = path.join(this.targetDir, '.claude');
+
+    if (!fs.existsSync(sourceDir)) {
+      this.log('未找到 .claude 源目录，跳过', 'warn');
+      return;
+    }
+
+    const targetExists = fs.existsSync(targetDir);
+    
+    // 创建目标目录结构
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    if (this.mergeMode && targetExists) {
+      // 智能合并模式
+      this.log('使用智能合并模式（保留用户自定义文件）...');
+      
+      // 复制 commands
+      const commandsDir = path.join(sourceDir, 'commands');
+      if (fs.existsSync(commandsDir)) {
+        const targetCommandsDir = path.join(targetDir, 'commands');
+        const result = this.mergeDir(commandsDir, targetCommandsDir);
+        if (result.updated > 0 || result.added > 0) {
+          this.log(`commands: 更新了 ${result.updated} 个文件，新增了 ${result.added} 个文件`, 'info');
+        }
+      }
+    } else {
+      // 完全覆盖模式
+      if (targetExists) {
+        this.backupDir(targetDir);
+      }
+      this.log('复制 Claude 配置文件...');
+      
+      // 复制 commands
+      const commandsDir = path.join(sourceDir, 'commands');
+      if (fs.existsSync(commandsDir)) {
+        const targetCommandsDir = path.join(targetDir, 'commands');
+        this.copyDir(commandsDir, targetCommandsDir);
+      }
+    }
+    
+    this.log('✓ Claude 配置安装完成！', 'success');
+  }
+
+  // 主安装方法
+  async install(tool = 'cursor', mergeMode = false) {
+    this.mergeMode = mergeMode;
+    
+    this.log(`6A-spec 安装工具`);
+    this.log(`目标目录: ${this.targetDir}`);
+    this.log(`工具: ${tool}`);
+    if (mergeMode) {
+      this.log(`模式: 智能合并（保留用户自定义文件）`, 'info');
+    } else {
+      this.log(`模式: 完全覆盖（会先备份现有配置）`, 'info');
+    }
+
+    try {
+      // 无论安装哪个工具，都要先安装公共配置
+      this.install6aspec();
+      
+      switch (tool.toLowerCase()) {
+        case 'cursor':
+          this.installCursor();
+          break;
+        case 'claude':
+          this.installClaude();
+          break;
+        case 'all':
+          this.installCursor();
+          this.installClaude();
+          break;
+        default:
+          throw new Error(`未知工具: ${tool}\n支持的工具: cursor, claude, all`);
+      }
+
+      this.log('安装完成！', 'success');
+    } catch (error) {
+      this.log(error.message, 'error');
+      throw error;
+    }
+  }
+}
+
+module.exports = new Installer();
+

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "6aspec",
+  "version": "2.0.0-dev.2",
+  "description": "6Aspec - 轻量级 spec 驱动开发框架，支持 Cursor 和 Claude Code",
+  "main": "lib/installer.js",
+  "bin": {
+    "6aspec": "./bin/6aspec"
+  },
+  "scripts": {
+    "test": "node bin/6aspec --help",
+    "version:dev": "npm version prerelease --preid=dev --no-git-tag-version",
+    "version:beta": "npm version prerelease --preid=beta --no-git-tag-version",
+    "version:rc": "npm version prerelease --preid=rc --no-git-tag-version",
+    "version:patch": "npm version patch --no-git-tag-version",
+    "version:minor": "npm version minor --no-git-tag-version",
+    "version:major": "npm version major --no-git-tag-version",
+    "version:dev:git": "npm version prerelease --preid=dev",
+    "version:beta:git": "npm version prerelease --preid=beta",
+    "version:rc:git": "npm version prerelease --preid=rc",
+    "version:patch:git": "npm version patch",
+    "version:minor:git": "npm version minor",
+    "version:major:git": "npm version major",
+    "publish:dev": "npm run version:dev && npm publish --tag dev",
+    "publish:beta": "npm run version:beta && npm publish --tag beta",
+    "publish:rc": "npm run version:rc && npm publish --tag rc",
+    "publish:latest": "npm run version:patch && npm publish",
+    "publish:dev:otp": "npm run version:dev && npm publish --tag dev --otp",
+    "publish:beta:otp": "npm run version:beta && npm publish --tag beta --otp",
+    "publish:rc:otp": "npm run version:rc && npm publish --tag rc --otp",
+    "publish:latest:otp": "npm run version:patch && npm publish --otp",
+    "publish:dev:git": "npm run version:dev:git && npm publish --tag dev",
+    "publish:beta:git": "npm run version:beta:git && npm publish --tag beta",
+    "publish:rc:git": "npm run version:rc:git && npm publish --tag rc",
+    "publish:latest:git": "npm run version:patch:git && npm publish"
+  },
+  "keywords": [
+    "cursor",
+    "claude",
+    "ai",
+    "prompts",
+    "spec-driven",
+    "development",
+    "6aspec"
+  ],
+  "author": "yanghuijava@gmail.com",
+  "license": "MIT",
+  "files": [
+    "bin/",
+    "lib/",
+    ".cursor/",
+    ".claude/",
+    ".6aspec/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/yanghuijava/6-a-spec.git"
+  }
+}