@zeyue0329/xiaoma-cli 1.12.0 → 1.15.0

package/tools/{cli/installers/lib → installer}/ide/shared/path-utils.js

@@ -15,8 +15,6 @@
  * - standalone/agents/fred.md → xiaoma-agent-standalone-fred.md
  */
 
-// Type segments - agents are included in naming, others are filtered out
-const TYPE_SEGMENTS = ['workflows', 'tasks', 'tools'];
 const AGENT_SEGMENT = 'agents';
 
 // XiaoMa installation folder name - centralized constant for all installers
@@ -194,125 +192,6 @@ function parseDashName(filename) {
   };
 }
 
-// ============================================================================
-// LEGACY FUNCTIONS (underscore format) - kept for backward compatibility
-// ============================================================================
-
-/**
- * Convert hierarchical path to flat underscore-separated name (LEGACY)
- * @deprecated Use toDashName instead
- */
-function toUnderscoreName(module, type, name) {
-  const isAgent = type === AGENT_SEGMENT;
-  if (module === 'core') {
-    return isAgent ? `xiaoma_agent_${name}.md` : `xiaoma_${name}.md`;
-  }
-  if (module === 'standalone') {
-    return isAgent ? `xiaoma_agent_standalone_${name}.md` : `xiaoma_standalone_${name}.md`;
-  }
-  return isAgent ? `xiaoma_${module}_agent_${name}.md` : `xiaoma_${module}_${name}.md`;
-}
-
-/**
- * Convert relative path to flat underscore-separated name (LEGACY)
- * @deprecated Use toDashPath instead
- */
-function toUnderscorePath(relativePath) {
-  // Strip common file extensions (same as toDashPath for consistency)
-  const withoutExt = relativePath.replace(/\.(md|yaml|yml|json|xml|toml)$/i, '');
-  const parts = withoutExt.split(/[/\\]/);
-
-  const module = parts[0];
-  const type = parts[1];
-  const name = parts.slice(2).join('_');
-
-  return toUnderscoreName(module, type, name);
-}
-
-/**
- * Create custom agent underscore name (LEGACY)
- * @deprecated Use customAgentDashName instead
- */
-function customAgentUnderscoreName(agentName) {
-  return `xiaoma_custom_${agentName}.md`;
-}
-
-/**
- * Check if a filename uses underscore format (LEGACY)
- * @deprecated Use isDashFormat instead
- */
-function isUnderscoreFormat(filename) {
-  return filename.startsWith('xiaoma_') && filename.includes('_');
-}
-
-/**
- * Extract parts from an underscore-formatted filename (LEGACY)
- * @deprecated Use parseDashName instead
- */
-function parseUnderscoreName(filename) {
-  const withoutExt = filename.replace('.md', '');
-  const parts = withoutExt.split('_');
-
-  if (parts.length < 2 || parts[0] !== 'xiaoma') {
-    return null;
-  }
-
-  const agentIndex = parts.indexOf('agent');
-
-  if (agentIndex !== -1) {
-    if (agentIndex === 1) {
-      // xiaoma_agent_... - check for standalone
-      if (parts.length >= 4 && parts[2] === 'standalone') {
-        return {
-          prefix: parts[0],
-          module: 'standalone',
-          type: 'agents',
-          name: parts.slice(3).join('_'),
-        };
-      }
-      return {
-        prefix: parts[0],
-        module: 'core',
-        type: 'agents',
-        name: parts.slice(agentIndex + 1).join('_'),
-      };
-    } else {
-      return {
-        prefix: parts[0],
-        module: parts[1],
-        type: 'agents',
-        name: parts.slice(agentIndex + 1).join('_'),
-      };
-    }
-  }
-
-  if (parts.length === 2) {
-    return {
-      prefix: parts[0],
-      module: 'core',
-      type: 'workflows',
-      name: parts[1],
-    };
-  }
-
-  // Check for standalone non-agent: xiaoma_standalone_name
-  if (parts[1] === 'standalone') {
-    return {
-      prefix: parts[0],
-      module: 'standalone',
-      type: 'workflows',
-      name: parts.slice(2).join('_'),
-    };
-  }
-
-  return {
-    prefix: parts[0],
-    module: parts[1],
-    type: 'workflows',
-    name: parts.slice(2).join('_'),
-  };
-}
-
 /**
  * Resolve the skill name for an artifact.
  * Prefers canonicalId from a xiaoma-skill-manifest.yaml sidecar when available,
@@ -328,37 +207,13 @@ function resolveSkillName(artifact) {
   return toDashPath(artifact.relativePath);
 }
 
-// Backward compatibility aliases (colon format was same as underscore)
-const toColonName = toUnderscoreName;
-const toColonPath = toUnderscorePath;
-const customAgentColonName = customAgentUnderscoreName;
-const isColonFormat = isUnderscoreFormat;
-const parseColonName = parseUnderscoreName;
-
 module.exports = {
-  // New standard (dash-based)
   toDashName,
   toDashPath,
   resolveSkillName,
   customAgentDashName,
   isDashFormat,
   parseDashName,
-
-  // Legacy (underscore-based) - kept for backward compatibility
-  toUnderscoreName,
-  toUnderscorePath,
-  customAgentUnderscoreName,
-  isUnderscoreFormat,
-  parseUnderscoreName,
-
-  // Backward compatibility aliases
-  toColonName,
-  toColonPath,
-  customAgentColonName,
-  isColonFormat,
-  parseColonName,
-
-  TYPE_SEGMENTS,
   AGENT_SEGMENT,
   XiaoMa_FOLDER_NAME,
 };

package/tools/{cli/installers/lib → installer}/ide/shared/skill-manifest.js

@@ -1,5 +1,5 @@
 const path = require('node:path');
-const fs = require('fs-extra');
+const fs = require('../../fs-native');
 const yaml = require('yaml');
 
 /**
@@ -27,7 +27,7 @@ async function loadSkillManifest(dirPath) {
 /**
  * Get the canonicalId for a specific file from a loaded skill manifest.
  * @param {Object|null} manifest - Loaded manifest (from loadSkillManifest)
- * @param {string} filename - Source filename to look up (e.g., 'pm.md', 'help.md', 'pm.agent.yaml')
+ * @param {string} filename - Source filename to look up (e.g., 'pm.md', 'help.md')
  * @returns {string} canonicalId or empty string
  */
 function getCanonicalId(manifest, filename) {
@@ -36,12 +36,6 @@ function getCanonicalId(manifest, filename) {
   if (manifest.__single) return manifest.__single.canonicalId || '';
   // Multi-entry: look up by filename directly
   if (manifest[filename]) return manifest[filename].canonicalId || '';
-  // Fallback: try alternate extensions for compiled files
-  const baseName = filename.replace(/\.(md|xml)$/i, '');
-  const agentKey = `${baseName}.agent.yaml`;
-  if (manifest[agentKey]) return manifest[agentKey].canonicalId || '';
-  const xmlKey = `${baseName}.xml`;
-  if (manifest[xmlKey]) return manifest[xmlKey].canonicalId || '';
   return '';
 }
 
@@ -57,34 +51,7 @@ function getArtifactType(manifest, filename) {
   if (manifest.__single) return manifest.__single.type || null;
   // Multi-entry: look up by filename directly
   if (manifest[filename]) return manifest[filename].type || null;
-  // Fallback: try alternate extensions for compiled files
-  const baseName = filename.replace(/\.(md|xml)$/i, '');
-  const agentKey = `${baseName}.agent.yaml`;
-  if (manifest[agentKey]) return manifest[agentKey].type || null;
-  const xmlKey = `${baseName}.xml`;
-  if (manifest[xmlKey]) return manifest[xmlKey].type || null;
   return null;
 }
 
-/**
- * Get the install_to_xiaoma flag for a specific file from a loaded skill manifest.
- * @param {Object|null} manifest - Loaded manifest (from loadSkillManifest)
- * @param {string} filename - Source filename to look up
- * @returns {boolean} install_to_xiaoma value (defaults to true)
- */
-function getInstallToXiaoma(manifest, filename) {
-  if (!manifest) return true;
-  // Single-entry manifest applies to all files in the directory
-  if (manifest.__single) return manifest.__single.install_to_xiaoma !== false;
-  // Multi-entry: look up by filename directly
-  if (manifest[filename]) return manifest[filename].install_to_xiaoma !== false;
-  // Fallback: try alternate extensions for compiled files
-  const baseName = filename.replace(/\.(md|xml)$/i, '');
-  const agentKey = `${baseName}.agent.yaml`;
-  if (manifest[agentKey]) return manifest[agentKey].install_to_xiaoma !== false;
-  const xmlKey = `${baseName}.xml`;
-  if (manifest[xmlKey]) return manifest[xmlKey].install_to_xiaoma !== false;
-  return true;
-}
-
-module.exports = { loadSkillManifest, getCanonicalId, getArtifactType, getInstallToXiaoma };
+module.exports = { loadSkillManifest, getCanonicalId, getArtifactType };

package/tools/installer/list-options.js

@@ -0,0 +1,210 @@
+const path = require('node:path');
+const fs = require('./fs-native');
+const yaml = require('yaml');
+const { getProjectRoot, getModulePath, getExternalModuleCachePath } = require('./project-root');
+
+/**
+ * Read a module.yaml and return its declared `code:` field, or null if missing/unparseable.
+ */
+async function readModuleCode(yamlPath) {
+  try {
+    const parsed = yaml.parse(await fs.readFile(yamlPath, 'utf8'));
+    if (parsed && typeof parsed === 'object' && typeof parsed.code === 'string') {
+      return parsed.code;
+    }
+  } catch {
+    // fall through
+  }
+  return null;
+}
+
+/**
+ * Discover module.yaml files for officials we can read locally:
+ *   - core, xmc: bundled in src/ (always present)
+ *   - external officials: only if previously cloned to ~/.xiaoma/cache/external-modules/
+ *
+ * Each result's `code` is the `code:` field from the module.yaml when present;
+ * that's the value `--set <module>.<key>=<value>` matches against.
+ *
+ * Community/custom modules are not enumerated; users reference their own
+ * module.yaml directly per the design (see issue #1663).
+ *
+ * @returns {Promise<Array<{code: string, yamlPath: string, source: string}>>}
+ */
+async function discoverOfficialModuleYamls() {
+  const found = [];
+  // Dedupe is case-insensitive because module caches occasionally retain a
+  // legacy UPPERCASE-named directory alongside the canonical lowercase one
+  // (same module, different cache key from an older schema). We pick whichever
+  // entry we see first and skip the alternate-case duplicate. NOTE: `--set`
+  // matching itself is case-sensitive (it keys on `moduleName` from the install
+  // flow's selected list, which is always lowercase short codes), so the
+  // surfaced `code` here is what users should type. Don't change to
+  // case-sensitive dedupe without revisiting that contract.
+  const seenCodes = new Set();
+
+  const addFound = async (yamlPath, source, fallbackCode) => {
+    const declaredCode = await readModuleCode(yamlPath);
+    const code = declaredCode || fallbackCode;
+    if (!code) return;
+    const lower = code.toLowerCase();
+    if (seenCodes.has(lower)) return;
+    seenCodes.add(lower);
+    found.push({ code, yamlPath, source });
+  };
+
+  // Built-ins.
+  for (const code of ['core', 'xmc', 'xpm']) {
+    const yamlPath = path.join(getModulePath(code), 'module.yaml');
+    if (await fs.pathExists(yamlPath)) {
+      // Built-ins use their well-known short codes regardless of what the
+      // module.yaml `code:` says, since the install flow keys on these.
+      seenCodes.add(code.toLowerCase());
+      found.push({ code, yamlPath, source: 'built-in' });
+    }
+  }
+
+  // Bundled in src/modules/<code>/module.yaml (rare, but supported by getModulePath).
+  const srcModulesDir = path.join(getProjectRoot(), 'src', 'modules');
+  if (await fs.pathExists(srcModulesDir)) {
+    const entries = await fs.readdir(srcModulesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const yamlPath = path.join(srcModulesDir, entry.name, 'module.yaml');
+      if (await fs.pathExists(yamlPath)) {
+        await addFound(yamlPath, 'bundled', entry.name);
+      }
+    }
+  }
+
+  // External cache (~/.xiaoma/cache/external-modules/<code>/...).
+  const cacheRoot = getExternalModuleCachePath('').replace(/\/$/, '');
+  if (await fs.pathExists(cacheRoot)) {
+    const rawEntries = await fs.readdir(cacheRoot, { withFileTypes: true });
+    for (const entry of rawEntries) {
+      if (!entry.isDirectory()) continue;
+      const candidates = [
+        path.join(cacheRoot, entry.name, 'module.yaml'),
+        path.join(cacheRoot, entry.name, 'src', 'module.yaml'),
+        path.join(cacheRoot, entry.name, 'skills', 'module.yaml'),
+      ];
+      for (const candidate of candidates) {
+        if (await fs.pathExists(candidate)) {
+          await addFound(candidate, 'cached', entry.name);
+          break;
+        }
+      }
+    }
+  }
+
+  return found;
+}
+
+function formatPromptText(item) {
+  if (Array.isArray(item.prompt)) return item.prompt.join(' ');
+  return String(item.prompt || '').trim();
+}
+
+function inferType(item) {
+  if (item['single-select']) return 'single-select';
+  if (item['multi-select']) return 'multi-select';
+  if (typeof item.default === 'boolean') return 'boolean';
+  if (typeof item.default === 'number') return 'number';
+  return 'string';
+}
+
+function formatModuleOptions(code, parsed, source) {
+  const lines = [];
+  const header = source === 'built-in' ? code : `${code} (${source})`;
+  lines.push(header + ':');
+
+  let count = 0;
+  for (const [key, item] of Object.entries(parsed)) {
+    if (!item || typeof item !== 'object' || !('prompt' in item)) continue;
+    count++;
+    const type = inferType(item);
+    const scope = item.scope === 'user' ? ' [user-scope]' : '';
+    const defaultStr = item.default === undefined || item.default === null ? '(none)' : String(item.default);
+    lines.push(`  ${code}.${key}    (${type}${scope})  default: ${defaultStr}`);
+    const promptText = formatPromptText(item);
+    if (promptText) lines.push(`    ${promptText}`);
+    if (Array.isArray(item['single-select'])) {
+      const values = item['single-select'].map((v) => (typeof v === 'object' ? v.value : v)).filter((v) => v !== undefined);
+      if (values.length > 0) lines.push(`    values: ${values.join(' | ')}`);
+    }
+    lines.push('');
+  }
+
+  if (count === 0) {
+    lines.push('  (no configurable options)', '');
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Render `--list-options` output.
+ *
+ * Returns `{ text, ok }` so callers can surface a non-zero exit code on
+ * a typo'd module-code lookup. Discovery dedupes case-insensitively, so
+ * the lookup is also case-insensitive — typing `--list-options XMC` and
+ * `--list-options xmc` both find the xmc built-in.
+ *
+ * @param {string|null} moduleCode - if non-null, restrict to this module
+ * @returns {Promise<{text: string, ok: boolean}>}
+ */
+async function formatOptionsList(moduleCode) {
+  const discovered = await discoverOfficialModuleYamls();
+  const needle = moduleCode ? moduleCode.toLowerCase() : null;
+  const filtered = needle ? discovered.filter((d) => d.code.toLowerCase() === needle) : discovered;
+
+  if (filtered.length === 0) {
+    if (moduleCode) {
+      const text = [
+        `No locally-known module.yaml for '${moduleCode}'.`,
+        '',
+        'Built-in modules (core, xmc) are always available. External officials',
+        'appear here after they have been installed at least once on this machine',
+        '(they are cached under ~/.xiaoma/cache/external-modules/).',
+        '',
+        'For community or custom modules, read the module.yaml file in that',
+        "module's source repository directly.",
+      ].join('\n');
+      return { text, ok: false };
+    }
+    return { text: 'No modules found.', ok: false };
+  }
+
+  const sections = [];
+  // Track when a module-scoped lookup couldn't actually be rendered (yaml
+  // unparseable or empty after parse). The full `--list-options` output is
+  // tolerant of one bad entry, but `--list-options <module>` against a single
+  // unreadable module should still fail tooling so a CI script catches it.
+  let moduleScopedFailure = false;
+  sections.push('Available --set keys', 'Format: --set <module>.<key>=<value> (repeatable)', '');
+  for (const { code, yamlPath, source } of filtered) {
+    let parsed;
+    try {
+      parsed = yaml.parse(await fs.readFile(yamlPath, 'utf8'));
+    } catch {
+      sections.push(`${code} (${source}): could not parse module.yaml`, '');
+      if (moduleCode) moduleScopedFailure = true;
+      continue;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      sections.push(`${code} (${source}): module.yaml is not a valid object (got ${Array.isArray(parsed) ? 'array' : typeof parsed})`, '');
+      if (moduleCode) moduleScopedFailure = true;
+      continue;
+    }
+    sections.push(formatModuleOptions(code, parsed, source));
+  }
+
+  if (!moduleCode) {
+    sections.push(
+      'Community and custom modules are not listed here — read their module.yaml directly. Unknown keys still persist with a warning.',
+    );
+  }
+
+  return { text: sections.join('\n'), ok: !moduleScopedFailure };
+}
+
+module.exports = { formatOptionsList, discoverOfficialModuleYamls };

package/tools/{cli/installers/lib → installer}/message-loader.js

@@ -1,7 +1,7 @@
-const fs = require('fs-extra');
+const fs = require('./fs-native');
 const path = require('node:path');
 const yaml = require('yaml');
-const prompts = require('../../lib/prompts');
+const prompts = require('./prompts');
 
 /**
  * Load and display installer messages from messages.yaml
@@ -18,7 +18,7 @@ class MessageLoader {
       return this.messages;
     }
 
-    const messagesPath = path.join(__dirname, '..', 'install-messages.yaml');
+    const messagesPath = path.join(__dirname, 'install-messages.yaml');
 
     try {
       const content = fs.readFileSync(messagesPath, 'utf8');

package/tools/installer/modules/channel-plan.js

@@ -0,0 +1,203 @@
+/**
+ * Channel plan: the per-module resolution decision applied at install time.
+ *
+ * A "plan entry" for a module is:
+ *   { channel: 'stable'|'next'|'pinned', pin?: string }
+ *
+ * We build the plan from:
+ *   1. CLI flags (--channel / --all-* / --next=CODE / --pin CODE=TAG)
+ *   2. Interactive answers (the "all stable?" gate + per-module picker)
+ *   3. Registry defaults (default_channel from xiaoma-modules.yaml)
+ *   4. Hardcoded fallback 'stable'
+ *
+ * Precedence: --pin > --next=CODE > --channel (global) > registry default > 'stable'.
+ *
+ * This module is pure. No prompts, no git, no filesystem.
+ */
+
+const VALID_CHANNELS = new Set(['stable', 'next']);
+
+/**
+ * Parse raw commander options into a structured channel options object.
+ *
+ * @param {Object} options - raw command-line options
+ * @returns {{
+ *   global: 'stable'|'next'|null,
+ *   nextSet: Set<string>,
+ *   pins: Map<string, string>,
+ *   warnings: string[]
+ * }}
+ */
+function parseChannelOptions(options = {}) {
+  const warnings = [];
+
+  // Global channel from --channel / --all-stable / --all-next.
+  let global = null;
+  const aliases = [];
+  if (options.channel) aliases.push({ flag: '--channel', value: normalizeChannel(options.channel, warnings, '--channel') });
+  if (options.allStable) aliases.push({ flag: '--all-stable', value: 'stable' });
+  if (options.allNext) aliases.push({ flag: '--all-next', value: 'next' });
+
+  const distinct = new Set(aliases.map((a) => a.value).filter(Boolean));
+  if (distinct.size > 1) {
+    warnings.push(
+      `Conflicting channel flags: ${aliases
+        .filter((a) => a.value)
+        .map((a) => a.flag + '=' + a.value)
+        .join(', ')}. Using first: ${aliases.find((a) => a.value).flag}.`,
+    );
+  }
+  const firstValid = aliases.find((a) => a.value);
+  if (firstValid) global = firstValid.value;
+
+  // --next=CODE (repeatable)
+  const nextSet = new Set();
+  for (const code of options.next || []) {
+    const trimmed = String(code).trim();
+    if (!trimmed) continue;
+    nextSet.add(trimmed);
+  }
+
+  // --pin CODE=TAG (repeatable)
+  const pins = new Map();
+  for (const spec of options.pin || []) {
+    const parsed = parsePinSpec(spec);
+    if (!parsed) {
+      warnings.push(`Ignoring malformed --pin value '${spec}'. Expected CODE=TAG.`);
+      continue;
+    }
+    if (pins.has(parsed.code)) {
+      warnings.push(`--pin specified multiple times for '${parsed.code}'. Using last: ${parsed.tag}.`);
+    }
+    pins.set(parsed.code, parsed.tag);
+  }
+
+  // --yes auto-confirms the community-module curator-bypass prompt so
+  // headless installs with --next=/--pin for a community module don't hang.
+  const acceptBypass = options.yes === true || options.acceptBypass === true;
+
+  return { global, nextSet, pins, warnings, acceptBypass };
+}
+
+function normalizeChannel(raw, warnings, flagName) {
+  if (typeof raw !== 'string') return null;
+  const lower = raw.trim().toLowerCase();
+  if (VALID_CHANNELS.has(lower)) return lower;
+  warnings.push(`Ignoring invalid ${flagName} value '${raw}'. Expected one of: stable, next.`);
+  return null;
+}
+
+function parsePinSpec(spec) {
+  if (typeof spec !== 'string') return null;
+  const idx = spec.indexOf('=');
+  if (idx <= 0 || idx === spec.length - 1) return null;
+  const code = spec.slice(0, idx).trim();
+  const tag = spec.slice(idx + 1).trim();
+  if (!code || !tag) return null;
+  return { code, tag };
+}
+
+/**
+ * Build a per-module plan entry, applying precedence.
+ *
+ * @param {Object} args
+ * @param {string} args.code
+ * @param {Object} args.channelOptions - from parseChannelOptions
+ * @param {string} [args.registryDefault] - module's default_channel, if any
+ * @returns {{channel: 'stable'|'next'|'pinned', pin?: string, source: string}}
+ *   source describes where the decision came from, for logging / debugging.
+ */
+function decideChannelForModule({ code, channelOptions, registryDefault }) {
+  const { global, nextSet, pins } = channelOptions || { nextSet: new Set(), pins: new Map() };
+
+  if (pins && pins.has(code)) {
+    return { channel: 'pinned', pin: pins.get(code), source: 'flag:--pin' };
+  }
+  if (nextSet && nextSet.has(code)) {
+    return { channel: 'next', source: 'flag:--next' };
+  }
+  if (global) {
+    return { channel: global, source: 'flag:--channel' };
+  }
+  if (registryDefault && VALID_CHANNELS.has(registryDefault)) {
+    return { channel: registryDefault, source: 'registry' };
+  }
+  return { channel: 'stable', source: 'default' };
+}
+
+/**
+ * Build a full channel plan map for a set of modules.
+ *
+ * @param {Object} args
+ * @param {Array<{code: string, defaultChannel?: string, builtIn?: boolean}>} args.modules
+ *   Only the modules that need a channel entry; callers should filter out
+ *   bundled modules (core/xmc) before calling.
+ * @param {Object} args.channelOptions - from parseChannelOptions
+ * @returns {Map<string, {channel: string, pin?: string, source: string}>}
+ */
+function buildPlan({ modules, channelOptions }) {
+  const plan = new Map();
+  for (const mod of modules || []) {
+    plan.set(
+      mod.code,
+      decideChannelForModule({
+        code: mod.code,
+        channelOptions,
+        registryDefault: mod.defaultChannel,
+      }),
+    );
+  }
+  return plan;
+}
+
+/**
+ * Report any --pin CODE=TAG entries that don't correspond to a selected module.
+ * These get warned about but don't abort the install.
+ */
+function orphanPinWarnings(channelOptions, selectedCodes) {
+  const warnings = [];
+  const selected = new Set(selectedCodes || []);
+  for (const code of channelOptions?.pins?.keys() || []) {
+    if (!selected.has(code)) {
+      warnings.push(`--pin for '${code}' has no effect (module not selected).`);
+    }
+  }
+  for (const code of channelOptions?.nextSet || []) {
+    if (!selected.has(code)) {
+      warnings.push(`--next for '${code}' has no effect (module not selected).`);
+    }
+  }
+  return warnings;
+}
+
+/**
+ * Warn when --pin / --next targets a bundled module (core, xmc). Those are
+ * shipped inside the installer binary — there's no git clone to override, so
+ * the flag has no effect. Users who actually want a prerelease core/xmc
+ * should use `npx @zeyue0329/xiaoma-cli@next install`.
+ */
+function bundledTargetWarnings(channelOptions, bundledCodes) {
+  const warnings = [];
+  const bundled = new Set(bundledCodes || []);
+  const hint = '(bundled module; use `npx @zeyue0329/xiaoma-cli@next install` for a prerelease)';
+  for (const code of channelOptions?.pins?.keys() || []) {
+    if (bundled.has(code)) {
+      warnings.push(`--pin for '${code}' has no effect ${hint}.`);
+    }
+  }
+  for (const code of channelOptions?.nextSet || []) {
+    if (bundled.has(code)) {
+      warnings.push(`--next for '${code}' has no effect ${hint}.`);
+    }
+  }
+  return warnings;
+}
+
+module.exports = {
+  parseChannelOptions,
+  decideChannelForModule,
+  buildPlan,
+  orphanPinWarnings,
+  bundledTargetWarnings,
+  parsePinSpec,
+};