@ichintansoni/skills-master 0.1.7 → 0.1.8

package/README.md

@@ -14,10 +14,13 @@ npx @ichintansoni/skills-master list --class code            # browse the catalo
 npx @ichintansoni/skills-master search navigation
 npx @ichintansoni/skills-master update                        # pull newer skill versions
 npx @ichintansoni/skills-master remove swiftui-sheets
+npx @ichintansoni/skills-master sync                          # re-emit to match the current config
 npx @ichintansoni/skills-master status                        # what's installed, and has it drifted?
 npx @ichintansoni/skills-master doctor                        # same detection, but fails on drift
 ```
 
+`update` pulls newer skill content, but only ever re-emits to the targets a skill was *already* installed to. So adding a target to `skills-master.json` after the fact, or changing a `paths` override, leaves config and disk disagreeing with nothing to reconcile them. `sync` is that reconciliation — it treats the configured target set as the source of truth and makes disk match. Local edits are preserved unless you pass `--overwrite`. A target you *dropped* from config is reported but only deleted with `--prune`; a `paths` change is a move, so the old copy is cleaned up straight away rather than left for agents to load twice.
+
 `status` and `doctor` share their drift detection but answer different questions. `status` is an inventory — it lists every installed skill with its version, targets, and whether the output has been edited or deleted, works entirely offline, and always exits 0, so it is safe to pipe (`status --json`, `status --problems`, `status <name>…`). `doctor` is the gate: same findings, but it exits non-zero, which is what you want in CI.
 
 `add` writes, per detected tool:

package/dist/bin.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // package.json
-var version = "0.1.7";
+var version = "0.1.8";
 
 // src/schema/projectConfig.ts
 import { z } from "zod";
@@ -1037,13 +1037,31 @@ function ensureGitignored(root, entries) {
   writeFileSync3(p, next, "utf8");
 }
 
+// src/util/targets.ts
+var VALID = new Set(ALL_TARGETS);
+function resolveTargets(cwd, configured, explicit) {
+  if (explicit?.length) return explicit;
+  if (configured.length) return configured;
+  const detected = detectTargets(cwd);
+  return detected.length ? detected : ALL_TARGETS;
+}
+function parseTargets(value) {
+  if (!value) return void 0;
+  if (value === "all") return ALL_TARGETS;
+  const ids = value.split(",").map((s) => s.trim()).filter(Boolean);
+  for (const id of ids) {
+    if (!VALID.has(id)) {
+      throw new Error(`Unknown target "${id}". Valid: ${[...VALID, "all"].join(", ")}.`);
+    }
+  }
+  return ids;
+}
+
 // src/commands/add.ts
 async function addCommand(opts) {
   const cfg = loadConfigOrDefault(opts.cwd);
   const hadConfig = loadConfig(opts.cwd) != null;
-  let targets = opts.targets?.length ? opts.targets : cfg.targets;
-  if (!targets.length) targets = detectTargets(opts.cwd);
-  if (!targets.length) targets = ALL_TARGETS;
+  const targets = resolveTargets(opts.cwd, cfg.targets, opts.targets);
   const content = await resolveContent({
     content: opts.content,
     ref: opts.ref ?? cfg.contentRef,
@@ -1378,6 +1396,147 @@ function statusCommand(opts) {
   return report;
 }
 
+// src/commands/sync.ts
+async function syncCommand(opts) {
+  const cfg = loadConfigOrDefault(opts.cwd);
+  const lock = loadLockfile(opts.cwd);
+  const targets = resolveTargets(opts.cwd, cfg.targets);
+  const paths = resolvePaths(cfg);
+  const prefix = opts.dryRun ? "[dry-run] " : "";
+  const all = Object.keys(lock.skills).sort();
+  const names = opts.names?.length ? all.filter((n) => opts.names.includes(n)) : all;
+  const result = {
+    synced: [],
+    skipped: [],
+    addedTargets: [],
+    orphaned: [],
+    stale: [],
+    pruned: false
+  };
+  if (all.length === 0) {
+    log.info("No skills installed \u2014 run `skills-master add <name>`.");
+    return result;
+  }
+  if (names.length === 0) {
+    log.warn("No installed skills match.");
+    return result;
+  }
+  const edited = new Map(
+    diagnoseInstalled(opts.cwd, lock).map((d) => [d.name, d.targets.some((t) => t.edited)])
+  );
+  const content = await resolveContent({
+    content: opts.content,
+    ref: opts.ref ?? cfg.contentRef,
+    cwd: opts.cwd
+  });
+  log.info(`Syncing ${names.length} skill(s) to targets: ${targets.join(", ")}`);
+  const addedTargets = /* @__PURE__ */ new Set();
+  const pruneNames = [];
+  const pruneTargets = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const locked = lock.skills[name];
+    const installedTo = Object.keys(locked.emitted);
+    const orphans = installedTo.filter((t) => !targets.includes(t));
+    if (orphans.length) {
+      result.orphaned.push({ name, targets: orphans });
+      pruneNames.push(name);
+      for (const t of orphans) pruneTargets.add(t);
+    }
+    if (edited.get(name) && !opts.overwrite) {
+      log.warn(`${prefix}"${name}" has local edits \u2014 skipping (use --overwrite to replace).`);
+      result.skipped.push(name);
+      continue;
+    }
+    let skill;
+    try {
+      skill = content.loadSkill(name);
+    } catch (err) {
+      if (err instanceof SkillNotFoundError) {
+        log.warn(`"${name}" no longer exists in the content library \u2014 leaving it in place.`);
+      } else {
+        log.error(`Failed to load "${name}": ${err instanceof Error ? err.message : String(err)}`);
+      }
+      result.skipped.push(name);
+      continue;
+    }
+    for (const t of targets) if (!locked.emitted[t]) addedTargets.add(t);
+    const prevFiles = /* @__PURE__ */ new Set();
+    const prevBlocks = /* @__PURE__ */ new Map();
+    for (const t of targets) {
+      const e = locked.emitted[t];
+      if (!e) continue;
+      for (const f of e.files) prevFiles.add(f);
+      if (e.block) prevBlocks.set(t, e.block);
+    }
+    const emitted = installSkill(opts.cwd, skill, targets, paths, {
+      dryRun: opts.dryRun,
+      overwrite: true
+      // edits were already checked above
+    });
+    const nowFiles = /* @__PURE__ */ new Set();
+    for (const e of Object.values(emitted.locked.emitted)) {
+      for (const f of e.files) nowFiles.add(f);
+    }
+    const staleFiles = [...prevFiles].filter((f) => !nowFiles.has(f));
+    const staleBlocks = [...prevBlocks].filter(([t, b]) => emitted.locked.emitted[t]?.block !== b).map(([, b]) => b);
+    if (staleFiles.length || staleBlocks.length) {
+      result.stale.push({ name, files: staleFiles, blocks: staleBlocks });
+    }
+    if (!opts.dryRun) {
+      lock.skills[name] = {
+        ...emitted.locked,
+        emitted: { ...locked.emitted, ...emitted.locked.emitted }
+      };
+    }
+    result.synced.push(name);
+    for (const r of emitted.results) {
+      if (r.action === "unchanged") continue;
+      const tag = r.mode === "block" ? `${r.path} [${r.blockId}]` : r.path;
+      log.info(`${prefix}${r.action.padEnd(9)} ${tag}`);
+    }
+  }
+  result.addedTargets = [...addedTargets].sort();
+  if (!opts.dryRun) saveLockfile(opts.cwd, lock);
+  if (result.orphaned.length) {
+    const list = [...pruneTargets].sort().join(", ");
+    if (opts.prune) {
+      removeCommand({
+        cwd: opts.cwd,
+        names: pruneNames,
+        targets: [...pruneTargets],
+        dryRun: opts.dryRun
+      });
+      result.pruned = true;
+    } else {
+      log.warn(
+        `${result.orphaned.length} skill(s) still have output for target(s) the config no longer lists: ${list}. Re-run with --prune to remove.`
+      );
+    }
+  }
+  if (result.stale.length) {
+    const gone = [];
+    for (const f of result.stale.flatMap((s) => s.files)) {
+      if (removeWholeFile(opts.cwd, f, opts.dryRun)) {
+        gone.push(f);
+        log.info(`${prefix}moved-from ${f}`);
+      }
+    }
+    pruneEmptyDirs(opts.cwd, gone, opts.dryRun);
+    for (const s of result.stale) {
+      for (const b of s.blocks) {
+        if (removeBlockFromFile(opts.cwd, b, s.name, opts.dryRun)) {
+          log.info(`${prefix}unblocked  ${b} [${s.name}]`);
+        }
+      }
+    }
+  }
+  const bits = [`${result.synced.length} synced`];
+  if (result.addedTargets.length) bits.push(`new target(s): ${result.addedTargets.join(", ")}`);
+  if (result.skipped.length) bits.push(`${result.skipped.length} skipped`);
+  log.success(`${prefix}${bits.join(", ")}.`);
+  return result;
+}
+
 // src/core/search-text.ts
 function searchNormalize(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
@@ -1922,20 +2081,6 @@ async function newSkillCommand(opts) {
   return skillMd;
 }
 
-// src/util/targets.ts
-var VALID = new Set(ALL_TARGETS);
-function parseTargets(value) {
-  if (!value) return void 0;
-  if (value === "all") return ALL_TARGETS;
-  const ids = value.split(",").map((s) => s.trim()).filter(Boolean);
-  for (const id of ids) {
-    if (!VALID.has(id)) {
-      throw new Error(`Unknown target "${id}". Valid: ${[...VALID, "all"].join(", ")}.`);
-    }
-  }
-  return ids;
-}
-
 // src/bin.ts
 async function run(fn, exitOnFalse = false) {
   try {
@@ -2023,6 +2168,19 @@ program.command("remove <names...>").description("Remove installed skills").opti
     })
   )
 );
+program.command("sync").description("Re-emit installed skills to match the current config (new targets, moved paths)").argument("[names...]", "limit the sync to these installed skills").option("--content <dir>", "local skills directory").option("--ref <git-ref>", "content ref to read from").option("--overwrite", "replace locally edited outputs").option("--prune", "delete outputs for targets the config no longer lists").option("--dry-run", "show what would change without writing").action(
+  (names, opts) => run(
+    () => syncCommand({
+      cwd: process.cwd(),
+      names,
+      content: opts.content,
+      ref: opts.ref,
+      overwrite: opts.overwrite,
+      prune: opts.prune,
+      dryRun: opts.dryRun
+    })
+  )
+);
 program.command("status").description("Show installed skills: versions, targets, and local-edit state").argument("[names...]", "limit the report to these skills").option("--problems", "show only skills that are edited or missing files").option("--json", "machine-readable output").action(
   (names, opts) => run(
     () => statusCommand({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ichintansoni/skills-master",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Install tool-agnostic Apple & Android development skills into any AI coding tool (Claude Code, Cursor, Copilot, AGENTS.md).",
   "keywords": [
     "skills",