kld-sdd 1.0.0

package/lib/init.js

@@ -0,0 +1,607 @@
+/**
+ * KLD SDD 初始化核心逻辑
+ * 
+ * 功能：
+ * 1. 检测并自动安装 openspec
+ * 2. 执行 openspec init 生成基础结构
+ * 3. 覆盖 opsx 命令（替换为4个独立命令）
+ * 4. 覆盖 openspec-* skill
+ * 5. 复制标准文档模版到项目
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const readline = require('readline');
+const os = require('os');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// 工具类型配置
+const TOOL_CONFIGS = {
+  cursor: {
+    name: 'Cursor',
+    configDir: '.cursor',
+    commandsDir: '.cursor/commands',
+    opsxDir: '.cursor/commands/opsx',
+    teamConfigDir: 'team-configs/cursor-commands'
+  },
+  claude: {
+    name: 'Claude Code',
+    configDir: '.claude',
+    commandsDir: '.claude/commands',
+    opsxDir: '.claude/commands/opsx',
+    teamConfigDir: 'team-configs/claude-commands'
+  },
+  codebuddy: {
+    name: 'CodeBuddy',
+    configDir: '.codebuddy',
+    commandsDir: '.codebuddy/commands',
+    opsxDir: '.codebuddy/commands/opsx',
+    teamConfigDir: 'team-configs/codebuddy-commands'
+  }
+};
+
+/**
+ * 询问用户选择
+ */
+function ask(question) {
+  return new Promise(resolve => {
+    rl.question(question, answer => resolve(answer.trim()));
+  });
+}
+
+/**
+ * 检查命令是否可用
+ */
+function commandExists(command) {
+  try {
+    if (os.platform() === 'win32') {
+      execSync(`where ${command}`, { stdio: 'ignore' });
+    } else {
+      execSync(`which ${command}`, { stdio: 'ignore' });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 获取包安装路径
+ */
+function getPackagePath() {
+  // 尝试多种方式找到包的路径
+  try {
+    // 方式1：通过 require.resolve 找到包位置
+    const mainPath = require.resolve('../package.json');
+    return path.dirname(mainPath);
+  } catch {
+    // 方式2：使用当前文件位置
+    return path.resolve(__dirname, '..');
+  }
+}
+
+/**
+ * 获取模版路径
+ */
+function getTemplatePath() {
+  const pkgPath = getPackagePath();
+  return path.join(pkgPath, 'templates', 'openspec');
+}
+
+/**
+ * 自动安装 openspec
+ */
+async function installOpenspec() {
+  console.log('📦 openspec 未安装，正在自动安装...');
+  
+  const npmCmd = os.platform() === 'win32' ? 'npm.cmd' : 'npm';
+  
+  try {
+    // 尝试全局安装
+    console.log('   正在执行: npm install -g @openspec/cli');
+    execSync(`${npmCmd} install -g @openspec/cli`, { 
+      stdio: 'inherit',
+      timeout: 120000
+    });
+    console.log('✅ openspec 安装完成');
+    return true;
+  } catch (error) {
+    console.log('❌ 全局安装失败，尝试本地安装...');
+    
+    try {
+      // 本地安装到当前项目
+      const cwd = process.cwd();
+      execSync(`${npmCmd} install @openspec/cli`, { 
+        cwd,
+        stdio: 'inherit',
+        timeout: 120000
+      });
+      console.log('✅ openspec 本地安装完成');
+      return true;
+    } catch (localError) {
+      console.log('❌ 安装失败，请手动安装: npm install -g @openspec/cli');
+      return false;
+    }
+  }
+}
+
+/**
+ * 执行 openspec init
+ */
+async function runOpenspecInit() {
+  console.log('🚀 正在运行 openspec init...');
+  
+  // 检查 openspec 是否安装
+  if (!commandExists('openspec')) {
+    const shouldInstall = await ask('openspec 未安装，是否自动安装? (y/n): ');
+    if (shouldInstall === 'y' || shouldInstall === 'Y') {
+      const installed = await installOpenspec();
+      if (!installed) {
+        console.log('⚠️  跳过 openspec 初始化，继续应用模版...');
+        return false;
+      }
+    } else {
+      console.log('⚠️  跳过 openspec 安装，继续应用模版...');
+      return false;
+    }
+  }
+  
+  try {
+    // 执行标准 openspec init
+    console.log('   执行: openspec init');
+    execSync('openspec init', { stdio: 'inherit' });
+    
+    console.log('✅ openspec 初始化完成');
+    return true;
+  } catch (error) {
+    console.log('⚠️  openspec init 执行失败，继续应用模版...');
+    return false;
+  }
+}
+
+/**
+ * 递归复制目录
+ */
+function copyDir(source, target) {
+  if (!fs.existsSync(target)) {
+    fs.mkdirSync(target, { recursive: true });
+  }
+  
+  const files = fs.readdirSync(source);
+  for (const file of files) {
+    const srcPath = path.join(source, file);
+    const tgtPath = path.join(target, file);
+    
+    const stat = fs.statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyDir(srcPath, tgtPath);
+    } else {
+      fs.copyFileSync(srcPath, tgtPath);
+    }
+  }
+}
+
+/**
+ * 覆盖 opsx 命令（替换为4个独立命令）
+ */
+function overrideOpsxCommands() {
+  console.log('🔧 正在覆盖 opsx 命令...');
+  
+  const pkgPath = getPackagePath();
+  const opsxTemplatePath = path.join(pkgPath, 'templates', 'opsx-commands');
+  const cwd = process.cwd();
+  
+  if (!fs.existsSync(opsxTemplatePath)) {
+    console.log(`⚠️  opsx 命令模版不存在: ${opsxTemplatePath}`);
+    return false;
+  }
+  
+  // 为每个检测到的工具覆盖 opsx 命令
+  for (const [toolKey, config] of Object.entries(TOOL_CONFIGS)) {
+    const targetOpsxDir = path.join(cwd, config.opsxDir);
+    
+    // 检查该工具是否已初始化
+    if (!fs.existsSync(path.join(cwd, config.configDir))) {
+      continue;
+    }
+    
+    // 确保 opsx 目录存在
+    if (!fs.existsSync(targetOpsxDir)) {
+      fs.mkdirSync(targetOpsxDir, { recursive: true });
+    }
+    
+    console.log(`   覆盖 ${config.name} 的 opsx 命令...`);
+    
+    // 读取我们的4个命令模版
+    const commands = ['propose.md', 'spec.md', 'design.md', 'task.md'];
+    
+    for (const cmd of commands) {
+      const sourceFile = path.join(opsxTemplatePath, cmd);
+      const targetFile = path.join(targetOpsxDir, cmd);
+      
+      if (fs.existsSync(sourceFile)) {
+        fs.copyFileSync(sourceFile, targetFile);
+        console.log(`     ✓ ${cmd}`);
+      }
+    }
+    
+    // 删除原有的 propose.md（如果存在），因为我们用新的覆盖了
+    const oldProposePath = path.join(targetOpsxDir, 'propose.md');
+    if (fs.existsSync(oldProposePath)) {
+      console.log(`     🗑️  已替换原有的 propose.md`);
+    }
+  }
+  
+  console.log('✅ opsx 命令覆盖完成');
+  return true;
+}
+
+/**
+ * 覆盖 openspec-* skill
+ */
+function overrideOpenspecSkills() {
+  console.log('🔧 正在覆盖 openspec skills...');
+  
+  const pkgPath = getPackagePath();
+  const skillsTemplatePath = path.join(pkgPath, 'templates', 'skills');
+  const cwd = process.cwd();
+  
+  // 如果模版目录不存在，跳过
+  if (!fs.existsSync(skillsTemplatePath)) {
+    console.log('   无 skills 模版需要覆盖');
+    return false;
+  }
+  
+  // 为每个检测到的工具覆盖 skills
+  for (const [toolKey, config] of Object.entries(TOOL_CONFIGS)) {
+    const skillsDir = path.join(cwd, config.configDir, 'skills');
+    
+    // 检查 skills 目录是否存在
+    if (!fs.existsSync(skillsDir)) {
+      continue;
+    }
+    
+    // 查找 openspec-* 开头的 skill 目录并覆盖
+    if (fs.existsSync(skillsTemplatePath)) {
+      const skillDirs = fs.readdirSync(skillsTemplatePath);
+      
+      for (const skillDir of skillDirs) {
+        if (skillDir.startsWith('openspec-')) {
+          const sourceSkillPath = path.join(skillsTemplatePath, skillDir);
+          const targetSkillPath = path.join(skillsDir, skillDir);
+          
+          if (fs.statSync(sourceSkillPath).isDirectory()) {
+            copyDir(sourceSkillPath, targetSkillPath);
+            console.log(`   覆盖 skill: ${skillDir}`);
+          }
+        }
+      }
+    }
+  }
+  
+  console.log('✅ openspec skills 覆盖完成');
+  return true;
+}
+
+/**
+ * 复制标准文档模版到项目
+ */
+function copyTemplatesToProject() {
+  console.log('📄 正在复制标准文档模版到项目...');
+  
+  const pkgPath = getPackagePath();
+  const templatePath = path.join(pkgPath, 'templates', 'openspec');
+  const cwd = process.cwd();
+  const targetDir = path.join(cwd, 'openspec-templates');
+  
+  if (!fs.existsSync(templatePath)) {
+    console.log(`⚠️  模版源目录不存在: ${templatePath}`);
+    return false;
+  }
+  
+  // 创建目标目录
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+  
+  // 复制模版文件
+  copyDir(templatePath, targetDir);
+  
+  console.log(`✅ 标准文档模版已复制到: ${targetDir}`);
+  console.log('   包含文件:');
+  const files = fs.readdirSync(targetDir);
+  files.forEach(file => {
+    console.log(`     - ${file}`);
+  });
+  
+  return true;
+}
+
+/**
+ * 应用团队配置到编辑器
+ */
+function applyTeamConfig(toolKey) {
+  const config = TOOL_CONFIGS[toolKey];
+  const cwd = process.cwd();
+  const teamConfigPath = path.join(cwd, config.teamConfigDir);
+  const targetPath = path.join(cwd, config.commandsDir);
+  
+  if (!fs.existsSync(teamConfigPath)) {
+    console.log(`⚠️  未找到团队配置目录: ${config.teamConfigDir}`);
+    return false;
+  }
+  
+  if (!fs.existsSync(targetPath)) {
+    fs.mkdirSync(targetPath, { recursive: true });
+  }
+  
+  console.log(`📁 正在应用 ${config.name} 团队配置...`);
+  copyDir(teamConfigPath, targetPath);
+  console.log(`✅ ${config.name} 配置已更新`);
+  return true;
+}
+
+/**
+ * 创建团队配置目录结构
+ */
+function createTeamConfigStructure() {
+  const cwd = process.cwd();
+  
+  console.log('📂 创建团队配置目录结构...');
+  
+  // 创建 team-configs 目录
+  for (const config of Object.values(TOOL_CONFIGS)) {
+    const teamDir = path.join(cwd, config.teamConfigDir);
+    if (!fs.existsSync(teamDir)) {
+      fs.mkdirSync(teamDir, { recursive: true });
+      console.log(`  ✓ 创建: ${config.teamConfigDir}`);
+    }
+  }
+  
+  // 创建 team-schemas 目录
+  const schemasDir = path.join(cwd, 'team-schemas');
+  if (!fs.existsSync(schemasDir)) {
+    fs.mkdirSync(schemasDir, { recursive: true });
+    console.log('  ✓ 创建: team-schemas');
+  }
+  
+  // 创建 README
+  const readmePath = path.join(cwd, 'team-configs', 'README.md');
+  if (!fs.existsSync(readmePath)) {
+    const readmeContent = `# 团队配置目录
+
+此目录用于存放团队共享的 AI 编辑器配置。
+
+## 目录结构
+
+\`\`\`
+team-configs/
+├── cursor-commands/      # Cursor 自定义命令
+├── claude-commands/      # Claude Code 自定义命令
+└── README.md
+\`\`\`
+
+## 使用说明
+
+1. 将团队自定义命令文件放入对应编辑器的目录
+2. 运行 \`kld-sdd-init\` 应用配置
+3. 配置会自动覆盖到编辑器的命令目录
+
+## 注意事项
+
+- 请勿在此目录存放个人配置
+- 修改配置后需重新运行初始化命令
+- 建议将团队配置纳入版本控制
+`;
+    fs.writeFileSync(readmePath, readmeContent);
+    console.log('  ✓ 创建: team-configs/README.md');
+  }
+}
+
+/**
+ * 创建 .gitignore 配置
+ */
+function updateGitignore() {
+  const cwd = process.cwd();
+  const gitignorePath = path.join(cwd, '.gitignore');
+  
+  const sddConfig = `
+# KLD SDD 个人配置 (保留团队配置)
+.cursor/commands/personal-*
+.claude/commands/personal-*
+
+# 但保留团队配置的占位目录
+!.cursor/commands/team-*
+!.claude/commands/team-*
+`;
+
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, 'utf-8');
+    if (!content.includes('KLD SDD')) {
+      fs.appendFileSync(gitignorePath, sddConfig);
+      console.log('✅ 已更新 .gitignore');
+    }
+  } else {
+    fs.writeFileSync(gitignorePath, sddConfig.trim());
+    console.log('✅ 已创建 .gitignore');
+  }
+}
+
+/**
+ * 检测当前项目使用的AI编辑器
+ */
+function detectTools() {
+  const detected = [];
+  const cwd = process.cwd();
+  
+  for (const [key, config] of Object.entries(TOOL_CONFIGS)) {
+    const configPath = path.join(cwd, config.configDir);
+    if (fs.existsSync(configPath)) {
+      detected.push(key);
+    }
+  }
+  
+  return detected;
+}
+
+/**
+ * 显示帮助信息
+ */
+function showHelp() {
+  console.log(`
+KLD SDD 项目初始化工具
+
+用法:
+  kld-sdd-init [选项]
+  npx kld-sdd [选项]
+
+选项:
+  -h, --help       显示帮助信息
+  -v, --version    显示版本号
+  --skip-openspec  跳过 openspec init 步骤
+  --skip-template  跳过复制内置模版
+  --tool <name>    指定编辑器工具 (cursor|claude)
+
+示例:
+  kld-sdd-init                    # 完整初始化流程
+  kld-sdd-init --skip-openspec    # 仅应用团队配置
+  kld-sdd-init --tool cursor      # 仅配置 Cursor
+`);
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  
+  // 解析参数
+  if (args.includes('-h') || args.includes('--help')) {
+    showHelp();
+    rl.close();
+    return;
+  }
+  
+  if (args.includes('-v') || args.includes('--version')) {
+    const pkg = require('../package.json');
+    console.log(pkg.version);
+    rl.close();
+    return;
+  }
+  
+  const skipOpenspec = args.includes('--skip-openspec');
+  const skipTemplate = args.includes('--skip-template');
+  const toolIndex = args.indexOf('--tool');
+  const specifiedTool = toolIndex !== -1 ? args[toolIndex + 1] : null;
+  
+  console.log('╔════════════════════════════════════════╗');
+  console.log('║     KLD SDD 项目初始化工具             ║');
+  console.log('║     内置 openSpec 标准模版             ║');
+  console.log('╚════════════════════════════════════════╝');
+  console.log();
+  
+  // 1. 运行 openspec init
+  if (!skipOpenspec) {
+    await runOpenspecInit();
+  }
+  
+  // 2. 覆盖 opsx 命令（4个独立命令）
+  if (!skipTemplate) {
+    overrideOpsxCommands();
+  }
+  
+  // 3. 覆盖 openspec skills
+  if (!skipTemplate) {
+    overrideOpenspecSkills();
+  }
+  
+  // 4. 复制标准文档模版到项目（供参考）
+  if (!skipTemplate) {
+    copyTemplatesToProject();
+  }
+  
+  // 5. 创建团队配置目录结构
+  createTeamConfigStructure();
+  
+  // 6. 检测或选择工具
+  let toolsToConfig = [];
+  
+  if (specifiedTool) {
+    if (TOOL_CONFIGS[specifiedTool]) {
+      toolsToConfig = [specifiedTool];
+    } else {
+      console.log(`❌ 未知工具: ${specifiedTool}`);
+      console.log(`支持的工具: ${Object.keys(TOOL_CONFIGS).join(', ')}`);
+      rl.close();
+      process.exit(1);
+    }
+  } else {
+    const detected = detectTools();
+    
+    if (detected.length === 0) {
+      console.log('⚠️  未检测到已初始化的 AI 编辑器');
+      const answer = await ask('是否手动选择要配置的工具? (cursor/claude/all/none): ');
+      
+      if (answer === 'all') {
+        toolsToConfig = Object.keys(TOOL_CONFIGS);
+      } else if (TOOL_CONFIGS[answer]) {
+        toolsToConfig = [answer];
+      } else if (answer !== 'none') {
+        console.log('跳过工具配置');
+      }
+    } else {
+      console.log(`\n检测到以下已初始化的编辑器: ${detected.map(t => TOOL_CONFIGS[t].name).join(', ')}`);
+      const answer = await ask('是否应用团队配置? (y/n/all): ');
+      
+      if (answer === 'all') {
+        toolsToConfig = Object.keys(TOOL_CONFIGS);
+      } else if (answer === 'y' || answer === 'Y') {
+        toolsToConfig = detected;
+      }
+    }
+  }
+  
+  // 7. 应用团队配置
+  console.log();
+  if (toolsToConfig.length > 0) {
+    for (const tool of toolsToConfig) {
+      applyTeamConfig(tool);
+    }
+  } else {
+    console.log('⏭️  跳过团队配置应用');
+  }
+  
+  // 8. 更新 .gitignore
+  updateGitignore();
+  
+  console.log();
+  console.log('╔════════════════════════════════════════╗');
+  console.log('║     ✅ 初始化完成！                   ║');
+  console.log('╚════════════════════════════════════════╝');
+  console.log();
+  console.log('已生成/覆盖:');
+  console.log('  📄 openspec-templates/      # 标准四文档模版（参考用）');
+  console.log('  🔧 .*/commands/opsx/        # 4个独立命令（propose/spec/design/task）');
+  console.log('  📁 team-configs/            # 团队配置目录');
+  console.log();
+  console.log('可用命令:');
+  console.log('  /opsx:propose  - 创建业务意图文档');
+  console.log('  /opsx:spec     - 创建技术契约文档');
+  console.log('  /opsx:design   - 创建技术实现方案');
+  console.log('  /opsx:task     - 拆解AI编码任务');
+  console.log();
+  console.log('后续步骤:');
+  console.log('  1. 运行 /opsx:propose <变更名称> 开始创建文档');
+  console.log('  2. 按顺序执行 propose → spec → design → task');
+  console.log('  3. 运行 /opsx:apply 开始代码实现');
+  console.log();
+  
+  rl.close();
+}
+
+module.exports = { main, detectTools, applyTeamConfig, getTemplatePath };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "kld-sdd",
+  "version": "1.0.0",
+  "description": "KLD SDD OpenSpec 项目初始化工具 - 内置模版一键初始化",
+  "main": "index.js",
+  "bin": {
+    "kld-sdd-init": "bin/kld-sdd-init.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "kld",
+    "sdd",
+    "openspec",
+    "init",
+    "cursor",
+    "claude",
+    "template"
+  ],
+  "author": "KLD Team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "README.md"
+  ],
+  "dependencies": {}
+}