baldart 5.6.0 → 5.8.0

package/src/utils/symlinks.js

@@ -210,7 +210,7 @@ class SymlinkUtils {
    */
   mergeSkills(opts = {}) {
     const tools = (opts.tools && opts.tools.length) ? opts.tools : ['claude'];
-    const aggregate = { linked: [], skipped: [], conflicts: [] };
+    const aggregate = { linked: [], skipped: [], conflicts: [], pruned: [], gatedOff: [] };
 
     const frameworkSkillsDir = path.join(this.cwd, FRAMEWORK_PAYLOAD, '.claude', 'skills');
     if (!fs.existsSync(frameworkSkillsDir)) {
@@ -218,17 +218,31 @@ class SymlinkUtils {
       return aggregate;
     }
 
-    const frameworkSkills = fs.readdirSync(frameworkSkillsDir).filter(name => {
-      if (name.startsWith('.')) return false;
-      const full = path.join(frameworkSkillsDir, name);
-      return fs.lstatSync(full).isDirectory();
-    });
+    // Feature-gate: link only the skills whose `requires_feature` frontmatter is
+    // satisfied by this consumer's `features.*` (fail-open when config is
+    // unavailable → link everything). Resolved ONCE and applied to EVERY tool
+    // from this single code path — the gate is shared semantics, so Claude and
+    // Codex stay identical by construction. See src/utils/skill-gate.js.
+    const gate = require('./skill-gate').resolveSkillGate(frameworkSkillsDir, this.cwd);
+    const frameworkSkills = gate.toLink;
+    aggregate.gatedOff = gate.gatedOff.slice();
+    if (gate.gatedOff.length) {
+      UI.info(`Feature-gate: ${gate.gatedOff.length} skill(s) skipped (gating feature off): ${gate.gatedOff.join(', ')}`);
+    }
 
     for (const tool of tools) {
       const result = this._mergeSkillsForTool(tool, frameworkSkills, frameworkSkillsDir);
       aggregate.linked.push(...result.linked);
       aggregate.skipped.push(...result.skipped);
       aggregate.conflicts.push(...result.conflicts);
+
+      // Prune direction: remove any pre-existing framework symlink for a skill
+      // that is now gated-off (e.g. a feature flipped false after a prior
+      // install, or a fail-open install that linked everything before config
+      // existed). Only OUR framework symlinks are removed — never a real user
+      // skill dir, never a user-override symlink pointing elsewhere.
+      const pruneResult = this._pruneGatedSkillsForTool(tool, gate.gatedOff, frameworkSkillsDir);
+      aggregate.pruned.push(...pruneResult.pruned);
     }
 
     if (aggregate.conflicts.length > 0) {
@@ -329,6 +343,54 @@ class SymlinkUtils {
     return result;
   }
 
+  /**
+   * Prune framework skill symlinks that are now gated-off — internal.
+   *
+   * This is the reconcile (removal) direction of the feature-gate: turning a
+   * `features.*` flag off (or a fail-open first install that linked everything
+   * before config existed) must actually REMOVE the stale symlinks, or the
+   * skill-description budget never shrinks. Each `name` in `gatedOff` is a
+   * framework skill name by construction (it came from the framework catalog),
+   * so basename∈catalog is guaranteed; we still verify the link RESOLVES to our
+   * framework source for that exact skill before unlinking. Safety invariants:
+   *   - never touch a real directory (a user-authored skill of the same name);
+   *   - never touch a symlink pointing ANYWHERE ELSE (a user override, cf. the
+   *     `user-symlink-override` branch in _mergeSkillsForTool).
+   */
+  _pruneGatedSkillsForTool(toolName, gatedOff, frameworkSkillsDir) {
+    const { getAdapter } = require('./tool-adapters');
+    const adapter = getAdapter(toolName, this.cwd);
+    const result = { pruned: [] };
+    if (!gatedOff || !gatedOff.length) return result;
+
+    const skillsRel = adapter.skillsDir();
+    const userSkillsDir = path.join(this.cwd, skillsRel);
+    if (!fs.existsSync(userSkillsDir)) return result;
+
+    for (const name of gatedOff) {
+      const linkPath = path.join(userSkillsDir, name);
+      let lstat = null;
+      try { lstat = fs.lstatSync(linkPath); } catch (_) { continue; /* absent */ }
+
+      // Only ever remove a symlink — a real dir here is a user-authored skill.
+      if (!lstat.isSymbolicLink()) continue;
+
+      const current = fs.readlinkSync(linkPath);
+      const resolved = path.resolve(path.dirname(linkPath), current);
+      const frameworkTarget = path.join(frameworkSkillsDir, name);
+
+      // Unlink ONLY when it resolves to OUR framework source for this skill.
+      // A symlink pointing elsewhere is a deliberate user override → leave it.
+      if (resolved === frameworkTarget) {
+        fs.unlinkSync(linkPath);
+        UI.info(`[${adapter.label}] Skill unlinked (feature gated off): ${path.join(skillsRel, name)}`);
+        result.pruned.push({ tool: toolName, name });
+      }
+    }
+
+    return result;
+  }
+
   // -----------------------------------------------------------------------
   // Public composite operations
   // -----------------------------------------------------------------------
@@ -827,7 +889,10 @@ class SymlinkUtils {
           UI.warning(`[${adapter.label}] Legacy bulk skills symlink at ${skillsRel}. Run \`npx baldart update\` to convert to per-item.`);
           allValid = false;
         } else {
-          const sample = ['skill-creator', 'frontend-design', 'bug', 'prd', 'capture'];
+          // Sample ONLY always-linked skills — never feature-gated ones (e.g.
+          // prd/capture), which are legitimately absent when their feature is
+          // off and would make this probe brittle / falsely alarming.
+          const sample = ['skill-creator', 'bug', 'simplify', 'overlay', 'find-skills'];
           let frameworkLinks = 0;
           sample.forEach(name => {
             const p = path.join(skillsDir, name);