@open-rlb/ng-bootstrap 3.3.45 → 3.3.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-rlb/ng-bootstrap",
-  "version": "3.3.45",
+  "version": "3.3.46",
   "peerDependencies": {
     "@angular/cdk": ">=21.0.0 <22.0.0",
     "@angular/common": ">=21.0.0 <22.0.0",

package/schematics/collection.json

@@ -5,6 +5,11 @@
       "description": "Add @open-rlb/ng-bootstrap to an Angular project: install peer dependencies, register Bootstrap styles, wire up provideRlbBootstrap(), and scaffold a starter component.",
       "factory": "./ng-add/index#ngAdd",
       "schema": "./ng-add/schema.json"
+    },
+    "sync-skills": {
+      "description": "Copy the Claude skills bundled with the installed version of @open-rlb/ng-bootstrap into .claude/skills. Re-runnable: this is how consumers pick up skill updates after npm update.",
+      "factory": "./sync-skills/index#syncSkills",
+      "schema": "./sync-skills/schema.json"
     }
   }
 }

package/schematics/ng-add/index.js

@@ -16,6 +16,8 @@ const DEPENDENCIES = [
     { name: 'bootstrap-icons', version: '^1.11.0', type: utility_1.DependencyType.Default },
     { name: '@types/bootstrap', version: '^5.2.0', type: utility_1.DependencyType.Dev },
 ];
+/** Keeps `.claude/skills` in step with the installed library version on every `npm install`. */
+const SYNC_SKILLS_COMMAND = 'ng g @open-rlb/ng-bootstrap:sync-skills';
 /** Global styles required for the Bootstrap look & feel. */
 const STYLE_PATHS = [
     'node_modules/bootstrap/dist/css/bootstrap.min.css',
@@ -34,8 +36,10 @@ function ngAdd(options) {
             // 4. Optionally scaffold a starter component.
             options.skipStarter ? noop : scaffoldStarter(tree, project),
             // 5. Optionally copy the bundled Claude skills into .claude/skills.
-            options.skipSkills ? noop : copyClaudeSkills(),
-            // 6. Print next steps.
+            options.skipSkills ? noop : (0, schematics_1.schematic)('sync-skills', {}),
+            // 6. Optionally keep them in sync on every future `npm install`.
+            options.skipSkills || options.skipSkillsAutoSync ? noop : addSkillsPostinstall(),
+            // 7. Print next steps.
             logNextSteps(project, options),
         ]);
     };
@@ -91,13 +95,34 @@ function scaffoldStarter(tree, project) {
     };
 }
 /**
- * Copies the Claude skills bundled with the package into the consumer's
- * `.claude/skills` folder. Library-authored skills are authoritative, so existing
- * copies are overwritten to stay in sync with the installed version.
+ * Adds a `postinstall` script that re-runs the sync-skills schematic, so `npm update` alone
+ * refreshes `.claude/skills` to match the newly installed library version.
+ *
+ * The script deliberately lives in the consumer's package.json rather than the library's: a
+ * library-side install script is silently skipped under `--ignore-scripts`, has to guess the
+ * app root via INIT_CWD, and would fire in unrelated repos on transitive installs.
  */
-function copyClaudeSkills() {
-    const skills = (0, schematics_1.apply)((0, schematics_1.url)('./claude-skills'), [(0, schematics_1.move)('.claude/skills')]);
-    return (0, schematics_1.mergeWith)(skills, schematics_1.MergeStrategy.Overwrite);
+function addSkillsPostinstall() {
+    return (tree, context) => {
+        const raw = tree.read('/package.json');
+        if (!raw) {
+            return tree;
+        }
+        const pkg = JSON.parse(raw.toString('utf-8'));
+        const existing = pkg.scripts?.['postinstall'];
+        if (existing?.includes(SYNC_SKILLS_COMMAND)) {
+            return tree;
+        }
+        // Never rewrite a postinstall the consumer already relies on — tell them what to append.
+        if (existing) {
+            context.logger.warn(`⚠ A "postinstall" script already exists. To keep the Claude skills up to date, append:\n` +
+                `    && ${SYNC_SKILLS_COMMAND}`);
+            return tree;
+        }
+        pkg.scripts = { ...pkg.scripts, postinstall: SYNC_SKILLS_COMMAND };
+        tree.overwrite('/package.json', JSON.stringify(pkg, null, 2) + '\n');
+        return tree;
+    };
 }
 function logNextSteps(project, options) {
     return (_tree, context) => {
@@ -113,6 +138,11 @@ function logNextSteps(project, options) {
         }
         if (!options.skipSkills) {
             log.info('   • Claude skills copied to .claude/skills/ (date-tz, rlb-* component guides)');
+            if (!options.skipSkillsAutoSync) {
+                log.info(`   • "postinstall": "${SYNC_SKILLS_COMMAND}" added to package.json`);
+                log.info('     Skills refresh on every `npm install`. Note `npm update <pkg>` skips');
+                log.info('     root lifecycle scripts — follow it with a bare `npm install`.');
+            }
         }
         log.info('');
     };

package/schematics/ng-add/schema.json

@@ -20,6 +20,11 @@
       "type": "boolean",
       "default": false,
       "description": "Do not copy the bundled Claude skills into .claude/skills."
+    },
+    "skipSkillsAutoSync": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add a postinstall script that refreshes .claude/skills on future installs."
     }
   },
   "required": []

package/schematics/sync-skills/index.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncSkills = syncSkills;
+const schematics_1 = require("@angular-devkit/schematics");
+const rxjs_1 = require("rxjs");
+/** Where the consumer's Claude skills live. */
+const SKILLS_ROOT = '/.claude/skills';
+/**
+ * Records which skill folders this library owns, so a later sync can delete the ones it no
+ * longer ships without touching skills the consumer wrote themselves.
+ */
+const MANIFEST_PATH = `${SKILLS_ROOT}/.rlb-skills.json`;
+/** Set this in CI if a pipeline asserts a clean working tree after `npm install`. */
+const SKIP_ENV_VAR = 'RLB_SKIP_SKILL_SYNC';
+const PACKAGE_NAME = '@open-rlb/ng-bootstrap';
+/**
+ * Copies the Claude skills bundled with the *installed* version of the library into the
+ * consumer's `.claude/skills`. Safe to re-run: it is how consumers pick up skill changes after
+ * `npm update`, typically from their own `postinstall` script.
+ */
+function syncSkills(options) {
+    return async (tree, context) => {
+        if (process.env[SKIP_ENV_VAR]) {
+            context.logger.info(`• ${SKIP_ENV_VAR} is set — skipping Claude skill sync.`);
+            return noop;
+        }
+        const bundled = await readBundledSkills(context);
+        if (bundled.skills.length === 0) {
+            context.logger.warn(`⚠ ${PACKAGE_NAME} shipped without Claude skills — nothing to sync. ` +
+                'This usually means the package was built with a bare `ng build` instead of `npm run lib:build`.');
+            return noop;
+        }
+        const previous = readManifest(tree);
+        // Only folders a previous sync claimed are ours to delete. Anything else in .claude/skills
+        // was authored in the consumer and must survive.
+        const stale = options.prune === false
+            ? []
+            : (previous?.skills ?? []).filter(name => !bundled.skills.includes(name));
+        const added = bundled.files.filter(file => !tree.exists(join(SKILLS_ROOT, file.path)));
+        const updated = bundled.files.filter(file => {
+            const target = join(SKILLS_ROOT, file.path);
+            const current = tree.read(target);
+            return current !== null && !current.equals(file.content);
+        });
+        return (0, schematics_1.chain)([
+            prune(stale),
+            (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)('./claude-skills'), [(0, schematics_1.move)(SKILLS_ROOT)]), schematics_1.MergeStrategy.Overwrite),
+            writeManifest(bundled.skills),
+            logSummary({ skills: bundled.skills, added: added.length, updated: updated.length, stale }),
+        ]);
+    };
+}
+/** Reads the skills packaged alongside this schematic (see scripts/build-schematics.mjs). */
+async function readBundledSkills(context) {
+    const source = (0, schematics_1.url)('./claude-skills')(context);
+    const bundledTree = (0, rxjs_1.isObservable)(source) ? await (0, rxjs_1.firstValueFrom)(source) : source;
+    const skills = new Set();
+    const files = [];
+    bundledTree.visit((path, entry) => {
+        const folder = path.replace(/^\//, '').split('/')[0];
+        if (folder) {
+            skills.add(folder);
+        }
+        if (entry) {
+            files.push({ path, content: entry.content });
+        }
+    });
+    return { skills: [...skills].sort(), files };
+}
+function readManifest(tree) {
+    const raw = tree.read(MANIFEST_PATH);
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw.toString('utf-8'));
+        return Array.isArray(parsed.skills)
+            ? { package: PACKAGE_NAME, version: '', ...parsed, skills: parsed.skills }
+            : null;
+    }
+    catch {
+        // A hand-mangled manifest must not abort the sync — treat it as "nothing owned yet".
+        return null;
+    }
+}
+/** Deletes every file under the named skill folders. */
+function prune(stale) {
+    return (tree) => {
+        for (const name of stale) {
+            const dir = tree.getDir(join(SKILLS_ROOT, name));
+            const paths = [];
+            dir.visit(path => paths.push(path));
+            paths.forEach(path => tree.delete(path));
+        }
+        return tree;
+    };
+}
+function writeManifest(skills) {
+    return (tree) => {
+        const manifest = { package: PACKAGE_NAME, version: installedVersion(), skills };
+        const content = JSON.stringify(manifest, null, 2) + '\n';
+        if (tree.exists(MANIFEST_PATH)) {
+            tree.overwrite(MANIFEST_PATH, content);
+        }
+        else {
+            tree.create(MANIFEST_PATH, content);
+        }
+        return tree;
+    };
+}
+/**
+ * The version of the library these skills came from. Resolved from the package.json two levels
+ * up from the compiled `schematics/sync-skills/index.js`, i.e. the installed package's own.
+ */
+function installedVersion() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('../../package.json').version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function logSummary(summary) {
+    return (_tree, context) => {
+        const log = context.logger;
+        log.info('');
+        log.info(`✅ Claude skills synced from ${PACKAGE_NAME}@${installedVersion()}`);
+        log.info(`   • ${summary.skills.length} skills: ${summary.skills.join(', ')}`);
+        log.info(`   • ${summary.added} new file(s), ${summary.updated} updated`);
+        if (summary.stale.length) {
+            log.info(`   • pruned (no longer shipped): ${summary.stale.join(', ')}`);
+        }
+        log.info('');
+    };
+}
+function join(base, path) {
+    return `${base}/${path}`.replace(/\/+/g, '/');
+}
+/** A no-op rule. */
+const noop = tree => tree;

package/schematics/sync-skills/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/schematics/sync-skills/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "OpenRlbNgBootstrapSyncSkills",
+  "title": "@open-rlb/ng-bootstrap sync-skills schematic",
+  "type": "object",
+  "properties": {
+    "prune": {
+      "type": "boolean",
+      "default": true,
+      "description": "Delete skills the library previously shipped but no longer does. Skills authored in the consumer are never touched."
+    }
+  },
+  "required": []
+}