@deepstorm/cli 0.1.0

package/dist/build-registry.js

@@ -0,0 +1,375 @@
+"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);
+var build_registry_exports = {};
+__export(build_registry_exports, {
+  buildRegistry: () => buildRegistry
+});
+module.exports = __toCommonJS(build_registry_exports);
+var fs = __toESM(require("node:fs"));
+var path = __toESM(require("node:path"));
+var import_js_yaml = __toESM(require("js-yaml"));
+const PACKAGE_LABELS = {
+  tide: { label: "\u4EA7\u54C1\u4FA7", description: "BMAD \u9700\u6C42\u8BA8\u8BBA\u3001PRD\u3001Jira", mcpDependencies: ["jira", "feishu-wiki", "figma"] },
+  reef: { label: "\u5F00\u53D1\u4FA7", description: "\u89C4\u8303\u751F\u6210\u3001\u4EE3\u7801\u5B9E\u73B0", mcpDependencies: ["jira", "feishu-wiki", "figma", "github", "context7"] },
+  sweep: { label: "\u6D4B\u8BD5\u4FA7", description: "\u6D4B\u8BD5\u751F\u6210\u3001\u8986\u76D6\u7387\u3001CI", mcpDependencies: ["jira", "feishu-wiki", "playwright"] },
+  atoll: { label: "\u8FD0\u7EF4\u4FA7", description: "\u90E8\u7F72\u8F85\u52A9\u3001\u76D1\u63A7\u3001\u6545\u969C\u6392\u67E5", mcpDependencies: ["jira", "feishu-wiki"] },
+  shared: { label: "\u5171\u4EAB", description: "\u516C\u5171\u6280\u80FD\u4E0E\u5DE5\u5177" }
+};
+const TOOL_ORDER = ["tide", "reef", "sweep", "atoll", "shared"];
+function getPackageDirs(packagesDir) {
+  if (!fs.existsSync(packagesDir)) return [];
+  const dirs = fs.readdirSync(packagesDir).filter((name) => {
+    const dir = path.join(packagesDir, name);
+    return fs.statSync(dir).isDirectory() && name !== "cli";
+  });
+  dirs.sort((a, b) => {
+    const ia = TOOL_ORDER.indexOf(a);
+    const ib = TOOL_ORDER.indexOf(b);
+    return (ia === -1 ? 999 : ia) - (ib === -1 ? 999 : ib);
+  });
+  return dirs;
+}
+function parseFrontmatter(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("---")) return null;
+  const endIndex = trimmed.indexOf("---", 3);
+  if (endIndex === -1) return null;
+  const yamlBlock = trimmed.slice(3, endIndex).trim();
+  if (!yamlBlock) return null;
+  try {
+    return import_js_yaml.default.load(yamlBlock);
+  } catch {
+    return null;
+  }
+}
+function collectJsonFiles(dir) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  for (const entry of fs.readdirSync(dir)) {
+    const fullPath = path.join(dir, entry);
+    if (entry === ".DS_Store") continue;
+    if (fs.statSync(fullPath).isDirectory()) {
+      results.push(...collectJsonFiles(fullPath));
+    } else if (entry.endsWith(".json")) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function scanAssets(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter((n) => n !== ".DS_Store").filter((n) => n !== "hooks.json").filter((n) => {
+    const stat = fs.statSync(path.join(dir, n));
+    return stat.isFile();
+  }).map((n) => n.replace(/\.tmpl$/, "")).filter((v, i, a) => a.indexOf(v) === i);
+}
+function buildRegistry(cliDir) {
+  console.log("\u{1F528} \u6784\u5EFA registry...\n");
+  const root = path.resolve(cliDir, "..", "..");
+  const distDir = path.join(cliDir, "dist");
+  const packagesDir = path.join(root, "packages");
+  const packageDirs = getPackageDirs(packagesDir);
+  const registry = {
+    version: "1",
+    tools: {},
+    wizards: {},
+    skills: {}
+  };
+  console.log("\u{1F4C4} \u626B\u63CF SKILL.md frontmatter...");
+  let skillCount = 0;
+  for (const pkg of packageDirs) {
+    const skillsDir = path.join(root, "packages", pkg, "skills");
+    if (!fs.existsSync(skillsDir)) continue;
+    const skillNames = fs.readdirSync(skillsDir).filter(
+      (n) => fs.statSync(path.join(skillsDir, n)).isDirectory()
+    );
+    for (const skillName of skillNames) {
+      const mdPath = path.join(skillsDir, skillName, "SKILL.md");
+      const tmplPath = path.join(skillsDir, skillName, "SKILL.md.tmpl");
+      const hasMd = fs.existsSync(mdPath);
+      const hasTmpl = fs.existsSync(tmplPath);
+      if (!hasMd && !hasTmpl) {
+        console.log(`  \u26A0 ${pkg}/${skillName}: \u7F3A\u5C11 SKILL.md/SKILL.md.tmpl\uFF0C\u8DF3\u8FC7`);
+        continue;
+      }
+      const skillMd = hasMd ? mdPath : tmplPath;
+      const content = fs.readFileSync(skillMd, "utf-8");
+      const fm = parseFrontmatter(content);
+      if (!fm) {
+        console.log(`  \u26A0 ${pkg}/${skillName}: frontmatter \u89E3\u6790\u5931\u8D25\uFF0C\u8DF3\u8FC7`);
+        continue;
+      }
+      if (!fm.deepstormm) {
+        console.log(`  - ${pkg}/${skillName}: \u65E0 deepstormm \u5B57\u6BB5\uFF0C\u8DF3\u8FC7\u6CE8\u518C`);
+        continue;
+      }
+      const df = fm.deepstormm;
+      const entry = {
+        tool: df.tool,
+        configKey: df.configKey,
+        configValue: df.configValue,
+        name: fm.name || void 0,
+        description: fm.description || void 0
+      };
+      if (hasTmpl) {
+        entry.hasTemplate = true;
+      }
+      const deps = df.dependencies;
+      if (Array.isArray(deps) && deps.length > 0) {
+        entry.dependencies = deps;
+      }
+      registry.skills[skillName] = entry;
+      skillCount++;
+    }
+  }
+  console.log(`  \u2714 \u5DF2\u6CE8\u518C ${skillCount} \u4E2A skill
+`);
+  console.log("\u{1F4CB} \u626B\u63CF wizard.json...");
+  let wizardCount = 0;
+  for (const pkg of packageDirs) {
+    const wizardPath = path.join(root, "packages", pkg, "wizard.json");
+    if (!fs.existsSync(wizardPath)) continue;
+    try {
+      const wizard = JSON.parse(fs.readFileSync(wizardPath, "utf-8"));
+      if (wizard.tool && wizard.questions) {
+        const pkgLabel = PACKAGE_LABELS[pkg];
+        const enriched = { ...wizard };
+        if (!enriched.label && pkgLabel) enriched.label = pkgLabel.label;
+        if (!enriched.description && pkgLabel) enriched.description = pkgLabel.description;
+        registry.wizards[enriched.tool] = enriched;
+        if (pkgLabel) registry.tools[enriched.tool] = pkgLabel;
+        wizardCount++;
+        console.log(`  \u2714 ${pkg}/wizard.json (${wizard.tool})`);
+      } else {
+        console.log(`  \u26A0 ${pkg}/wizard.json: \u7F3A\u5C11 tool \u6216 questions \u5B57\u6BB5`);
+      }
+    } catch {
+      console.log(`  \u26A0 ${pkg}/wizard.json: \u89E3\u6790\u5931\u8D25`);
+    }
+  }
+  if (wizardCount === 0) console.log("  \u65E0 wizard.json \u6587\u4EF6");
+  console.log(`  \u2714 \u5DF2\u6CE8\u518C ${wizardCount} \u4E2A wizard
+`);
+  console.log("\u{1F50C} \u626B\u63CF MCP \u5DE5\u5177\u914D\u7F6E...");
+  const mcpTools = {};
+  const cliMcpDir = path.join(cliDir, "mcp");
+  const mcpJsonFiles = collectJsonFiles(cliMcpDir);
+  let mcpCount = 0;
+  for (const jsonPath of mcpJsonFiles) {
+    try {
+      const data = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+      if (data.name && data.domain && data.label) {
+        mcpTools[data.name] = {
+          domain: data.domain,
+          label: data.label,
+          description: data.description || ""
+        };
+        mcpCount++;
+        console.log(`  \u2714 ${data.label} (${data.name}) \u2192 ${data.domain}`);
+      } else {
+        console.log(`  \u26A0 ${path.relative(cliDir, jsonPath)}: \u7F3A\u5C11 name/domain/label \u5B57\u6BB5\uFF0C\u8DF3\u8FC7`);
+      }
+    } catch {
+      console.log(`  \u26A0 ${path.relative(cliDir, jsonPath)}: \u89E3\u6790\u5931\u8D25\uFF0C\u8DF3\u8FC7`);
+    }
+  }
+  registry.mcpTools = mcpTools;
+  console.log(`  \u2714 \u5DF2\u6CE8\u518C ${mcpCount} \u4E2A MCP \u5DE5\u5177
+`);
+  console.log("\u{1F4C1} \u626B\u63CF agents \u548C hooks \u5F52\u5C5E...");
+  const toolAssets = {};
+  for (const pkg of packageDirs) {
+    const wizardPath = path.join(root, "packages", pkg, "wizard.json");
+    if (!fs.existsSync(wizardPath)) continue;
+    let tool;
+    try {
+      const wizard = JSON.parse(fs.readFileSync(wizardPath, "utf-8"));
+      tool = wizard.tool;
+    } catch {
+      continue;
+    }
+    if (!tool) continue;
+    const assets = {};
+    const agentsDir = path.join(root, "packages", pkg, "agents");
+    const hooksDir = path.join(root, "packages", pkg, "hooks");
+    if (fs.existsSync(agentsDir)) {
+      const agents = scanAssets(agentsDir);
+      if (agents.length > 0) assets.agents = agents;
+    }
+    if (fs.existsSync(hooksDir)) {
+      const hooks = scanAssets(hooksDir);
+      if (hooks.length > 0) assets.hooks = hooks;
+    }
+    if (Object.keys(assets).length > 0) {
+      toolAssets[tool] = assets;
+    }
+  }
+  registry.toolAssets = toolAssets;
+  console.log(`  \u2714 \u5DF2\u6620\u5C04 ${Object.keys(toolAssets).length} \u4E2A\u5DE5\u5177\u7684 assets
+`);
+  for (const skill of Object.values(registry.skills)) {
+    if (skill.tool && !registry.tools[skill.tool]) {
+      registry.tools[skill.tool] = {
+        label: skill.tool.charAt(0).toUpperCase() + skill.tool.slice(1),
+        description: ""
+      };
+    }
+  }
+  const assetDirs = ["skills", "agents", "mcp", "hooks"];
+  const distHooksJson = path.join(distDir, "hooks", "hooks.json");
+  if (fs.existsSync(distHooksJson)) {
+    fs.rmSync(distHooksJson, { force: true });
+  }
+  for (const assetDir of assetDirs) {
+    for (const pkg of packageDirs) {
+      const srcDir = path.join(root, "packages", pkg, assetDir);
+      if (!fs.existsSync(srcDir)) continue;
+      const entries = fs.readdirSync(srcDir);
+      if (assetDir === "skills") {
+        const dirs = entries.filter((n) => fs.statSync(path.join(srcDir, n)).isDirectory());
+        if (dirs.length === 0) continue;
+        for (const item of dirs) {
+          const src = path.join(srcDir, item);
+          const dest = path.join(distDir, assetDir, item);
+          const needsUpdate = !fs.existsSync(dest);
+          if (!needsUpdate) {
+            const srcStat = fs.statSync(src);
+            const destStat = fs.statSync(dest);
+            if (srcStat.mtimeMs <= destStat.mtimeMs) continue;
+          }
+          fs.cpSync(src, dest, { recursive: true, force: true });
+          console.log(`  ${needsUpdate ? "  \u590D\u5236" : "  \u66F4\u65B0"} ${pkg}/${assetDir}/${item}`);
+        }
+      } else {
+        const destDir = path.join(distDir, assetDir);
+        fs.mkdirSync(destDir, { recursive: true });
+        for (const entry of entries) {
+          if (entry === ".DS_Store" || entry === "variants") continue;
+          if (assetDir === "hooks" && entry === "hooks.json") {
+            copyToolHooksJson(destDir, pkg, srcDir);
+            continue;
+          }
+          const src = path.join(srcDir, entry);
+          const dest = path.join(destDir, entry);
+          if (fs.existsSync(dest)) continue;
+          fs.cpSync(src, dest, { recursive: true, force: false });
+          console.log(`  \u590D\u5236 ${pkg}/${assetDir}/${entry}`);
+        }
+      }
+    }
+  }
+  let cleanedCount = 0;
+  function cleanTests(dir) {
+    if (!fs.existsSync(dir)) return;
+    for (const entry of fs.readdirSync(dir)) {
+      const full = path.join(dir, entry);
+      if (!fs.statSync(full).isDirectory()) continue;
+      if (entry === "__tests__") {
+        fs.rmSync(full, { recursive: true, force: true });
+        cleanedCount++;
+      } else {
+        cleanTests(full);
+      }
+    }
+  }
+  for (const assetDir of assetDirs) {
+    const d = path.join(distDir, assetDir);
+    if (fs.existsSync(d)) cleanTests(d);
+  }
+  if (cleanedCount > 0) console.log(`  \u2714 \u5DF2\u6E05\u7406 ${cleanedCount} \u4E2A __tests__ \u76EE\u5F55`);
+  if (fs.existsSync(cliMcpDir)) {
+    const destDir = path.join(distDir, "mcp");
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs.readdirSync(cliMcpDir)) {
+      if (entry === ".DS_Store") continue;
+      const src = path.join(cliMcpDir, entry);
+      const dest = path.join(destDir, entry);
+      fs.cpSync(src, dest, { recursive: true, force: true });
+    }
+    console.log(`  \u590D\u5236 cli/mcp/ \u2192 dist/mcp/`);
+  }
+  const cliMcpSkillsSrc = path.join(cliDir, "mcp-skills");
+  if (fs.existsSync(cliMcpSkillsSrc)) {
+    const destDir = path.join(distDir, "mcp-skills");
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs.readdirSync(cliMcpSkillsSrc)) {
+      if (entry === ".DS_Store") continue;
+      const src = path.join(cliMcpSkillsSrc, entry);
+      const dest = path.join(destDir, entry);
+      fs.cpSync(src, dest, { recursive: true, force: true });
+    }
+    console.log(`  \u590D\u5236 cli/mcp-skills/ \u2192 dist/mcp-skills/`);
+  }
+  const cliEnvExamplesSrc = path.join(cliDir, "env-examples");
+  if (fs.existsSync(cliEnvExamplesSrc)) {
+    const destDir = path.join(distDir, "env-examples");
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs.readdirSync(cliEnvExamplesSrc)) {
+      if (entry === ".DS_Store") continue;
+      const src = path.join(cliEnvExamplesSrc, entry);
+      const dest = path.join(destDir, entry);
+      fs.cpSync(src, dest, { recursive: true, force: true });
+    }
+    console.log(`  \u590D\u5236 cli/env-examples/ \u2192 dist/env-examples/`);
+  }
+  const registryPath = path.join(distDir, "registry.json");
+  fs.mkdirSync(distDir, { recursive: true });
+  fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  const schemaSrc = path.join(cliDir, "config-schema.json");
+  const schemaDest = path.join(distDir, "config-schema.json");
+  if (fs.existsSync(schemaSrc)) {
+    fs.cpSync(schemaSrc, schemaDest, { force: true });
+  }
+  console.log(`
+\u{1F4E6} registry.json \u5DF2\u751F\u6210 \u2192 ${registryPath}`);
+  console.log(`   tools: ${Object.keys(registry.tools).length} \u4E2A\u5DE5\u5177`);
+  console.log(`   wizards: ${Object.keys(registry.wizards).length} \u4E2A`);
+  console.log(`   skills: ${Object.keys(registry.skills).length} \u4E2A`);
+  console.log("\n\u2714 \u6784\u5EFA\u5B8C\u6210");
+}
+function copyToolHooksJson(destDir, pkg, srcDir) {
+  const destPath = path.join(destDir, `${pkg}-hooks.json`);
+  const srcPath = path.join(srcDir, "hooks.json");
+  if (!fs.existsSync(srcPath)) return;
+  const destDirExists = fs.existsSync(destDir);
+  if (!destDirExists) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+  fs.cpSync(srcPath, destPath, { force: true });
+  console.log(`  \u590D\u5236 ${pkg}/hooks/hooks.json \u2192 ${pkg}-hooks.json`);
+}
+const isMainModule = typeof require !== "undefined" && typeof module !== "undefined" && require.main === module;
+if (isMainModule) {
+  const cliDir = path.resolve(__dirname, "..");
+  buildRegistry(cliDir);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRegistry
+});