hubskillz 0.4.0 → 1.0.0

package/README.md

@@ -4,9 +4,9 @@
 [![CI](https://github.com/JejeDurden2/hubskillz-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/JejeDurden2/hubskillz-cli/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/hubskillz)](https://github.com/JejeDurden2/hubskillz-cli/blob/main/LICENSE)
 
-Keep the Claude Code skills on your machine in sync with your organization's approved directory.
+See every Claude Code skill on your machine in one place, share it, and keep your directory current.
 
-`hubskillz` inventories `~/.claude/skills` and `<repo>/.claude/skills`, reports the state of every skill against the directory, and installs the approved versions after showing you the plan. Skills you customized are never overwritten unless you ask.
+`hubskillz` inventories `~/.claude/skills` and `<repo>/.claude/skills` and uploads that layout to your directory, the way a git push sends your files to GitHub. It never writes a local file: your repos are the source of truth, the directory is the picture of them.
 
 ## Install
 
@@ -25,7 +25,7 @@ hubskillz login        # paste a device token from Settings, Device tokens
 hubskillz doctor       # what is broken or duplicated on this machine
 hubskillz upgrade --all  # every skills.sh skill to its latest upstream
 hubskillz status       # what is installed, and how it compares
-hubskillz sync --all   # install the approved set, adopt what the directory lacks
+hubskillz sync --all   # upload every skill of this machine to your directory
 ```
 
 The bare `hubskillz` command prints this quickstart, with your progress, until the first sync completes.
@@ -36,7 +36,7 @@ The bare `hubskillz` command prints this quickstart, with your progress, until t
 hubskillz login    [--token TOKEN] [--base-url URL]
 hubskillz logout
 hubskillz status   [--path DIR] [--yes]
-hubskillz sync     [--path DIR] [--all] [--adopt] [--yes] [--dry-run] [--force]
+hubskillz sync     [--path DIR] [--all] [--yes]
 hubskillz upgrade  [SKILL...] [--path DIR] [--all] [--yes]
 hubskillz doctor   [--path DIR]
 hubskillz move     <skill> <global|DIR> [--from global|DIR] [--force]
@@ -66,14 +66,13 @@ What the inventory contains: for every skill, its name, content hash and per-fil
 
 ### sync
 
-Installs missing skills and updates drifted ones to the approved version. Shows the plan first and asks for confirmation. Skills you changed locally are left untouched unless you pass `--force`.
+Uploads the skills as they sit on disk and prints their state, like a git push: the directory mirrors the machine. `sync` never writes a local file. A skill the directory does not know yet is added to it automatically: an upstream skill is pinned at its installed hash, a private skill is created from its snapshot. In a team org that step is maintainer only, other roles get a notice and keep syncing.
 
-- `--path DIR`: project directory to act on. Default: the current directory.
-- `--all`: act on the global root, the project root and every registered project. With nothing registered yet, it first scans your home directory for repos with `.claude/skills` and asks which ones to register (see `projects discover`). Default: the project root when `DIR/.claude/skills` exists, else the global root.
-- `--adopt`: add every importable skill found on this surface to the directory as an approved version, without asking. Importable means installed here and absent from the directory: an upstream skill is pinned at its installed hash, a private skill is created from its snapshot. Maintainer only, other roles get a notice and keep syncing. Without the flag, an interactive run asks the same question once; `--yes` alone answers no and `--dry-run` skips it.
-- `--yes`, `-y`: apply without asking.
-- `--dry-run`: print the plan and stop.
-- `--force`: overwrite locally customized skills.
+- `--path DIR`: project directory to report. Default: the current directory.
+- `--all`: cover the global root, the project root and every registered project. With nothing registered yet, it first scans your home directory for repos with `.claude/skills` and asks which ones to register (see `projects discover`). Default: the project root when `DIR/.claude/skills` exists, else the global root.
+- `--yes`, `-y`: register every discovered project without asking.
+
+To change what a repo holds, edit it like any other file and `sync` again: `hubskillz move` carries a skill between roots, `hubskillz upgrade` updates skills.sh skills, deleting the folder removes the skill.
 
 ### upgrade
 
@@ -89,7 +88,7 @@ hubskillz fetches nothing here. It reads each skills.sh lock to know what is ins
 
 `upgrade` looks a named skill up in every root, so `hubskillz upgrade find-skills` works from anywhere. A name no lock lists is an error. `--yes` passes `-y` through to skills.sh.
 
-This is the one command that walks past your approved versions: it installs upstream head, whatever version your directory pinned. `hubskillz status` then reports those skills as drifted or customized, and `hubskillz sync` puts the pinned versions back.
+This command installs upstream head, whatever version your directory pinned. `hubskillz sync` afterwards reports the new versions to the directory, where you review and approve them.
 
 ### doctor
 
@@ -100,7 +99,7 @@ Reads every local skills root and reports what no agent loads, and what loads tw
 | `error` | A folder with no `SKILL.md`, an empty folder, a symlink whose target is gone. Nothing loads.                                                                                                          |
 | `warn`  | A `SKILL.md` without a `name` or a `description`, a copy that duplicates or shadows `~/.claude/skills`, the same skill sitting in several projects, a registered repo that lost its `.claude/skills`. |
 
-Every warning names the command that clears it: `hubskillz sync` for a redundant project copy, `hubskillz move <skill> global` for a skill repeated across projects, `hubskillz projects remove` for a dead registration.
+Every warning names what clears it: deleting a redundant project copy, `hubskillz move <skill> global` for a skill repeated across projects, `hubskillz projects remove` for a dead registration.
 
 ### move
 
@@ -142,9 +141,7 @@ Registers repos so `sync --all` and `status` cover them from anywhere, in one ru
 - Global root: `~/.claude/skills`
 - Project root: `<project>/.claude/skills`
 
-Claude Code loads the global root in every project on the machine. A skill installed there reports `inherited` on a project surface: keep the global root up to date and every project is covered, `sync` writes no copy into the repo. A project copy that matches a known version (unmodified or late) is a redundant shadow of the global one: `sync` removes it after showing the plan. `sync` never removes a customized copy.
-
-A symlinked skill directory (the skills.sh canonical copy under `~/.agents/skills`) is written through, so every agent on the machine sees the approved version. Links that leave your home directory are refused.
+Claude Code loads the global root in every project on the machine. A skill installed there reports `inherited` on a project surface: it is already inside the project, nothing needs a copy in the repo. A project copy that matches a known version is a redundant shadow of the global one; `doctor` points it out and you delete it when you want.
 
 ## CI and containers
 
@@ -154,13 +151,7 @@ Set `HUBSKILLZ_TOKEN` and no config file is needed:
 HUBSKILLZ_TOKEN=... npx hubskillz sync --all --yes
 ```
 
-Prompts are skipped when stdin is not a TTY: `sync` needs `--yes` to apply, `projects discover` registers everything found.
-
-Update every machine and every repo from the directory, without installing anything:
-
-```sh
-npx hubskillz sync --all --yes
-```
+Prompts are skipped when stdin is not a TTY: `projects discover` registers everything found.
 
 ## Configuration
 

package/dist/index.js

@@ -19143,19 +19143,6 @@ function parseSkillMd(source) {
     body: source.slice(match[0].length).replace(/^(\r?\n)+/, "")
   };
 }
-var QUOTED = /^(["'])([\s\S]*)\1$/;
-var RELEASE = /^v?\d[\w.+-]{0,23}$/;
-function declaredRelease(source) {
-  const entry = parseSkillMd(source).frontmatter.find(
-    (item) => item.key === "version"
-  );
-  const value = (entry?.value ?? "").replace(QUOTED, "$2").trim();
-  return RELEASE.test(value) ? value : null;
-}
-function releaseOf(files) {
-  const skillMd = files.find((file2) => file2.path === "SKILL.md");
-  return skillMd === void 0 ? null : declaredRelease(skillMd.content);
-}
 
 // src/commands/doctor.ts
 import { existsSync as existsSync2 } from "node:fs";
@@ -19606,7 +19593,7 @@ function duplicateFindings(surfaces) {
         level: "warn",
         skill: skill.name,
         where: whereOf(surface),
-        problem: twin.contentHash === skill.contentHash ? "same content as ~/.claude/skills, `npx hubskillz sync` clears it" : "differs from ~/.claude/skills and wins over it here"
+        problem: twin.contentHash === skill.contentHash ? "same content as ~/.claude/skills, safe to delete this copy" : "differs from ~/.claude/skills and wins over it here"
       });
     }
   }
@@ -19858,16 +19845,6 @@ async function promptSecret(label) {
     input2.on("data", onData);
   });
 }
-async function confirm(question) {
-  if (process.stdin.isTTY !== true) return false;
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await rl.question(`${question} [y/N] `);
-    return answer.trim().toLowerCase() === "y";
-  } finally {
-    rl.close();
-  }
-}
 function parseSelection(answer, count) {
   const text = answer.trim().toLowerCase();
   if (text === "" || text === "all" || text === "a") {
@@ -19919,7 +19896,7 @@ function quickstart(config2) {
     "hubskillz status"
   ) + step(
     synced,
-    "Install the approved set everywhere, adopt what the directory lacks",
+    "Upload every skill of this machine to your directory",
     "hubskillz sync --all"
   ) + `
 ${dim("Run `hubskillz help` for every command, `hubskillz help <command>` for its flags.")}
@@ -20344,7 +20321,7 @@ function printNotes(surface, items, baseUrl) {
   const importable = items.filter((item) => item.importable).map((item) => item.name);
   if (importable.length > 0) {
     process.stdout.write(
-      `${dim(`${importable.length} not in the directory yet, run npx hubskillz sync to adopt them:`)} ${importable.join(", ")}
+      `${dim(`${importable.length} not in your directory yet, run npx hubskillz sync to add them:`)} ${importable.join(", ")}
 `
     );
   }
@@ -20390,7 +20367,7 @@ function printSurface(surface, inventory, baseUrl) {
   ).length;
   if (duplicates > 0) {
     process.stdout.write(
-      `${dim(`${duplicates} duplicate cop${duplicates === 1 ? "y" : "ies"} here: run npx hubskillz sync to remove ${duplicates === 1 ? "it" : "them"}`)}
+      `${dim(`${duplicates} duplicate cop${duplicates === 1 ? "y" : "ies"} of ~/.claude/skills here: remove ${duplicates === 1 ? "it" : "them"} or keep ${duplicates === 1 ? "it" : "them"} on purpose`)}
 `
     );
   }
@@ -20410,126 +20387,12 @@ function printSurface(surface, inventory, baseUrl) {
   ).length;
   if (behind > 0) {
     process.stdout.write(
-      `${dim(`${plural(behind, "skill")} to install or update: run npx hubskillz sync`)}
+      `${dim(`${plural(behind, "skill")} behind the approved version: review at ${reviewUrl(baseUrl)}`)}
 `
     );
   }
 }
 
-// src/commands/sync.ts
-import { lstat as lstat2, readdir as readdir4, realpath as realpath2, rm as rm4 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { join as join8, resolve as resolve7, sep as sep2 } from "node:path";
-
-// src/apply.ts
-import { mkdir as mkdir3, mkdtemp, rename as rename2, rm as rm3, rmdir, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname3, join as join7, sep } from "node:path";
-async function applySkill(input2) {
-  for (const path of [...input2.files.map((f) => f.path), ...input2.remove]) {
-    if (!isSafeRelativePath(path)) {
-      return Result.fail(
-        new CliError(
-          "UNSAFE_PATH",
-          `Refusing to write outside the skill: ${path}`
-        )
-      );
-    }
-  }
-  await mkdir3(input2.dir, { recursive: true });
-  const staging = await mkdtemp(join7(dirname3(input2.dir), ".hubskillz-"));
-  try {
-    for (const file2 of input2.files) {
-      const staged = join7(staging, ...file2.path.split("/"));
-      await mkdir3(dirname3(staged), { recursive: true });
-      await writeFile2(staged, file2.content, "utf8");
-    }
-    for (const file2 of input2.files) {
-      const target = join7(input2.dir, ...file2.path.split("/"));
-      await mkdir3(dirname3(target), { recursive: true });
-      await rename2(join7(staging, ...file2.path.split("/")), target);
-    }
-    for (const path of input2.remove) {
-      const target = join7(input2.dir, ...path.split("/"));
-      await rm3(target, { force: true });
-      await pruneEmptyDirs(dirname3(target), input2.dir);
-    }
-  } finally {
-    await rm3(staging, { recursive: true, force: true });
-  }
-  return Result.ok(void 0);
-}
-function isSafeRelativePath(path) {
-  if (path === "" || path.startsWith("/") || /^[a-zA-Z]:/u.test(path)) {
-    return false;
-  }
-  return !path.split(/[/\\]/u).includes("..");
-}
-async function pruneEmptyDirs(from, stopAt) {
-  let current = from;
-  while (current.startsWith(stopAt + sep)) {
-    try {
-      await rmdir(current);
-    } catch {
-      return;
-    }
-    current = dirname3(current);
-  }
-}
-
-// src/plan.ts
-function computePlan(input2) {
-  const plans = [];
-  for (const skill of input2.approved) {
-    const local = input2.local.find((entry) => entry.name === skill.name);
-    const item = input2.items.find((entry) => entry.name === skill.name);
-    const state = item?.state ?? (local === void 0 ? "missing" : "customized");
-    const localFiles = new Map(
-      (local?.files ?? []).map((file2) => [file2.path, file2.content])
-    );
-    const wanted = new Map(
-      skill.files.map((file2) => [file2.path, file2.content])
-    );
-    const added = [];
-    const changed = [];
-    for (const [path, content] of wanted) {
-      const current = localFiles.get(path);
-      if (current === void 0) added.push(path);
-      else if (current !== content) changed.push(path);
-    }
-    const removed = [...localFiles.keys()].filter((path) => !wanted.has(path));
-    plans.push({
-      name: skill.name,
-      state,
-      version: skill.version,
-      release: releaseOf(skill.files),
-      action: actionFor(
-        state,
-        local !== void 0,
-        added.length + changed.length + removed.length,
-        input2.force
-      ),
-      added: added.sort(),
-      changed: changed.sort(),
-      removed: removed.sort()
-    });
-  }
-  return plans.sort((a, b) => a.name < b.name ? -1 : 1);
-}
-function versionLabel(plan) {
-  return plan.release ?? `v${plan.version}`;
-}
-function actionFor(state, installed, diffCount, force) {
-  if (state === "inherited") return installed ? "remove" : "inherited";
-  if (state === "customized" && !force) return "skip";
-  if (!installed) return "install";
-  return diffCount === 0 ? "keep" : "update";
-}
-function planHasWrites(plans) {
-  return plans.some(
-    (plan) => plan.action === "install" || plan.action === "update" || plan.action === "remove"
-  );
-}
-
 // src/commands/sync.ts
 async function sync(options) {
   const config2 = await readConfig();
@@ -20546,10 +20409,10 @@ async function sync(options) {
     projects2
   );
   for (const surface of surfaces) {
-    const result = await syncSurface(session, surface, options);
+    const result = await syncSurface(session, surface);
     if (result.isFailure) return result;
   }
-  if (!options.dryRun && config2.value.firstSyncAt === void 0 && process.env["HUBSKILLZ_TOKEN"] === void 0) {
+  if (config2.value.firstSyncAt === void 0 && process.env["HUBSKILLZ_TOKEN"] === void 0) {
     const stored = await readConfig();
     if (stored.isSuccess && stored.value.firstSyncAt === void 0) {
       await writeConfig({
@@ -20561,57 +20424,20 @@ async function sync(options) {
   }
   return Result.ok(void 0);
 }
-async function syncSurface(session, surface, options) {
+async function syncSurface(session, surface) {
   const first = await postInventory(session, surface);
   if (first.isFailure) return Result.fail(first.error);
-  const surfaceId = first.value.surfaceId;
-  const inventory = await maybeAdopt(session, surface, first.value, options);
+  const inventory = await adoptImportable(session, surface, first.value);
   if (inventory.isFailure) return Result.fail(inventory.error);
-  const approved = await apiRequest({
-    session,
-    method: "GET",
-    path: `/api/cli/approved?surfaceId=${encodeURIComponent(surfaceId)}`,
-    schema: approvedResponseSchema
-  });
-  if (approved.isFailure) return Result.fail(approved.error);
-  const blocked = approved.value.skills.filter((skill) => skill.blocked);
-  const plans = computePlan({
-    items: inventory.value.items,
-    approved: approved.value.skills.filter((skill) => !skill.blocked),
-    local: surface.skills,
-    force: options.force
-  });
-  printHeader(surface);
-  printPlan(plans, blocked, surface);
-  printNotes(surface, inventory.value.items, session.baseUrl);
-  if (options.dryRun) return Result.ok(void 0);
-  if (!planHasWrites(plans)) return clearPending(session, surfaceId);
-  if (!options.yes && !await confirm("Apply?")) {
-    process.stdout.write("Nothing applied.\n");
-    return Result.ok(void 0);
-  }
-  const applied = await applyPlan(surface, plans, approved.value.skills);
-  if (applied.isFailure) return applied;
-  const rescanned = await scanSurface(
-    surface.descriptor.path,
-    surface.descriptor.label,
-    surface.descriptor.machineId,
-    surface.descriptor.scope
-  );
-  const reposted = await postInventory(session, rescanned);
-  if (reposted.isFailure) return Result.fail(reposted.error);
-  return clearPending(session, surfaceId);
+  printSurface(surface, inventory.value, session.baseUrl);
+  return clearPending(session, first.value.surfaceId);
 }
-async function maybeAdopt(session, surface, inventory, options) {
+async function adoptImportable(session, surface, inventory) {
   const importable = inventory.items.filter((item) => item.importable);
-  if (importable.length === 0 || options.dryRun) return Result.ok(inventory);
-  const wanted = options.adopt || !options.yes && await confirm(
-    `Adopt ${plural(importable.length, "skill")} found here as approved in your directory?`
-  );
-  if (!wanted) return Result.ok(inventory);
+  if (importable.length === 0) return Result.ok(inventory);
   process.stdout.write(
     dim(
-      `adopting ${plural(importable.length, "skill")}, this can take a minute...
+      `adding ${plural(importable.length, "skill")} to your directory, this can take a minute...
 `
     )
   );
@@ -20624,95 +20450,22 @@ async function maybeAdopt(session, surface, inventory, options) {
   });
   if (adopted.isFailure && adopted.error.code === "FORBIDDEN") {
     process.stdout.write(
-      `${dim("not adopted: ask a maintainer to adopt these skills")}
+      `${dim("not added: ask a maintainer to adopt these skills")}
 `
     );
     return Result.ok(inventory);
   }
   if (adopted.isFailure) return Result.fail(adopted.error);
-  const names = adopted.value.adopted;
-  process.stdout.write(
-    names.length === 0 ? `${dim("nothing adopted")}
-` : `adopted ${plural(names.length, "skill")} as approved: ${names.join(", ")}
-`
-  );
   for (const skip of adopted.value.skipped) {
     process.stdout.write(dim(`skipped ${skip.name} (${skip.code})
 `));
   }
   if (adopted.value.adopted.length === 0) return Result.ok(inventory);
-  return postInventory(session, surface);
-}
-async function applyPlan(surface, plans, approved) {
-  for (const plan of plans) {
-    if (plan.action === "remove") {
-      if (!exists(join8(globalSkillsRoot(), plan.name))) {
-        process.stdout.write(
-          `${plan.name}: no longer in ~/.claude/skills, keeping the copy here
-`
-        );
-        continue;
-      }
-      await rm4(join8(surface.descriptor.path, plan.name), {
-        recursive: true,
-        force: true
-      });
-      process.stdout.write(
-        `removed ${plan.name} (inherited from ~/.claude/skills)
-`
-      );
-      continue;
-    }
-    if (plan.action !== "install" && plan.action !== "update") continue;
-    const skill = approved.find((entry) => entry.name === plan.name);
-    if (skill === void 0) continue;
-    const dir = await writeTarget(surface.descriptor.path, plan.name);
-    if (dir.isFailure) return Result.fail(dir.error);
-    if (await containsSymlink(dir.value)) {
-      process.stdout.write(
-        `${plan.name}: contains a symlink, refusing to write
-`
-      );
-      continue;
-    }
-    const written = await applySkill({
-      dir: dir.value,
-      files: skill.files,
-      remove: plan.removed
-    });
-    if (written.isFailure) return written;
-    process.stdout.write(
-      `${plan.action === "install" ? "installed" : "updated"} ${plan.name} ${versionLabel(plan)}
+  process.stdout.write(
+    `added ${plural(adopted.value.adopted.length, "skill")} to your directory: ${adopted.value.adopted.join(", ")}
 `
-    );
-  }
-  return Result.ok(void 0);
-}
-async function writeTarget(root, name) {
-  const dir = join8(root, name);
-  const stats = await lstat2(dir).catch(() => null);
-  if (stats === null || !stats.isSymbolicLink()) return Result.ok(dir);
-  const target = await realpath2(dir).catch(() => null);
-  const home2 = await realpath2(homedir6()).catch(() => homedir6());
-  if (target === null || !isInside(target, home2) || isInside(target, await realpath2(root).catch(() => resolve7(root)))) {
-    return Result.fail(
-      new CliError(
-        "UNSAFE_LINK",
-        `Refusing to write through ${dir}: it points to ${target ?? "nowhere"}.`
-      )
-    );
-  }
-  return Result.ok(target);
-}
-async function containsSymlink(dir) {
-  const entries = await readdir4(dir, {
-    recursive: true,
-    withFileTypes: true
-  }).catch(() => []);
-  return entries.some((entry) => entry.isSymbolicLink());
-}
-function isInside(path, dir) {
-  return path.startsWith(dir + sep2);
+  );
+  return postInventory(session, surface);
 }
 async function clearPending(session, surfaceId) {
   const pending = await apiRequest({
@@ -20733,101 +20486,29 @@ async function clearPending(session, surfaceId) {
   }
   return Result.ok(void 0);
 }
-function printPlan(plans, blocked, surface) {
-  const listed = plans.filter((plan) => plan.action !== "inherited");
-  const rows = [
-    ...listed.map((plan) => [
-      plan.action,
-      plan.name,
-      originOf(surface, plan.name),
-      versionLabel(plan),
-      detailOf(plan)
-    ]),
-    ...blocked.map((skill) => [
-      accent("blocked"),
-      skill.name,
-      originOf(surface, skill.name),
-      versionLabel({ version: skill.version, release: releaseOf(skill.files) }),
-      `org policy: ${skill.blockedReason ?? "no reason given"}`
-    ])
-  ];
-  const inherited = plans.length - listed.length;
-  if (rows.length === 0) {
-    const note = inherited > 0 ? `nothing to sync, ${inherited} inherited from ~/.claude/skills` : "nothing to sync";
-    process.stdout.write(`${dim(note)}
-
-`);
-    return;
-  }
-  process.stdout.write(
-    `${table(["ACTION", "SKILL", "ORIGIN", "VERSION", "FILES"], rows)}
-`
-  );
-  for (const plan of plans) {
-    if (plan.action !== "update") continue;
-    for (const [marker, paths] of [
-      ["+", plan.added],
-      ["~", plan.changed],
-      ["-", plan.removed]
-    ]) {
-      for (const path of paths) {
-        process.stdout.write(dim(`  ${marker} ${plan.name}/${path}
-`));
-      }
-    }
-  }
-  const counts = [
-    [plans.filter((plan) => plan.action === "install").length, "to install"],
-    [plans.filter((plan) => plan.action === "update").length, "to update"],
-    [plans.filter((plan) => plan.action === "keep").length, "up to date"],
-    [plans.filter((plan) => plan.action === "remove").length, "to remove"],
-    [
-      plans.filter((plan) => plan.action === "inherited").length,
-      "inherited from ~/.claude/skills"
-    ],
-    [plans.filter((plan) => plan.action === "skip").length, "skipped"],
-    [blocked.length, "blocked"]
-  ];
-  process.stdout.write(
-    `${counts.filter(([n]) => n > 0).map(([n, label]) => `${n} ${label}`).join(", ")}
-
-`
-  );
-}
-function detailOf(plan) {
-  if (plan.action === "keep") return dim("up to date");
-  if (plan.action === "skip") {
-    return `${accent("customized locally")}, use --force to overwrite`;
-  }
-  if (plan.action === "remove") {
-    return "duplicate of ~/.claude/skills, Claude Code loads it from there";
-  }
-  if (plan.action === "install") return `+${plan.added.length}`;
-  return `+${plan.added.length} ~${plan.changed.length} -${plan.removed.length}`;
-}
 
 // src/commands/upgrade.ts
 import { spawn } from "node:child_process";
-import { homedir as homedir7 } from "node:os";
-import { resolve as resolve8 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { resolve as resolve7 } from "node:path";
 function globalRoot() {
   return {
     label: "global",
-    cwd: homedir7(),
+    cwd: homedir6(),
     scope: "-g",
     lockPath: globalLockPath()
   };
 }
 function projectRoot(dir) {
   return {
-    label: shortPath(resolve8(dir)),
-    cwd: resolve8(dir),
+    label: shortPath(resolve7(dir)),
+    cwd: resolve7(dir),
     scope: "-p",
     lockPath: projectLockPath(dir)
   };
 }
 function upgradeRoots(path, all, registered) {
-  const dir = resolve8(path ?? process.cwd());
+  const dir = resolve7(path ?? process.cwd());
   const hasProject = exists(projectSkillsRoot(dir));
   if (!all) return [hasProject ? projectRoot(dir) : globalRoot()];
   return [
@@ -20957,8 +20638,8 @@ var COMMANDS = [
   },
   {
     name: "sync",
-    usage: "hubskillz sync [--path DIR] [--all] [--adopt] [--yes] [--dry-run] [--force]",
-    summary: "Install and update skills to the approved versions",
+    usage: "hubskillz sync [--path DIR] [--all] [--yes]",
+    summary: "Upload the skills as they are, like a git push",
     flags: [
       {
         spec: "--path DIR",
@@ -20969,12 +20650,9 @@ var COMMANDS = [
         help: "Global root, this project and every registered project"
       },
       {
-        spec: "--adopt",
-        help: "Add importable skills to the directory as approved (maintainers)"
-      },
-      { spec: "-y, --yes", help: "Apply without asking" },
-      { spec: "--dry-run", help: "Print the plan and stop" },
-      { spec: "--force", help: "Overwrite skills you customized locally" }
+        spec: "-y, --yes",
+        help: "Register every discovered project without asking"
+      }
     ]
   },
   {
@@ -21045,7 +20723,7 @@ function flagLines(flags) {
 }
 function usage() {
   const width = Math.max(...COMMANDS.map((command) => command.name.length));
-  return `${bold("hubskillz")} ${dim(`v${"0.4.0"}`)}  keep your agent skills in sync
+  return `${bold("hubskillz")} ${dim(`v${"1.0.0"}`)}  keep your agent skills in sync
 
 ${bold("Usage")}
   hubskillz <command> [flags]
@@ -21107,9 +20785,7 @@ async function run() {
         token: { type: "string" },
         path: { type: "string" },
         all: { type: "boolean", default: false },
-        adopt: { type: "boolean", default: false },
         yes: { type: "boolean", short: "y", default: false },
-        "dry-run": { type: "boolean", default: false },
         force: { type: "boolean", default: false },
         message: { type: "string", short: "m" },
         from: { type: "string" },
@@ -21125,7 +20801,7 @@ Run \`hubskillz help\` for usage.`)
     );
   }
   if (values.version === true) {
-    process.stdout.write(`${"0.4.0"}
+    process.stdout.write(`${"1.0.0"}
 `);
     return Result.ok(void 0);
   }
@@ -21151,10 +20827,7 @@ Run \`hubskillz help\` for usage.`)
         baseUrl: values["base-url"],
         path: values.path,
         all: values.all === true,
-        adopt: values.adopt === true,
-        yes: values.yes === true,
-        dryRun: values["dry-run"] === true,
-        force: values.force === true
+        yes: values.yes === true
       });
     case "upgrade":
       return upgrade({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hubskillz",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "Keep your Claude Code skills in sync with your organization's approved catalog.",
   "license": "MIT",
   "author": "Jérôme Desmares",