release-skill 0.5.0 → 0.6.0

package/src/adapters/plugin-marketplace.mjs

@@ -2179,10 +2179,34 @@ export function createPluginMarketplaceAdapter(deps = {}) {
             // pluginRootForEntrySkill 在非 external 结构化 CLI 路径中已确定；
             // external 路径或 human-attestation（null）时回退到 snapshotDirReal。
             const pluginRootForSkill = pluginRootForEntrySkill || snapshotDirReal;
-            const entrySkillFile = resolve(pluginRootForSkill, 'skills', action.entrySkill, 'SKILL.md');
+            // Prefixed skill-directory fallback (0.5.1 entry-skill-prefix fix,
+            // D-ACA-30 platform_physical_name): some candidate builds name
+            // skill directories `skills/<plugin>-<entrySkill>/` instead of
+            // the unprefixed `skills/<entrySkill>/`. Resolve the unprefixed
+            // layout first; when it misses, retry with the plugin prefix.
+            let entrySkillFile = resolve(pluginRootForSkill, 'skills', action.entrySkill, 'SKILL.md');
+            let entrySkillExists = false;
             try {
               await stat(entrySkillFile);
+              entrySkillExists = true;
             } catch {
+              if (action.plugin) {
+                const prefixed = resolve(
+                  pluginRootForSkill,
+                  'skills',
+                  `${action.plugin}-${action.entrySkill}`,
+                  'SKILL.md',
+                );
+                try {
+                  await stat(prefixed);
+                  entrySkillFile = prefixed;
+                  entrySkillExists = true;
+                } catch {
+                  // both layouts miss; report below
+                }
+              }
+            }
+            if (!entrySkillExists) {
               const skillRel = relative(snapshotDirReal, entrySkillFile) || `skills/${action.entrySkill}/SKILL.md`;
               return createResult({
                 actionType,
@@ -3476,8 +3500,11 @@ export function createPluginMarketplaceAdapter(deps = {}) {
             });
           }
 
-          // Verify entry skill exists as a regular file in install dir
-          const entrySkillPath = resolve(installPath, 'skills', action.entrySkill, 'SKILL.md');
+          // Verify entry skill exists as a regular file in install dir.
+          // Prefixed skill-directory fallback (0.5.1 entry-skill-prefix fix):
+          // mirror the preflight resolution — `skills/<entrySkill>` first,
+          // then `skills/<plugin>-<entrySkill>` when the plugin is known.
+          let entrySkillPath = resolve(installPath, 'skills', action.entrySkill, 'SKILL.md');
           let entrySkillFound = false;
           try {
             const skillStat = await lstat(entrySkillPath);
@@ -3485,7 +3512,24 @@ export function createPluginMarketplaceAdapter(deps = {}) {
               entrySkillFound = true;
             }
           } catch {
-            // entry skill not found
+            // entry skill not found in unprefixed layout
+          }
+          if (!entrySkillFound && action.plugin) {
+            const prefixedPath = resolve(
+              installPath,
+              'skills',
+              `${action.plugin}-${action.entrySkill}`,
+              'SKILL.md',
+            );
+            try {
+              const skillStat = await lstat(prefixedPath);
+              if (skillStat.isFile() && !skillStat.isSymbolicLink()) {
+                entrySkillPath = prefixedPath;
+                entrySkillFound = true;
+              }
+            } catch {
+              // both layouts miss; report below
+            }
           }
 
           if (!entrySkillFound) {

package/src/adapters/push-snapshot.mjs

@@ -58,10 +58,16 @@ function validateAction(action) {
   githubRepositoryUrl(action.repo, action.githubHost);
 
   const validStrategies = ['create-release-branch', 'advance-existing-branch', 'initialize-default-branch'];
-  const strategy = action.branchStrategy ?? 'create-release-branch';
-  if (typeof strategy !== 'string' || !validStrategies.includes(strategy)) {
+  // Explicit strategy is required (0.5.1 chain hardening): the historical
+  // `?? 'create-release-branch'` default silently produced orphan root
+  // commits whenever a plan omitted the strategy — the root cause of the
+  // synthetic-date root commits in the public repositories. The plan layer
+  // now guarantees the value; a missing value here fails closed instead of
+  // degrading to the orphan-root channel.
+  if (typeof action.branchStrategy !== 'string' || !validStrategies.includes(action.branchStrategy)) {
     throw new Error(`branchStrategy must be one of: ${validStrategies.join(', ')}`);
   }
+  const strategy = action.branchStrategy;
   if (strategy === 'advance-existing-branch' || strategy === 'initialize-default-branch') {
     if (!action.parentCommit || typeof action.parentCommit !== 'string') {
       throw new Error(`${strategy} requires parentCommit`);
@@ -126,7 +132,8 @@ export function createPushSnapshotAdapter(deps = {}) {
           { shell: false },
         );
         const remoteTip = stdout.trim().split(/\s+/)[0] ?? '';
-        const strategy = action.branchStrategy ?? 'create-release-branch';
+        // Guaranteed by validateAction above (branchStrategy is required).
+        const strategy = action.branchStrategy;
 
         if (strategy === 'advance-existing-branch') {
           if (!remoteTip) {
@@ -173,7 +180,8 @@ export function createPushSnapshotAdapter(deps = {}) {
         });
         const gitDir = await inspectLocalObjects(action, context, exec);
         const remoteUrl = githubRepositoryUrl(action.repo, action.githubHost);
-        const strategy = action.branchStrategy ?? 'create-release-branch';
+        // Guaranteed by validateAction above (branchStrategy is required).
+        const strategy = action.branchStrategy;
 
         if (strategy === 'advance-existing-branch') {
           await exec(

package/src/commands/assess.mjs

@@ -709,6 +709,171 @@ async function checkRemotePrerequisites(root, config, offline) {
   return gaps;
 }
 
+/**
+ * Parse a semver-ish version string into comparable components.
+ *
+ * Accepts `major.minor.patch` with an optional `-prerelease` suffix (which
+ * sorts strictly below the same release triple). Returns null for anything
+ * that is not a version-shaped tag (candidate names like `0.1.27-candidate.2`
+ * parse fine; non-version tags are skipped).
+ *
+ * @param {string} version
+ * @returns {{ major: number, minor: number, patch: number, prerelease: string|null } | null}
+ */
+export function parseSemverVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(version);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ?? null,
+  };
+}
+
+/**
+ * Compare two parsed semver values. Returns a negative/zero/positive number.
+ *
+ * @param {{ major: number, minor: number, patch: number, prerelease: string|null }} a
+ * @param {{ major: number, minor: number, patch: number, prerelease: string|null }} b
+ * @returns {number}
+ */
+export function compareSemverVersions(a, b) {
+  if (a.major !== b.major) return a.major - b.major;
+  if (a.minor !== b.minor) return a.minor - b.minor;
+  if (a.patch !== b.patch) return a.patch - b.patch;
+  if (a.prerelease && !b.prerelease) return -1;
+  if (!a.prerelease && b.prerelease) return 1;
+  return 0;
+}
+
+/**
+ * Describe a version-sequence gap between an immediate predecessor and the
+ * target version, or null when the step is contiguous.
+ *
+ * A gap means some version between the two was never released (e.g. the
+ * historical 0.1.1 -> 0.1.3 jump with no v0.1.2 tag). Pre-release steps
+ * never count as gaps by themselves.
+ *
+ * @param {{ major: number, minor: number, patch: number, prerelease: string|null }} prev
+ * @param {{ major: number, minor: number, patch: number, prerelease: string|null }} target
+ * @returns {string|null}
+ */
+export function describeVersionSequenceGap(prev, target) {
+  if (prev.major !== target.major) {
+    return prev.major + 1 < target.major
+      ? `major ${prev.major}.x.x -> ${target.major}.x.x`
+      : null;
+  }
+  if (prev.minor !== target.minor) {
+    return prev.minor + 1 < target.minor
+      ? `minor ${prev.major}.${prev.minor}.x -> ${target.major}.${target.minor}.x`
+      : null;
+  }
+  if (prev.patch !== target.patch) {
+    return prev.patch + 1 < target.patch
+      ? `patch ${prev.major}.${prev.minor}.${prev.patch} -> ${target.major}.${target.minor}.${target.patch}`
+      : null;
+  }
+  return null;
+}
+
+/**
+ * Build a regex that extracts the version from a tag name following the
+ * unit's tagTemplate (`{version}` placeholder, regex-special characters
+ * escaped).
+ *
+ * @param {string} tagTemplate
+ * @returns {RegExp}
+ */
+export function buildTagVersionRegex(tagTemplate) {
+  const escaped = tagTemplate
+    .split('{version}')
+    .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+    .join('(.+)');
+  return new RegExp(`^${escaped}$`);
+}
+
+/**
+ * Check the public repository's release tag sequence for version jumps
+ * (0.5.1 chain hardening): when the immediate predecessor release is more
+ * than one version step below the current target version, register a
+ * warning-level gap `VERSION_SEQUENCE_GAP` (e.g. 0.1.1 -> 0.1.3 with no
+ * v0.1.2 tag). This never blocks: it records the observation for the human
+ * release planner.
+ *
+ * @param {string} root - Project root.
+ * @param {Object} config - The loaded project config.
+ * @returns {Promise<Object[]>} Array of warning gap entries.
+ */
+async function checkReleaseTagSequence(root, config) {
+  const gaps = [];
+  for (const unit of config.releaseUnits ?? []) {
+    const tagTemplate = unit.version?.tagTemplate;
+    if (!tagTemplate || !unit.publicRepo) continue;
+
+    const versionRegex = buildTagVersionRegex(tagTemplate);
+    const tagPattern = tagTemplate.replace('{version}', '*');
+
+    let stdout;
+    try {
+      ({ stdout } = await execFile(
+        'git',
+        ['ls-remote', `https://github.com/${unit.publicRepo}.git`, `refs/tags/${tagPattern}`],
+        { cwd: root, shell: false, encoding: 'utf8', timeout: 15_000 },
+      ));
+    } catch {
+      // Tag enumeration failure (network/auth/repo absent) is not a version
+      // gap and must not block; the remote-prerequisites npm check already
+      // reports unreachable registries where relevant.
+      continue;
+    }
+
+    let targetVersion;
+    try {
+      const pkg = JSON.parse(await readFile(resolve(root, unit.source, 'package.json'), 'utf8'));
+      targetVersion = pkg.version;
+    } catch {
+      continue; // package metadata issues are reported elsewhere
+    }
+    const targetParsed = parseSemverVersion(targetVersion);
+    if (!targetParsed) continue;
+
+    let previousParsed = null;
+    let previousTag = null;
+    for (const line of stdout.trim().split('\n')) {
+      if (!line) continue;
+      const tagName = line.split('\t')[1]?.replace(/^refs\/tags\//, '');
+      if (!tagName) continue;
+      const versionMatch = versionRegex.exec(tagName);
+      if (!versionMatch) continue;
+      const parsed = parseSemverVersion(versionMatch[1]);
+      if (!parsed) continue;
+      // Prereleases never qualify as the "previous release" predecessor.
+      if (parsed.prerelease) continue;
+      if (compareSemverVersions(parsed, targetParsed) >= 0) continue;
+      if (previousParsed === null || compareSemverVersions(parsed, previousParsed) > 0) {
+        previousParsed = parsed;
+        previousTag = tagName;
+      }
+    }
+
+    if (!previousParsed) continue;
+    const gap = describeVersionSequenceGap(previousParsed, targetParsed);
+    if (gap) {
+      gaps.push(createGap({
+        scope: GapScope.PROJECT,
+        category: GapCategory.REMOTE,
+        severity: Severity.WARNING,
+        code: 'VERSION_SEQUENCE_GAP',
+        message: `发布单元 "${unit.id}" 的版本序列存在跳号（${gap}，上一发布标签 ${previousTag}，目标版本 ${targetVersion}）：请确认中间版本未发布是否是有意为之；发布链仍会以链式历史推进，但跳过的版本不会补造标签`,
+        file: '.release-skill/project.yaml',
+      }));
+    }
+  }
+  return gaps;
+}
+
 /**
  * Perform a basic README structural check.
  *
@@ -967,6 +1132,12 @@ export async function assessProject(options) {
   const remoteGaps = await checkRemotePrerequisites(root, config, offline);
   allGaps.push(...remoteGaps);
 
+  // --- 7b. Release tag sequence (online only; warning, never blocking) ---
+  if (!offline) {
+    const tagSequenceGaps = await checkReleaseTagSequence(root, config);
+    allGaps.push(...tagSequenceGaps);
+  }
+
   // --- 8. README structure check ---
   const readmeGaps = await checkReadmeStructure(root, config);
   allGaps.push(...readmeGaps);