kld-sdd 2.4.19 → 2.5.1

package/lib/command-bridge.js

@@ -0,0 +1,156 @@
+/**
+ * KunlunZhima OPSX Command Bridge 生成与管理
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { renderTemplate, validateRenderedContent } = require('./skills-bundle');
+
+const BRIDGE_MARKER = '# SDD KunlunZhima Skill Bridge';
+const BRIDGE_MAX_BYTES = 4096;
+
+function posixJoin(...segments) {
+  return segments.filter(Boolean).join('/').replace(/\\/g, '/');
+}
+
+function loadBridgeTemplate(pkgPath) {
+  const templatePath = path.join(pkgPath, 'templates', 'commands', 'kunlunzhima', 'skill-bridge.md');
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`缺少 Kunlun bridge 模板: ${templatePath}`);
+  }
+  return fs.readFileSync(templatePath, 'utf8');
+}
+
+function escapeYamlString(value) {
+  return String(value || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function renderBridgeTemplate(template, metadata, profile) {
+  const skillRelativePath = posixJoin(profile.skillsDir, metadata.skillDir, 'SKILL.md');
+  const rendered = template
+    .replace(/\$\{BRIDGE_NAME\}/g, escapeYamlString(metadata.displayName))
+    .replace(/\$\{BRIDGE_DESCRIPTION\}/g, escapeYamlString(metadata.description))
+    .replace(/\$\{BRIDGE_ARGUMENT_HINT\}/g, escapeYamlString(metadata.argumentHint))
+    .replace(/\$\{SKILL_RELATIVE_PATH\}/g, skillRelativePath)
+    .replace(/\$\{SKILL_DIR\}/g, posixJoin(profile.skillsDir, metadata.skillDir));
+
+  validateRenderedContent(rendered, profile, `bridge:${metadata.commandName}`);
+  return rendered;
+}
+
+function generateKunlunBridge(metadata, profile, projectRoot, pkgPath = path.resolve(__dirname, '..')) {
+  if (!profile || !profile.requiresCommandBridge) {
+    throw new Error('当前 profile 不需要 Kunlun command bridge');
+  }
+
+  const skillPath = path.join(projectRoot, profile.skillsDir, metadata.skillDir, 'SKILL.md');
+  if (!fs.existsSync(skillPath)) {
+    throw new Error(`缺少 Skill 文件，无法生成 bridge: ${posixJoin(profile.skillsDir, metadata.skillDir, 'SKILL.md')}`);
+  }
+
+  const template = loadBridgeTemplate(pkgPath || path.resolve(__dirname, '..'));
+  const content = renderBridgeTemplate(template, metadata, profile);
+
+  if (Buffer.byteLength(content, 'utf8') > BRIDGE_MAX_BYTES) {
+    throw new Error(`bridge 文件过大 (${metadata.commandName})，可能复制了 Skill 正文`);
+  }
+
+  if (!content.includes(BRIDGE_MARKER)) {
+    throw new Error(`生成的 bridge 缺少受管标记: ${metadata.commandName}`);
+  }
+
+  return content;
+}
+
+function getBridgeCommandPath(profile, projectRoot, commandName) {
+  return path.join(projectRoot, profile.opsxCommandsDir, `${commandName}.md`);
+}
+
+function isManagedBridgeFile(content) {
+  return typeof content === 'string' && content.includes(BRIDGE_MARKER);
+}
+
+function assertNoUserCommandConflict(commandPath, commandName) {
+  if (!fs.existsSync(commandPath)) {
+    return;
+  }
+
+  const existing = fs.readFileSync(commandPath, 'utf8');
+  if (!isManagedBridgeFile(existing)) {
+    throw new Error(
+      `命令文件冲突: ${commandName}.md 已存在且不含 SDD 受管标记。` +
+      '请手动备份后删除或重命名该文件，再重新初始化。'
+    );
+  }
+}
+
+function deployKunlunCommandBridges({ profile, projectRoot, pkgPath, skillMetadata }) {
+  if (!profile) {
+    throw new Error('缺少 profile');
+  }
+  if (!profile.requiresCommandBridge) {
+    return { deployed: [], skipped: true };
+  }
+  if (!projectRoot) {
+    throw new Error('缺少 projectRoot');
+  }
+  if (!Array.isArray(skillMetadata) || skillMetadata.length === 0) {
+    throw new Error('缺少 OPSX skill metadata');
+  }
+
+  const opsxDir = path.join(projectRoot, profile.opsxCommandsDir);
+  if (!fs.existsSync(opsxDir)) {
+    fs.mkdirSync(opsxDir, { recursive: true });
+  }
+
+  const deployed = [];
+
+  for (const metadata of skillMetadata) {
+    const commandPath = getBridgeCommandPath(profile, projectRoot, metadata.commandName);
+    assertNoUserCommandConflict(commandPath, metadata.commandName);
+
+    const content = generateKunlunBridge(metadata, profile, projectRoot, pkgPath);
+    fs.writeFileSync(commandPath, content, 'utf8');
+    deployed.push({
+      commandName: metadata.commandName,
+      path: commandPath,
+      skillPath: posixJoin(profile.skillsDir, metadata.skillDir, 'SKILL.md'),
+    });
+  }
+
+  return { deployed, skipped: false };
+}
+
+function cleanupManagedKunlunBridges(profile, projectRoot) {
+  if (!profile || !profile.requiresCommandBridge || !projectRoot) {
+    return { removed: [] };
+  }
+
+  const opsxDir = path.join(projectRoot, profile.opsxCommandsDir);
+  if (!fs.existsSync(opsxDir)) {
+    return { removed: [] };
+  }
+
+  const removed = [];
+  for (const file of fs.readdirSync(opsxDir)) {
+    if (!file.endsWith('.md')) continue;
+    const filePath = path.join(opsxDir, file);
+    const content = fs.readFileSync(filePath, 'utf8');
+    if (isManagedBridgeFile(content)) {
+      fs.unlinkSync(filePath);
+      removed.push(filePath);
+    }
+  }
+
+  return { removed };
+}
+
+module.exports = {
+  BRIDGE_MARKER,
+  BRIDGE_MAX_BYTES,
+  generateKunlunBridge,
+  deployKunlunCommandBridges,
+  cleanupManagedKunlunBridges,
+  isManagedBridgeFile,
+  getBridgeCommandPath,
+};

package/lib/deploy-codebuddy-hooks.js

@@ -0,0 +1,99 @@
+/**
+ * Deploy CodeBuddy SDD Hook Pack to a target project.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { mergeCodebuddySettings } = require('./settings-merge');
+
+function copyFileSync(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function copyDirSync(srcDir, destDir) {
+  if (!fs.existsSync(srcDir)) return;
+  fs.mkdirSync(destDir, { recursive: true });
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function validateExistingSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) {
+    return { ok: true };
+  }
+  const originalBytes = fs.readFileSync(settingsPath, 'utf8');
+  try {
+    JSON.parse(originalBytes);
+    return { ok: true, originalBytes };
+  } catch {
+    return {
+      ok: false,
+      error: `${path.basename(settingsPath)} 不是合法 JSON，请修复后重试（路径: ${settingsPath}）`,
+      originalBytes,
+    };
+  }
+}
+
+function deployCodebuddyHookPack(profile, cwd, pkgPath) {
+  if (!profile || profile.hookProvider !== 'codebuddy') {
+    return { ok: true, skipped: true };
+  }
+
+  const hookTemplateDir = path.join(pkgPath, 'templates', 'hooks', 'codebuddy');
+  const hookSourceDir = path.join(hookTemplateDir, 'hooks');
+  const settingsTemplatePath = path.join(hookTemplateDir, 'settings.json');
+  const coreSourcePath = path.join(pkgPath, 'lib', 'hook-gate-core.js');
+
+  if (!fs.existsSync(hookSourceDir) || !fs.existsSync(settingsTemplatePath)) {
+    return {
+      ok: false,
+      error: `CodeBuddy Hook 模板缺失: ${hookTemplateDir}`,
+    };
+  }
+
+  const codebuddyDir = path.join(cwd, profile.configDir || '.codebuddy');
+  const targetSettingsPath = path.join(codebuddyDir, 'settings.json');
+  const settingsCheck = validateExistingSettings(targetSettingsPath);
+  if (!settingsCheck.ok) {
+    return settingsCheck;
+  }
+
+  const targetHookDir = path.join(codebuddyDir, 'hooks');
+  fs.mkdirSync(targetHookDir, { recursive: true });
+
+  for (const file of fs.readdirSync(hookSourceDir)) {
+    if (file === 'hook-gate-core.cjs') continue;
+    copyFileSync(path.join(hookSourceDir, file), path.join(targetHookDir, file));
+  }
+
+  if (fs.existsSync(coreSourcePath)) {
+    copyFileSync(coreSourcePath, path.join(targetHookDir, 'hook-gate-core.cjs'));
+  } else {
+    return {
+      ok: false,
+      error: `共享 hook 核心缺失: ${coreSourcePath}`,
+    };
+  }
+
+  const templateSettings = JSON.parse(fs.readFileSync(settingsTemplatePath, 'utf8'));
+  const mergeResult = mergeCodebuddySettings(targetSettingsPath, templateSettings);
+  if (!mergeResult.ok) {
+    return mergeResult;
+  }
+
+  return { ok: true, hookDir: targetHookDir, settingsPath: targetSettingsPath };
+}
+
+module.exports = {
+  deployCodebuddyHookPack,
+  copyDirSync,
+  validateExistingSettings,
+};

package/lib/hook-gate-core.js

@@ -0,0 +1,333 @@
+/**
+ * Shared SDD hook gate utilities for Claude and CodeBuddy adapters.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_ENV_KEYS = {
+  claude: 'CLAUDE_PROJECT_DIR',
+  codebuddy: 'CODEBUDDY_PROJECT_DIR',
+};
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function parseHookInput(raw, options = {}) {
+  const { strict = false } = options;
+  if (!raw || !String(raw).trim()) {
+    if (strict) {
+      return { ok: false, error: 'stdin 为空，缺少 hook 输入 JSON' };
+    }
+    return { ok: true, input: {} };
+  }
+  try {
+    return { ok: true, input: JSON.parse(raw) };
+  } catch {
+    if (strict) {
+      return { ok: false, error: 'stdin 不是合法 JSON，无法解析 hook 输入' };
+    }
+    return { ok: true, input: {} };
+  }
+}
+
+function normalizeHookInput(input) {
+  const normalized = { ...(input || {}) };
+  normalized.tool_name = String(
+    normalized.tool_name || normalized.toolName || ''
+  );
+  normalized.tool_input = normalized.tool_input != null
+    ? normalized.tool_input
+    : (normalized.toolInput != null ? normalized.toolInput : {});
+  normalized.tool_response = normalized.tool_response != null
+    ? normalized.tool_response
+    : (normalized.toolResponse != null ? normalized.toolResponse : {});
+  return normalized;
+}
+
+function hasTelemetryCli(dir) {
+  return fs.existsSync(path.join(dir, 'skywalk-sdd', 'log.cjs')) ||
+    fs.existsSync(path.join(dir, 'skywalk-sdd', 'log.js'));
+}
+
+function findProjectRoot(startDir) {
+  if (!startDir) return '';
+  let current = path.resolve(startDir);
+  for (let i = 0; i < 25; i++) {
+    if (hasTelemetryCli(current)) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return '';
+    current = parent;
+  }
+  return '';
+}
+
+function getProjectRoot(input, provider = 'codebuddy') {
+  const toolInput = input.tool_input || input.toolInput || {};
+  const envKey = PROJECT_ENV_KEYS[provider] || PROJECT_ENV_KEYS.codebuddy;
+  const candidates = [
+    toolInput.cwd,
+    input.cwd,
+    input.project_root,
+    process.env[envKey],
+    process.env.PWD,
+    process.cwd(),
+  ].filter(Boolean);
+  for (const dir of candidates) {
+    const root = findProjectRoot(dir);
+    if (root) return root;
+  }
+  return process.cwd();
+}
+
+function safeChangeName(name) {
+  if (!name) return '';
+  return String(name)
+    .toLowerCase()
+    .replace(/[\s_]+/g, '-')
+    .replace(/[^a-z0-9一-鿿\-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function findActiveApplyStage(projectRoot) {
+  const stateDir = path.join(projectRoot, 'skywalk-sdd', 'state');
+  if (!fs.existsSync(stateDir)) return null;
+
+  let latest = null;
+  for (const file of fs.readdirSync(stateDir).filter((f) => f.endsWith('.json'))) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(stateDir, file), 'utf8'));
+      const event = data.event || null;
+      if (event && event.command === 'apply') {
+        if (!latest || new Date(event.timestamp) > new Date(latest.timestamp)) {
+          latest = event;
+        }
+      }
+    } catch {
+      // skip
+    }
+  }
+  return latest;
+}
+
+function hasCompletedCheck(projectRoot, changeName) {
+  const safeName = safeChangeName(changeName);
+  const eventsChangeDir = path.join(projectRoot, 'skywalk-sdd', 'events', safeName);
+  if (!fs.existsSync(eventsChangeDir)) return false;
+
+  const jsonlFiles = fs.readdirSync(eventsChangeDir)
+    .filter((f) => f.endsWith('.jsonl'))
+    .sort()
+    .reverse();
+
+  for (const file of jsonlFiles) {
+    try {
+      const lines = fs.readFileSync(path.join(eventsChangeDir, file), 'utf-8')
+        .split('\n')
+        .filter(Boolean);
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const event = JSON.parse(lines[i]);
+          if (
+            event.type === 'stage_end' &&
+            event.command === 'check' &&
+            (event.result === 'success' || event.result === 'partial')
+          ) {
+            return true;
+          }
+        } catch {
+          // skip
+        }
+      }
+    } catch {
+      // skip
+    }
+  }
+  return false;
+}
+
+function getPassedChanges(projectRoot) {
+  if (!projectRoot) return [];
+  const changesDir = path.join(projectRoot, 'openspec', 'changes');
+  if (!fs.existsSync(changesDir)) return [];
+
+  const passed = [];
+  try {
+    for (const entry of fs.readdirSync(changesDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') || entry.name === 'archive') continue;
+      if (hasCompletedCheck(projectRoot, entry.name)) {
+        passed.push(entry.name);
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return passed;
+}
+
+function isOpsxApplySkill(toolInput) {
+  if (!toolInput) return false;
+  let input;
+  if (typeof toolInput === 'string') {
+    try { input = JSON.parse(toolInput); } catch { return false; }
+  } else {
+    input = toolInput;
+  }
+  if (!input || typeof input !== 'object') return false;
+  return (input.skill || '') === 'opsx-apply';
+}
+
+function extractChangeName(toolInput) {
+  if (!toolInput) return null;
+  let input;
+  if (typeof toolInput === 'string') {
+    try { input = JSON.parse(toolInput); } catch { return null; }
+  } else {
+    input = toolInput;
+  }
+  if (!input || typeof input !== 'object') return null;
+
+  const args = input.args || '';
+  if (!args.trim()) return null;
+  const trimmed = args.trim();
+  const changeFlagMatch = trimmed.match(/^--change\s+(.+)$/);
+  if (changeFlagMatch) {
+    return safeChangeName(changeFlagMatch[1].trim().split(/\s+/)[0]);
+  }
+  return safeChangeName(trimmed.split(/\s+/)[0]);
+}
+
+function blockWithReason(reason, extra) {
+  console.log(JSON.stringify({ decision: 'block', reason, ...(extra || {}) }));
+  process.exit(2);
+}
+
+function allowExit(extra) {
+  if (extra) {
+    console.log(JSON.stringify({ decision: 'allow', ...extra }));
+  }
+  process.exit(0);
+}
+
+function evaluateApplyWriteGate(input, provider = 'codebuddy') {
+  const toolName = String(input.tool_name || input.toolName || '');
+  if (!toolName) {
+    return {
+      action: 'block',
+      reason: 'stdin 缺少必要字段 tool_name，无法执行 apply 写入门禁检查',
+    };
+  }
+  if (toolName !== 'Write' && toolName !== 'Edit') {
+    return { action: 'allow' };
+  }
+
+  const projectRoot = getProjectRoot(input, provider);
+  const activeApply = findActiveApplyStage(projectRoot);
+  if (!activeApply) {
+    return { action: 'allow' };
+  }
+  if (hasCompletedCheck(projectRoot, activeApply.change)) {
+    return { action: 'allow' };
+  }
+
+  const changeName = activeApply.change || 'unknown';
+  return {
+    action: 'block',
+    reason: `[SDD Apply Gate] 检测到 apply 阶段正在执行（change: ${changeName}），但 check 阶段尚未完成。\n\n请先执行 /opsx-check 完成质量门禁检查，再执行 /opsx-apply 进行代码实施。\n\n操作顺序：/opsx-check → /opsx-apply`,
+  };
+}
+
+function evaluateSkillApplyGate(input, provider = 'codebuddy') {
+  const toolName = String(input.tool_name || input.toolName || '');
+  if (!toolName) {
+    return {
+      action: 'block',
+      reason: 'stdin 缺少必要字段 tool_name，无法执行 Skill apply 门禁检查',
+    };
+  }
+  if (toolName !== 'Skill') {
+    return { action: 'allow' };
+  }
+
+  const toolInput = input.tool_input;
+  if (!isOpsxApplySkill(toolInput)) {
+    return { action: 'allow' };
+  }
+
+  const projectRoot = getProjectRoot(input, provider);
+  if (!findProjectRoot(projectRoot)) {
+    return { action: 'allow' };
+  }
+
+  const changeName = extractChangeName(toolInput);
+  if (changeName) {
+    if (hasCompletedCheck(projectRoot, changeName)) {
+      return { action: 'allow' };
+    }
+    return {
+      action: 'block',
+      reason: `变更 "${changeName}" 尚未完成 check 阶段。请先执行 /opsx-check ${changeName} 完成检查后再 apply。`,
+    };
+  }
+
+  const passedChanges = getPassedChanges(projectRoot);
+  if (passedChanges.length === 0) {
+    return {
+      action: 'block',
+      reason: '当前项目没有任何变更已完成 check 阶段。请先执行 /opsx-check <change-name> 完成检查后再 apply。',
+    };
+  }
+
+  const msg = passedChanges.length === 1
+    ? `检测到已通过 check 的变更: "${passedChanges[0]}"，允许进入 apply。`
+    : `检测到 ${passedChanges.length} 个已通过 check 的变更: ${passedChanges.join(', ')}，允许进入 apply。`;
+  return { action: 'allow', reason: msg };
+}
+
+function evaluatePreToolDangerGate(input) {
+  const toolInput = input.tool_input || input.toolInput || {};
+  const command = String(toolInput.command || input.command || '');
+  const dangerousPatterns = [
+    /\brm\s+-rf\b/i,
+    /\brmdir\s+\/s\b/i,
+    /\bdel\s+\/[fsq]/i,
+    /\bgit\s+reset\s+--hard\b/i,
+    /\bgit\s+clean\s+-fdx\b/i,
+    /\bRemove-Item\b.*\b-Recurse\b.*\b-Force\b/i,
+  ];
+  if (dangerousPatterns.some((pattern) => pattern.test(command))) {
+    return {
+      action: 'block',
+      reason: 'Blocked by SDD hook: destructive command requires explicit user approval.',
+    };
+  }
+  return { action: 'allow' };
+}
+
+module.exports = {
+  PROJECT_ENV_KEYS,
+  readStdin,
+  parseHookInput,
+  normalizeHookInput,
+  hasTelemetryCli,
+  findProjectRoot,
+  getProjectRoot,
+  safeChangeName,
+  findActiveApplyStage,
+  hasCompletedCheck,
+  getPassedChanges,
+  isOpsxApplySkill,
+  extractChangeName,
+  blockWithReason,
+  allowExit,
+  evaluateApplyWriteGate,
+  evaluateSkillApplyGate,
+  evaluatePreToolDangerGate,
+};