@zeyue0329/xiaoma-cli 1.20.0 → 1.22.0

package/tools/installer/modules/version-resolver.js

@@ -2,7 +2,7 @@ const path = require('node:path');
 const semver = require('semver');
 const yaml = require('yaml');
 const fs = require('../fs-native');
-const { getExternalModuleCachePath, getModulePath, resolveInstalledModuleYaml } = require('../project-root');
+const { BUILTIN_MODULE_CODES, getExternalModuleCachePath, getModulePath, resolveInstalledModuleYaml } = require('../project-root');
 
 const DEFAULT_PARENT_DEPTH = 8;
 
@@ -141,7 +141,7 @@ async function buildSearchRoots(moduleName, moduleSourcePath) {
 
   await addRoot(moduleSourcePath);
 
-  if (moduleName === 'core' || moduleName === 'xmc' || moduleName === 'xpm') {
+  if (BUILTIN_MODULE_CODES.includes(moduleName)) {
     await addRoot(getModulePath(moduleName));
   } else {
     await addRoot(getExternalModuleCachePath(moduleName));

package/tools/installer/project-root.js

@@ -59,20 +59,22 @@ function getSourcePath(...segments) {
   return path.join(getProjectRoot(), 'src', ...segments);
 }
 
+/**
+ * Built-in module codes. Each ships inside this repo as `src/<code>-skills/`
+ * and is versioned with the CLI itself; every other code resolves to an
+ * external/community/custom source. Single source of truth — the installer,
+ * manifest writer, version resolver, and `--list-options` all key off this.
+ */
+const BUILTIN_MODULE_CODES = ['core', 'xmc', 'xpm', 'zqyl'];
+
 /**
  * Get path to a module's directory
- * core, xmc, and xpm are built-in modules directly under src/ (as *-skills dirs)
+ * Built-in modules live directly under src/ (as *-skills dirs)
  * All other modules are stored remote
  */
 function getModulePath(moduleName, ...segments) {
-  if (moduleName === 'core') {
-    return getSourcePath('core-skills', ...segments);
-  }
-  if (moduleName === 'xmc') {
-    return getSourcePath('xmc-skills', ...segments);
-  }
-  if (moduleName === 'xpm') {
-    return getSourcePath('xpm-skills', ...segments);
+  if (BUILTIN_MODULE_CODES.includes(moduleName)) {
+    return getSourcePath(`${moduleName}-skills`, ...segments);
   }
   return getSourcePath('modules', moduleName, ...segments);
 }
@@ -221,6 +223,7 @@ async function resolveInstalledModuleYaml(moduleName) {
 }
 
 module.exports = {
+  BUILTIN_MODULE_CODES,
   getProjectRoot,
   getSourcePath,
   getModulePath,

package/tools/installer/ui.js

@@ -7,6 +7,7 @@ const { CLIUtils } = require('./cli-utils');
 const { ExternalModuleManager } = require('./modules/external-manager');
 const { resolveModuleVersion } = require('./modules/version-resolver');
 const { Manifest } = require('./core/manifest');
+const { BUILTIN_MODULE_CODES } = require('./project-root');
 const {
   parseChannelOptions,
   buildPlan,
@@ -884,7 +885,7 @@ class UI {
     // they can be managed via --custom-source, uninstall, or a dedicated installer.
     const externalManager = new ExternalModuleManager();
     const registryModules = await externalManager.listAvailable();
-    const officialRegistryCodes = new Set(['core', 'xmc', 'xpm', ...registryModules.map((m) => m.code)]);
+    const officialRegistryCodes = new Set([...BUILTIN_MODULE_CODES, ...registryModules.map((m) => m.code)]);
     const installedNonOfficial = [...installedModuleIds].filter((id) => !officialRegistryCodes.has(id));
 
     // Phase 2: Custom URL modules

package/tools/validate-zqyl-pack.js

@@ -0,0 +1,171 @@
+/**
+ * ZQYL Pack Consistency Validator
+ *
+ * The zqyl module is the only pack whose skills ship in three near-identical
+ * platform variants (backend / mid / front), and whose descriptions carry
+ * import-authored text that asserts facts about OTHER files. A multi-agent UAT
+ * showed both failure modes are silent: a wrong `platformType` produces the wrong
+ * theme with no console error, and a skill reference that does not resolve just
+ * makes the agent guess. Neither is caught by validate-skills.js (frontmatter
+ * shape) or validate-file-refs.js (path resolution) — skill NAMES are not paths.
+ *
+ * What it checks:
+ * - ZQYL-01: every `xiaoma-zqyl-*` skill name asserted anywhere in the pack resolves
+ *            to an installed skill directory (placeholder forms are exempt)
+ * - ZQYL-02: the `platformType` quoted in a skill's description equals the value in
+ *            that same skill's body (`- platformType：`x``) — catches invented values
+ * - ZQYL-03: frontmatter `name` matches the directory (the manifest generator skips
+ *            mismatches silently, so the skill would vanish at install time)
+ * - ZQYL-04: no unresolved `{平台}` placeholder inside a platform-pinned file
+ * - ZQYL-05: components-index.md's availability matrix matches the directories on disk
+ *
+ * Usage:
+ *   node tools/validate-zqyl-pack.js            # report, exit 0
+ *   node tools/validate-zqyl-pack.js --strict   # exit 1 on any finding
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const yaml = require('yaml');
+
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+const PACK_DIR = path.join(PROJECT_ROOT, 'src', 'zqyl-skills');
+const INDEX_FILE = path.join(PACK_DIR, 'xiaoma-zqyl-ui-spec', 'components-index.md');
+const STRICT = process.argv.includes('--strict');
+
+const PLATFORMS = ['backend', 'mid', 'front'];
+const findings = [];
+
+function report(rule, file, detail) {
+  findings.push({ rule, file: path.relative(PROJECT_ROOT, file), detail });
+}
+
+function walk(dir, onFile) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) walk(full, onFile);
+    else onFile(full);
+  }
+}
+
+if (!fs.existsSync(PACK_DIR)) {
+  console.log('src/zqyl-skills not present — nothing to validate.');
+  process.exit(0);
+}
+
+// --- collect skills -------------------------------------------------------
+
+const skills = new Map(); // name -> { dir, fm, body }
+walk(PACK_DIR, (file) => {
+  if (path.basename(file) !== 'SKILL.md') return;
+  const raw = fs.readFileSync(file, 'utf8').replaceAll('\r\n', '\n');
+  const match = raw.match(/^---\n([\S\s]*?)\n---\n/);
+  if (!match) {
+    report('ZQYL-03', file, 'SKILL.md has no frontmatter');
+    return;
+  }
+  let fm;
+  try {
+    fm = yaml.parse(match[1]);
+  } catch (error) {
+    report('ZQYL-03', file, `unparseable frontmatter: ${error.message}`);
+    return;
+  }
+  const dirName = path.basename(path.dirname(file));
+  if (!fm || fm.name !== dirName) {
+    report('ZQYL-03', file, `frontmatter name "${fm && fm.name}" != directory "${dirName}" — the installer would skip this skill silently`);
+    return;
+  }
+  skills.set(fm.name, { dir: path.dirname(file), fm, body: raw.slice(match[0].length) });
+});
+
+// --- ZQYL-01: asserted skill names resolve --------------------------------
+
+walk(PACK_DIR, (file) => {
+  if (!file.endsWith('.md')) return;
+  const text = fs.readFileSync(file, 'utf8');
+  for (const [lineNo, line] of text.split('\n').entries()) {
+    for (const m of line.matchAll(/xiaoma-zqyl-[a-z0-9-]+/g)) {
+      const name = m[0];
+      const after = line.slice(m.index + name.length);
+      // `xiaoma-zqyl-{组件 key}-{平台}` and `xiaoma-zqyl-{line,bar}-chart-…` are notation, not claims
+      if (after.startsWith('{') || after.startsWith(',')) continue;
+      if (skills.has(name)) continue;
+      report('ZQYL-01', file, `line ${lineNo + 1}: references "${name}", which is not a skill in this pack`);
+    }
+  }
+});
+
+// --- ZQYL-02: description platformType matches the skill's own body -------
+
+for (const [name, { dir, fm, body }] of skills) {
+  const claimed = fm.description && fm.description.match(/platformType\s*`([A-Za-z]+)`/);
+  if (!claimed) continue;
+  const own = body.match(/^-\s*platformType[：:]\s*`([A-Za-z]+)`/m);
+  if (own && own[1] !== claimed[1]) {
+    report(
+      'ZQYL-02',
+      path.join(dir, 'SKILL.md'),
+      `description claims platformType \`${claimed[1]}\` but the body declares \`${own[1]}\` (${name})`,
+    );
+  }
+}
+
+// --- ZQYL-04: no {平台} left in a platform-pinned file ---------------------
+
+for (const [name, { dir }] of skills) {
+  if (!PLATFORMS.some((p) => name.endsWith(`-${p}`))) continue;
+  walk(dir, (file) => {
+    if (!file.endsWith('.md')) return;
+    const text = fs.readFileSync(file, 'utf8');
+    for (const [lineNo, line] of text.split('\n').entries()) {
+      // only flag placeholders attached to a skill reference; prose notation elsewhere is fine
+      if (/xiaoma-zqyl-[a-z0-9-]*-\{平台\}/.test(line)) {
+        report('ZQYL-04', file, `line ${lineNo + 1}: unresolved {平台} in "${name}", a skill already pinned to one platform`);
+      }
+    }
+  });
+}
+
+// --- ZQYL-05: components-index matrix matches disk ------------------------
+
+if (fs.existsSync(INDEX_FILE)) {
+  const rows = fs
+    .readFileSync(INDEX_FILE, 'utf8')
+    .split('\n')
+    .filter((l) => /^\|\s*`[a-z-]+`\s*\|/.test(l));
+  for (const row of rows) {
+    const cells = row.split('|').map((c) => c.trim());
+    const key = cells[1].replaceAll('`', '');
+    const [b, m, f] = [cells[3], cells[4], cells[5]];
+    for (const [platform, cell] of [
+      ['backend', b],
+      ['mid', m],
+      ['front', f],
+    ]) {
+      const claimsAvailable = cell === '✅';
+      const exists = skills.has(`xiaoma-zqyl-${key}-${platform}`);
+      if (claimsAvailable !== exists) {
+        report(
+          'ZQYL-05',
+          INDEX_FILE,
+          `"${key}" is marked ${claimsAvailable ? 'available' : 'unavailable'} on ${platform}, but xiaoma-zqyl-${key}-${platform} ${exists ? 'exists' : 'does not exist'}`,
+        );
+      }
+    }
+  }
+} else {
+  report('ZQYL-05', INDEX_FILE, 'components-index.md is missing — the 24 chart skills lose their only entry point');
+}
+
+// --- output ---------------------------------------------------------------
+
+console.log(`\nZQYL pack validation: ${skills.size} skills in ${path.relative(PROJECT_ROOT, PACK_DIR)}\n`);
+if (findings.length === 0) {
+  console.log('   All checks passed.\n');
+} else {
+  for (const f of findings) console.log(`  [${f.rule}] ${f.file}\n    ${f.detail}`);
+  console.log(`\n   ${findings.length} finding(s).\n`);
+}
+
+if (STRICT && findings.length > 0) process.exit(1);