@hungvv/super-ads-skills 0.0.0-stage → 1.0.0

package/dist/cli.js

@@ -0,0 +1,654 @@
+// src/cli.ts
+import { readFileSync as readFileSync3 } from "fs";
+import path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Command } from "commander";
+import pc from "picocolors";
+
+// src/agents.ts
+import { existsSync } from "fs";
+import os from "os";
+import path from "path";
+var TARGETS = {
+  claude: {
+    id: "claude",
+    project: path.join(".claude", "skills"),
+    global: path.join(os.homedir(), ".claude", "skills")
+  },
+  cursor: {
+    id: "cursor",
+    project: path.join(".cursor", "skills"),
+    global: path.join(os.homedir(), ".cursor", "skills")
+  },
+  agents: {
+    id: "agents",
+    project: path.join(".agents", "skills"),
+    global: path.join(os.homedir(), ".agents", "skills")
+  },
+  antigravity: {
+    id: "antigravity",
+    project: path.join(".agents", "skills"),
+    global: path.join(os.homedir(), ".gemini", "config", "skills")
+  },
+  // Global-only in practice: no project-level equivalent is known, so this reuses the same project
+  // path as `antigravity` (already shared with `agents`/Codex) rather than leaving it unspecified.
+  "antigravity-builtin": {
+    id: "antigravity-builtin",
+    project: path.join(".agents", "skills"),
+    global: path.join(os.homedir(), ".gemini", "antigravity-ide", "builtin", "skills")
+  }
+};
+var AGENTS = [
+  { id: "claude", label: "Claude Code", targets: ["claude"], hints: [".claude", "CLAUDE.md"] },
+  { id: "cursor", label: "Cursor", targets: ["cursor"], hints: [".cursor"] },
+  { id: "codex", label: "Codex", targets: ["agents"], hints: [".codex", ".agents", "AGENTS.md"] },
+  // No project file is unique to Antigravity yet (it shares `.agents/` with Codex), so it is never
+  // auto-detected — the user picks it explicitly with `--agent antigravity`. Two targets: its own
+  // `config/skills` plus the IDE's `builtin/skills` — both point at the same folder at project scope.
+  { id: "antigravity", label: "Antigravity", targets: ["antigravity", "antigravity-builtin"], hints: [] }
+];
+var DEFAULT_AGENTS = AGENTS.map((a) => a.id);
+function agentById(id) {
+  return AGENTS.find((a) => a.id === id);
+}
+function agentsForTarget(target) {
+  return AGENTS.filter((a) => a.targets.includes(target));
+}
+function targetsForAgents(agents) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of agents) {
+    const agent = agentById(id);
+    agent?.targets.forEach((t) => seen.add(t));
+  }
+  return [...seen];
+}
+function targetRoot(target, opts) {
+  const spec = TARGETS[target];
+  return opts.global ? spec.global : path.join(opts.cwd, spec.project);
+}
+function targetLabel(target) {
+  return agentsForTarget(target).map((a) => a.label).join(" / ");
+}
+
+// src/installer.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  readlinkSync,
+  readdirSync as readdirSync2,
+  rmSync,
+  rmdirSync,
+  statSync as statSync2,
+  symlinkSync,
+  unlinkSync as unlinkSync2
+} from "fs";
+import os3 from "os";
+import path4 from "path";
+import semver2 from "semver";
+
+// src/manifest.ts
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import os2 from "os";
+import path2 from "path";
+var META_FILENAME = ".super-ads-skills-meta.json";
+var PROJECT_MANIFEST = ".super-ads-skills.json";
+function manifestPath(scope) {
+  if (!scope.global) return path2.join(scope.cwd, PROJECT_MANIFEST);
+  const base = process.env.XDG_CONFIG_HOME || path2.join(os2.homedir(), ".config");
+  return path2.join(base, "super-ads-skills", "manifest.json");
+}
+function emptyManifest(packageVersion) {
+  return { schemaVersion: 1, packageVersion, installed: {} };
+}
+function readManifest(scope, packageVersion) {
+  try {
+    const parsed = JSON.parse(readFileSync(manifestPath(scope), "utf8"));
+    if (parsed.schemaVersion !== 1) throw new Error(`Unsupported manifest schemaVersion ${parsed.schemaVersion}`);
+    return { ...parsed, installed: parsed.installed ?? {} };
+  } catch (error) {
+    if (error.code === "ENOENT") return emptyManifest(packageVersion);
+    throw error;
+  }
+}
+function writeManifest(scope, manifest) {
+  const file = manifestPath(scope);
+  if (!Object.keys(manifest.installed).length) {
+    try {
+      unlinkSync(file);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    return;
+  }
+  mkdirSync(path2.dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function isSafeRelPath(rel) {
+  if (typeof rel !== "string" || rel.length === 0) return false;
+  if (rel.includes("\0") || rel.includes("\\")) return false;
+  if (rel.startsWith("/") || /^[a-zA-Z]:/.test(rel)) return false;
+  return rel.split("/").every((part) => part !== "" && part !== "." && part !== "..");
+}
+function readMeta(skillDir) {
+  try {
+    const meta = JSON.parse(readFileSync(path2.join(skillDir, META_FILENAME), "utf8"));
+    if (!Array.isArray(meta?.files) || !meta.files.every(isSafeRelPath)) return null;
+    return meta;
+  } catch {
+    return null;
+  }
+}
+function writeMeta(skillDir, meta) {
+  writeFileSync(path2.join(skillDir, META_FILENAME), `${JSON.stringify(meta, null, 2)}
+`, "utf8");
+}
+
+// src/skills.ts
+import { createHash } from "crypto";
+import { readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+import semver from "semver";
+import { z } from "zod";
+var GROUPS = ["Ads"];
+var OTHER_GROUP = "Other";
+var SKILL_PREFIX = "super-ads";
+var UNPREFIXED_SKILLS = ["adspro-to-superads"];
+function isKitSkillName(name) {
+  return name.startsWith(`${SKILL_PREFIX}-`) || UNPREFIXED_SKILLS.includes(name);
+}
+function fullName(input) {
+  return isKitSkillName(input) ? input : `${SKILL_PREFIX}-${input}`;
+}
+var SkillFrontmatterSchema = z.object({
+  /**
+   * Template/frontmatter schema version. Lets the CLI migrate old skills when the template
+   * changes, instead of guessing from headings. Optional so pre-schema skills still load; new
+   * skills set 1.
+   */
+  schema: z.coerce.number().int().positive().optional(),
+  name: z.string().regex(/^[a-z0-9-]+$/, "name must be kebab-case [a-z0-9-]").refine(isKitSkillName, `name must start with "${SKILL_PREFIX}-" or be one of: ${UNPREFIXED_SKILLS.join(", ")}`),
+  description: z.string().min(1, "description is required"),
+  version: z.string().refine((v) => !!semver.valid(v), "version must be valid semver"),
+  group: z.enum(GROUPS).optional()
+});
+var IGNORED_ENTRIES = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db", ".super-ads-skills-meta.json"]);
+function listSkillFiles(dir) {
+  const out = [];
+  const walk = (current, prefix) => {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      if (IGNORED_ENTRIES.has(entry.name)) continue;
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const abs = path3.join(current, entry.name);
+      if (entry.isSymbolicLink()) throw new Error(`Symlinks are not allowed in skills: ${rel}`);
+      if (entry.isDirectory()) walk(abs, rel);
+      else if (entry.isFile()) out.push(rel);
+    }
+  };
+  walk(dir, "");
+  return out.sort();
+}
+function hashFolder(dir, files) {
+  const hash = createHash("sha256");
+  for (const rel of files) {
+    const content = readFileSync2(path3.join(dir, ...rel.split("/"))).toString("utf8").replace(/\r\n/g, "\n");
+    hash.update(rel);
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\0");
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+function readSkill(dir) {
+  const skillMd = path3.join(dir, "SKILL.md");
+  const raw = readFileSync2(skillMd, "utf8");
+  if (raw.charCodeAt(0) === 65279) {
+    throw new Error("SKILL.md starts with a UTF-8 BOM; save it as UTF-8 without BOM");
+  }
+  const parsed = matter(raw);
+  const front = SkillFrontmatterSchema.parse(parsed.data);
+  const folderName = path3.basename(dir);
+  if (front.name !== folderName) {
+    throw new Error(`frontmatter name "${front.name}" must match folder name "${folderName}"`);
+  }
+  const files = listSkillFiles(dir);
+  return {
+    ...front,
+    displayGroup: front.group ?? OTHER_GROUP,
+    dir,
+    files,
+    contentHash: hashFolder(dir, files),
+    body: parsed.content
+  };
+}
+function bundledSkillsDir() {
+  const here = path3.dirname(fileURLToPath(import.meta.url));
+  return path3.resolve(here, "..", "skills");
+}
+function loadSkills(root = bundledSkillsDir()) {
+  const entries = readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path3.join(root, e.name)).filter((dir) => {
+    try {
+      return statSync(path3.join(dir, "SKILL.md")).isFile();
+    } catch {
+      return false;
+    }
+  });
+  return entries.map(readSkill).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/installer.ts
+function skillStoreRoot() {
+  if (process.env.SUPER_ADS_SKILLS_STORE) return process.env.SUPER_ADS_SKILLS_STORE;
+  if (process.platform === "win32") {
+    const base2 = process.env.LOCALAPPDATA || path4.join(os3.homedir(), "AppData", "Local");
+    return path4.join(base2, "super-ads-skills", "skills");
+  }
+  const base = process.env.XDG_DATA_HOME || path4.join(os3.homedir(), ".local", "share");
+  return path4.join(base, "super-ads-skills", "skills");
+}
+function skillStoreDir(skillName) {
+  assertSafeSkillName(skillName);
+  return path4.join(skillStoreRoot(), skillName);
+}
+function listSkillDirs(scope) {
+  const found = /* @__PURE__ */ new Map();
+  for (const target of Object.keys(TARGETS)) {
+    const root = targetRoot(target, scope);
+    if (!existsSync2(root)) continue;
+    for (const entry of readdirSync2(root, { withFileTypes: true })) {
+      if (!(entry.isDirectory() || entry.isSymbolicLink()) || !/^[a-z0-9-]+$/.test(entry.name)) continue;
+      if (!existsSync2(path4.join(root, entry.name, "SKILL.md"))) continue;
+      found.set(entry.name, [...found.get(entry.name) ?? [], target]);
+    }
+  }
+  return found;
+}
+function assertSafeSkillName(name) {
+  if (!/^[a-z0-9-]+$/.test(name)) throw new Error(`Unsafe skill name: ${name}`);
+}
+function unlinkInside(destDir, abs) {
+  const root = path4.resolve(destDir);
+  const target = path4.resolve(abs);
+  if (target !== root && !target.startsWith(root + path4.sep)) {
+    throw new Error(`Refusing to delete outside the skill folder: ${target}`);
+  }
+  if (existsSync2(target)) unlinkSync2(target);
+}
+function lstatOrNull(abs) {
+  try {
+    return lstatSync(abs);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function unlinkNestedStoreLink(destDir, storeDir) {
+  let entries;
+  try {
+    entries = readdirSync2(destDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isSymbolicLink()) continue;
+    const abs = path4.join(destDir, entry.name);
+    const points = resolvedLink(abs);
+    if (points && path4.resolve(points) === storeDir) unlinkSync2(abs);
+  }
+}
+function resolvedLink(destDir) {
+  const stat = lstatOrNull(destDir);
+  if (!stat?.isSymbolicLink()) return null;
+  return path4.resolve(path4.dirname(destDir), readlinkSync(destDir));
+}
+function currentHash(dir, files) {
+  const present = files.filter((rel) => existsSync2(path4.join(dir, ...rel.split("/"))));
+  return hashFolder(dir, present);
+}
+function hasDrift(destDir, meta) {
+  const missing = meta.files.some((rel) => !existsSync2(path4.join(destDir, ...rel.split("/"))));
+  if (missing) return true;
+  return currentHash(destDir, meta.files) !== meta.contentHash;
+}
+function installAction(skill, meta, packageVersion) {
+  if (semver2.gt(skill.version, meta.version)) return "update";
+  if (semver2.lt(skill.version, meta.version)) return "downgrade";
+  if (meta.packageVersion !== packageVersion) return "update";
+  if (meta.contentHash !== skill.contentHash) return "update";
+  return "skip";
+}
+function planInstall(skill, target, scope, mode = "link", packageVersion) {
+  assertSafeSkillName(skill.name);
+  const destDir = path4.join(targetRoot(target, scope), skill.name);
+  const storeDir = mode === "link" ? skillStoreDir(skill.name) : void 0;
+  const files = skill.files.map((rel) => path4.join(storeDir ?? destDir, ...rel.split("/")));
+  const base = { skill, target, destDir, files, mode, storeDir };
+  if (mode === "copy") {
+    const destStat = lstatOrNull(destDir);
+    if (destStat?.isSymbolicLink()) {
+      return {
+        ...base,
+        action: isStoreLink(destDir, skill.name) ? "update" : "drift"
+      };
+    }
+    const meta2 = readMeta(destDir);
+    if (!existsSync2(destDir) || !meta2) return { ...base, action: "create" };
+    if (hasDrift(destDir, meta2)) return { ...base, action: "drift", installedVersion: meta2.version };
+    const action = installAction(skill, meta2, packageVersion);
+    return { ...base, action, installedVersion: meta2.version };
+  }
+  const stat = lstatOrNull(destDir);
+  if (!stat) return { ...base, action: "create" };
+  if (stat.isSymbolicLink()) {
+    const points = resolvedLink(destDir);
+    const storeMeta = readMeta(skillStoreDir(skill.name));
+    if (!points || path4.resolve(points) !== path4.resolve(skillStoreDir(skill.name)) || !storeMeta) {
+      return { ...base, action: "update", installedVersion: storeMeta?.version };
+    }
+    const action = installAction(skill, storeMeta, packageVersion);
+    return { ...base, action, installedVersion: storeMeta.version };
+  }
+  if (!isPreviousCopy(destDir, skill)) return { ...base, action: "drift" };
+  const meta = readMeta(destDir);
+  return { ...base, action: "update", installedVersion: meta?.version };
+}
+function isPreviousCopy(destDir, skill) {
+  const meta = readMeta(destDir);
+  if (meta?.skill === skill.name) return true;
+  const nested = resolvedLink(path4.join(destDir, skill.name));
+  if (nested && path4.resolve(nested) === path4.resolve(skillStoreDir(skill.name))) return true;
+  return false;
+}
+function isStoreLink(destDir, skillName) {
+  const points = resolvedLink(destDir);
+  return Boolean(points && path4.resolve(points) === path4.resolve(skillStoreDir(skillName)));
+}
+function writeSkillTree(skill, destDir, packageVersion) {
+  const previous = lstatOrNull(destDir)?.isSymbolicLink() ? null : readMeta(destDir);
+  if (previous) {
+    for (const rel of previous.files) {
+      if (skill.files.includes(rel)) continue;
+      unlinkInside(destDir, path4.join(destDir, ...rel.split("/")));
+    }
+  }
+  for (const rel of skill.files) {
+    const from = path4.join(skill.dir, ...rel.split("/"));
+    const to = path4.join(destDir, ...rel.split("/"));
+    mkdirSync2(path4.dirname(to), { recursive: true });
+    copyFileSync(from, to);
+  }
+  const meta = {
+    schemaVersion: 1,
+    skill: skill.name,
+    version: skill.version,
+    packageVersion,
+    contentHash: skill.contentHash,
+    files: [...skill.files]
+  };
+  writeMeta(destDir, meta);
+  pruneEmptyDirs(destDir);
+}
+function linkSkill(storeDir, destDir) {
+  const expected = path4.resolve(storeDir);
+  if (path4.resolve(destDir) === expected) {
+    throw new Error(`Refusing to replace the store with a link to itself: ${destDir}`);
+  }
+  const current = resolvedLink(destDir);
+  if (current && path4.resolve(current) === expected) return;
+  const stat = lstatOrNull(destDir);
+  if (stat?.isSymbolicLink()) unlinkSync2(destDir);
+  else if (stat?.isDirectory()) {
+    unlinkNestedStoreLink(destDir, expected);
+    rmSync(destDir, { recursive: true });
+  } else if (stat) unlinkSync2(destDir);
+  mkdirSync2(path4.dirname(destDir), { recursive: true });
+  try {
+    symlinkSync(storeDir, destDir);
+  } catch (error) {
+    const code = error.code;
+    if (code === "EPERM" || code === "EACCES") {
+      throw new Error(
+        `Could not create a symlink at ${destDir}. Enable Developer Mode or run as administrator, or re-run with --copy.`
+      );
+    }
+    throw error;
+  }
+}
+function executeInstall(plan, packageVersion) {
+  if (plan.mode === "copy") {
+    const stat = lstatOrNull(plan.destDir);
+    if (stat?.isSymbolicLink()) {
+      if (!isStoreLink(plan.destDir, plan.skill.name)) {
+        throw new Error(`Refusing to replace an unmanaged symlink: ${plan.destDir}`);
+      }
+      unlinkSync2(plan.destDir);
+    }
+    writeSkillTree(plan.skill, plan.destDir, packageVersion);
+    return;
+  }
+  const storeDir = plan.storeDir ?? skillStoreDir(plan.skill.name);
+  writeSkillTree(plan.skill, storeDir, packageVersion);
+  linkSkill(storeDir, plan.destDir);
+}
+function planRemove(skillName, target, scope) {
+  assertSafeSkillName(skillName);
+  const destDir = path4.join(targetRoot(target, scope), skillName);
+  const base = {
+    skillName,
+    target,
+    destDir,
+    files: [],
+    kept: [],
+    unmanaged: false,
+    drift: false,
+    linked: false
+  };
+  const stat = lstatOrNull(destDir);
+  if (!stat) return base;
+  if (stat.isSymbolicLink()) {
+    return { ...base, linked: true, files: [destDir] };
+  }
+  if (!existsSync2(destDir)) return base;
+  const meta = readMeta(destDir);
+  if (!meta) {
+    return {
+      ...base,
+      unmanaged: true,
+      files: listSkillFiles(destDir).map((rel) => path4.join(destDir, ...rel.split("/")))
+    };
+  }
+  const present = listSkillFiles(destDir);
+  const managed = new Set(meta.files);
+  return {
+    ...base,
+    files: [
+      ...meta.files.map((rel) => path4.join(destDir, ...rel.split("/"))).filter((abs) => existsSync2(abs)),
+      path4.join(destDir, META_FILENAME)
+    ],
+    kept: present.filter((rel) => !managed.has(rel)),
+    drift: hasDrift(destDir, meta)
+  };
+}
+function executeRemove(plan) {
+  if (plan.linked) {
+    const stat = lstatSync(plan.destDir);
+    if (!stat.isSymbolicLink()) throw new Error(`Refusing to unlink a non-link: ${plan.destDir}`);
+    unlinkSync2(plan.destDir);
+    return;
+  }
+  for (const abs of plan.files) {
+    unlinkInside(plan.destDir, abs);
+  }
+  pruneEmptyDirs(plan.destDir, true);
+}
+function purgeSkillStore(skillName, scopes) {
+  const storeDir = skillStoreDir(skillName);
+  if (!existsSync2(storeDir)) return false;
+  const expected = path4.resolve(storeDir);
+  for (const scope of scopes) {
+    for (const target of Object.keys(TARGETS)) {
+      const destDir = path4.join(targetRoot(target, scope), skillName);
+      const points = resolvedLink(destDir);
+      if (points && path4.resolve(points) === expected) return false;
+    }
+  }
+  rmSync(storeDir, { recursive: true });
+  return true;
+}
+function pruneEmptyDirs(dir, includeSelf = false) {
+  if (!existsSync2(dir) || !statSync2(dir).isDirectory()) return;
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) pruneEmptyDirs(path4.join(dir, entry.name), true);
+  }
+  if (!includeSelf) return;
+  if (readdirSync2(dir).length === 0) rmdirSync(dir);
+}
+
+// src/status.ts
+import { existsSync as existsSync3, lstatSync as lstatSync2, readlinkSync as readlinkSync2 } from "fs";
+import path5 from "path";
+function installedInfo(skillName, scope) {
+  const out = [];
+  for (const target of Object.keys(TARGETS)) {
+    const destDir = path5.join(targetRoot(target, scope), skillName);
+    let linked = false;
+    try {
+      linked = lstatSync2(destDir).isSymbolicLink();
+    } catch {
+      continue;
+    }
+    if (linked) {
+      const meta2 = existsSync3(destDir) ? readMeta(destDir) : null;
+      const points = path5.resolve(path5.dirname(destDir), readlinkSync2(destDir));
+      const drift = !meta2 || path5.resolve(points) !== path5.resolve(skillStoreDir(skillName));
+      if (!meta2) {
+        out.push({ target, version: "0.0.0", drift: true, layout: "symlink" });
+        continue;
+      }
+      out.push({ target, version: meta2.version, drift, layout: "symlink" });
+      continue;
+    }
+    const meta = readMeta(destDir);
+    if (!meta) continue;
+    out.push({ target, version: meta.version, drift: hasDrift(destDir, meta), layout: "copy" });
+  }
+  return out;
+}
+function skillStatus(skill, scope) {
+  const installs = installedInfo(skill.name, scope);
+  const agents = [...new Set(installs.flatMap((i) => agentsForTarget(i.target).map((a) => a.label)))];
+  if (!installs.length) return { label: skill.name, hint: skill.description, state: "new", agents };
+  if (installs.some((i) => i.drift)) return { label: skill.name, hint: "Modified locally", state: "modified", agents };
+  const oldest = installs.map((i) => i.version).sort()[0];
+  if (installs.some((i) => i.version !== skill.version)) {
+    return { label: skill.name, hint: `update available ${oldest} \u2192 ${skill.version}`, state: "outdated", agents };
+  }
+  return { label: skill.name, hint: `installed v${skill.version}`, state: "installed", agents };
+}
+
+// src/cli.ts
+var PACKAGE_VERSION = JSON.parse(
+  readFileSync3(path6.resolve(path6.dirname(fileURLToPath2(import.meta.url)), "..", "package.json"), "utf8")
+).version;
+function scopeOf(opts) {
+  return { global: !opts.project, cwd: process.cwd() };
+}
+function agentsOf(opts) {
+  if (!opts.agent) return [...DEFAULT_AGENTS];
+  const ids = opts.agent.split(",").map((s) => s.trim()).filter(Boolean);
+  const unknown = ids.filter((id) => !agentById(id));
+  if (unknown.length) {
+    throw new Error(`Unknown agent: ${unknown.join(", ")}. Supported: ${AGENTS.map((a) => a.id).join(", ")}`);
+  }
+  return ids;
+}
+function describe(plan) {
+  const where = `${plan.skill.name} -> ${targetLabel(plan.target)}`;
+  const version = plan.installedVersion ? `${plan.installedVersion} -> ${plan.skill.version}` : `v${plan.skill.version}`;
+  return `${where} (${version})`;
+}
+function syncSkills(opts) {
+  const scope = scopeOf(opts);
+  const agents = agentsOf(opts);
+  const targets = targetsForAgents(agents);
+  const mode = opts.copy ? "copy" : "link";
+  const skills = loadSkills();
+  const manifest = readManifest(scope, PACKAGE_VERSION);
+  manifest.packageVersion = PACKAGE_VERSION;
+  const plans = skills.flatMap((skill) => targets.map((t) => planInstall(skill, t, scope, mode, PACKAGE_VERSION)));
+  const apply = plans.filter((p) => p.action === "create" || p.action === "update" || opts.force && p.action === "drift");
+  const blocked = opts.force ? [] : plans.filter((p) => p.action === "drift");
+  const upToDate = plans.filter((p) => p.action === "skip" || p.action === "downgrade").length;
+  const orphans = Object.keys(manifest.installed).filter((name) => !skills.some((s) => s.name === name));
+  for (const p of apply) console.log(`${pc.green(p.action === "create" ? "install" : "update ")} ${describe(p)}`);
+  for (const p of blocked) console.log(`${pc.yellow("skip   ")} ${describe(p)} - edited locally, use --force to overwrite`);
+  for (const name of orphans) console.log(`${pc.red("remove ")} ${name} - no longer in the kit`);
+  console.log(pc.dim(`${upToDate} already up to date`));
+  if (opts.dryRun) return console.log(pc.dim("dry run: nothing written"));
+  for (const p of apply) executeInstall(p, PACKAGE_VERSION);
+  for (const name of orphans) removeSkill(name, scope, targets, true);
+  for (const skill of skills) {
+    const done = plans.filter((p) => p.skill.name === skill.name && !blocked.includes(p));
+    if (!done.length) continue;
+    manifest.installed[skill.name] = { version: skill.version, targets, agents };
+  }
+  writeManifest(scope, manifest);
+  const labels = agents.map((id) => agentById(id)?.label).join(", ");
+  console.log(pc.green(`
+Done: ${skills.length} skills for ${labels} (${scope.global ? "global" : "project"}, ${mode}).`));
+  if (blocked.length) process.exitCode = 1;
+}
+function removeSkill(name, scope, targets, force) {
+  const plans = targets.map((t) => planRemove(name, t, scope)).filter((p) => p.files.length);
+  const removable = plans.filter((p) => force || !p.drift && !p.unmanaged);
+  for (const p of plans) {
+    if (removable.includes(p)) executeRemove(p);
+    else console.log(`${pc.yellow("skip   ")} ${name} -> ${targetLabel(p.target)} - not managed or edited, use --force`);
+  }
+  const manifest = readManifest(scope, PACKAGE_VERSION);
+  if (removable.length === plans.length) delete manifest.installed[name];
+  writeManifest(scope, manifest);
+  purgeSkillStore(name, [scope]);
+  return removable.length;
+}
+function runRemove(names, opts) {
+  const scope = scopeOf(opts);
+  const targets = targetsForAgents(agentsOf(opts));
+  const present = [...listSkillDirs(scope).keys()].filter(isKitSkillName);
+  const wanted = names.length ? names.map(fullName) : present;
+  for (const name of wanted) {
+    const n = removeSkill(name, scope, targets, Boolean(opts.force));
+    console.log(`${n ? pc.green("removed") : pc.dim("absent ")} ${name}`);
+  }
+}
+function runList(opts) {
+  const scope = scopeOf(opts);
+  for (const skill of loadSkills()) {
+    const s = skillStatus(skill, scope);
+    const tag = { new: pc.dim("not installed"), installed: pc.green("installed"), outdated: pc.yellow("outdated"), modified: pc.red("modified") }[s.state];
+    console.log(`${skill.name.padEnd(28)} v${skill.version.padEnd(8)} ${tag}${s.agents.length ? pc.dim(`  [${s.agents.join(", ")}]`) : ""}`);
+  }
+}
+var program = new Command();
+program.name("super-ads-skills").description("SuperAds agent skills").version(PACKAGE_VERSION);
+var common = (c) => c.option("--agent <ids>", `limit to some agents (${AGENTS.map((a) => a.id).join(",")}); default: all`).option("--project", "install into the current project instead of globally").option("--copy", "copy files instead of symlinking to the shared store").option("--force", "overwrite or remove skills edited by hand").option("--dry-run", "show what would change, write nothing");
+common(program.command("install").description("Install every skill for every supported agent (no prompts)")).action(syncSkills);
+common(program.command("update").description("Refresh installed skills to this checkout and drop retired ones")).action(syncSkills);
+common(program.command("remove [skills...]").description("Remove skills (all of them when none named)")).action(runRemove);
+common(program.command("list").description("Show every skill and its install state")).action(runList);
+program.action(() => {
+  console.log(pc.bold(`SuperAds Skills v${PACKAGE_VERSION}
+`));
+  console.log("  super-ads-skills install   install all skills for all agents");
+  console.log("  super-ads-skills update    refresh after git pull");
+  console.log("  super-ads-skills list      show state");
+  console.log("  super-ads-skills remove    uninstall");
+});
+program.parseAsync().catch((error) => {
+  console.error(pc.red(error instanceof Error ? error.message : String(error)));
+  process.exit(1);
+});