skillswitch 0.1.2 → 0.1.4

package/dist/cli.js

@@ -3,6 +3,7 @@
 // src/cli.ts
 import { Command } from "commander";
 import * as readline from "readline";
+import * as fs13 from "fs";
 
 // src/scanner.ts
 import * as fs from "fs";
@@ -36,8 +37,13 @@ function scanStandaloneSkills(claudeDir = defaultClaudeDir) {
       const filePath = path.join(dir, file);
       if (!fs.statSync(filePath).isFile()) continue;
       const name = file.slice(0, -3);
-      const content = fs.readFileSync(filePath, "utf-8");
-      skills.push({ source: "standalone", name, path: filePath, status, description: extractDescription(content) });
+      try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        skills.push({ source: "standalone", name, path: filePath, status, description: extractDescription(content) });
+      } catch {
+        process.stderr.write(`Warning: could not read ${filePath} \u2014 skipping
+`);
+      }
     }
   }
   readDir(skillsDir2, "active");
@@ -48,13 +54,30 @@ function scanPlugins(claudeDir = defaultClaudeDir) {
   const pluginsDir = path.join(claudeDir, "plugins");
   const installedFile = path.join(pluginsDir, "installed_plugins.json");
   if (!fs.existsSync(installedFile)) return [];
-  const raw = JSON.parse(fs.readFileSync(installedFile, "utf-8"));
-  const pluginMap = raw.plugins ?? {};
+  let pluginMap;
+  try {
+    const raw = JSON.parse(fs.readFileSync(installedFile, "utf-8"));
+    pluginMap = raw.plugins ?? {};
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      process.stderr.write("Warning: plugins/installed_plugins.json is malformed \u2014 skipping plugin scan\n");
+      return [];
+    }
+    throw err;
+  }
   const blockedSet = /* @__PURE__ */ new Set();
   const blocklistFile = path.join(pluginsDir, "blocklist.json");
   if (fs.existsSync(blocklistFile)) {
-    const bl = JSON.parse(fs.readFileSync(blocklistFile, "utf-8"));
-    for (const entry of bl.plugins ?? []) blockedSet.add(entry.plugin);
+    try {
+      const bl = JSON.parse(fs.readFileSync(blocklistFile, "utf-8"));
+      for (const entry of bl.plugins ?? []) blockedSet.add(entry.plugin);
+    } catch (err) {
+      if (err instanceof SyntaxError) {
+        process.stderr.write("Warning: plugins/blocklist.json is malformed \u2014 treating as empty\n");
+      } else {
+        throw err;
+      }
+    }
   }
   return Object.keys(pluginMap).map((pluginId) => {
     const atIdx = pluginId.indexOf("@");
@@ -64,7 +87,7 @@ function scanPlugins(claudeDir = defaultClaudeDir) {
     const cacheBase = path.join(pluginsDir, "cache", sourceMarket, name);
     const pluginSkills = [];
     if (fs.existsSync(cacheBase)) {
-      const versions = fs.readdirSync(cacheBase).filter((d) => fs.statSync(path.join(cacheBase, d)).isDirectory()).sort();
+      const versions = fs.readdirSync(cacheBase).filter((d) => fs.statSync(path.join(cacheBase, d)).isDirectory()).sort((a, b) => a.localeCompare(b, void 0, { numeric: true, sensitivity: "base" }));
       if (versions.length > 0) {
         const skillsDir2 = path.join(cacheBase, versions[versions.length - 1], "skills");
         if (fs.existsSync(skillsDir2)) collectPluginSkills(skillsDir2, name, pluginId, status, pluginSkills);
@@ -79,12 +102,23 @@ function collectPluginSkills(dir, pluginName, pluginId, status, out) {
     if (fs.statSync(entryPath).isDirectory()) {
       for (const sub of fs.readdirSync(entryPath)) {
         if (!sub.endsWith(".md")) continue;
-        const content = fs.readFileSync(path.join(entryPath, sub), "utf-8");
-        out.push({ source: "plugin", name: `${entry}:${sub.slice(0, -3)}`, plugin: pluginId, status, description: extractDescription(content) });
+        const subPath = path.join(entryPath, sub);
+        try {
+          const content = fs.readFileSync(subPath, "utf-8");
+          out.push({ source: "plugin", name: `${entry}:${sub.slice(0, -3)}`, plugin: pluginId, status, description: extractDescription(content) });
+        } catch {
+          process.stderr.write(`Warning: could not read ${subPath} \u2014 skipping
+`);
+        }
       }
     } else if (entry.endsWith(".md")) {
-      const content = fs.readFileSync(entryPath, "utf-8");
-      out.push({ source: "plugin", name: `${pluginName}:${entry.slice(0, -3)}`, plugin: pluginId, status, description: extractDescription(content) });
+      try {
+        const content = fs.readFileSync(entryPath, "utf-8");
+        out.push({ source: "plugin", name: `${pluginName}:${entry.slice(0, -3)}`, plugin: pluginId, status, description: extractDescription(content) });
+      } catch {
+        process.stderr.write(`Warning: could not read ${entryPath} \u2014 skipping
+`);
+      }
     }
   }
 }
@@ -107,6 +141,7 @@ function disableSkill(name, claudeDir = defaultClaudeDir2) {
 function enableSkill(name, claudeDir = defaultClaudeDir2) {
   const src = path2.join(disabledDir(claudeDir), `${name}.md`);
   if (!fs2.existsSync(src)) throw new Error(`Skill "${name}" is not in disabled directory`);
+  fs2.mkdirSync(skillsDir(claudeDir), { recursive: true });
   fs2.renameSync(src, path2.join(skillsDir(claudeDir), `${name}.md`));
 }
 
@@ -129,6 +164,10 @@ async function readBlocklist(claudeDir = defaultClaudeDir3) {
     if (err.code === "ENOENT") {
       return { fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), plugins: [] };
     }
+    if (err instanceof SyntaxError) {
+      process.stderr.write("Warning: blocklist.json is malformed \u2014 treating as empty\n");
+      return { fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), plugins: [] };
+    }
     throw err;
   }
 }
@@ -151,10 +190,11 @@ async function blockPlugin(pluginId, reason, claudeDir = defaultClaudeDir3) {
 async function unblockPlugin(pluginId, claudeDir = defaultClaudeDir3) {
   const blocklist = await readBlocklist(claudeDir);
   const filtered = blocklist.plugins.filter((e) => e.plugin !== pluginId);
-  if (filtered.length === blocklist.plugins.length) return;
+  if (filtered.length === blocklist.plugins.length) return false;
   blocklist.plugins = filtered;
   blocklist.fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
   await writeBlocklist(blocklist, claudeDir);
+  return true;
 }
 async function setBlockedPlugins(pluginIds, reason, claudeDir = defaultClaudeDir3) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -163,37 +203,375 @@ async function setBlockedPlugins(pluginIds, reason, claudeDir = defaultClaudeDir
   await writeBlocklist(data, claudeDir);
 }
 
-// src/profiles.ts
+// src/adapters/claude.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
-import { homedir as homedir4 } from "os";
-var defaultClaudeDir4 = path4.join(homedir4(), ".claude");
+import * as os3 from "os";
+var ClaudeAdapter = class {
+  constructor(claudeDir = path4.join(os3.homedir(), ".claude")) {
+    this.claudeDir = claudeDir;
+    this.skillsDirs = [path4.join(claudeDir, "skills")];
+  }
+  claudeDir;
+  cliName = "claude";
+  displayName = "Claude Code";
+  skillsDirs;
+  isInstalled() {
+    return fs4.existsSync(this.claudeDir);
+  }
+  scanSkills() {
+    return scanStandaloneSkills(this.claudeDir).map((s) => ({
+      name: s.name,
+      status: s.status,
+      description: s.description
+    }));
+  }
+  disableSkill(name) {
+    disableSkill(name, this.claudeDir);
+  }
+  enableSkill(name) {
+    enableSkill(name, this.claudeDir);
+  }
+};
+
+// src/adapters/gemini.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as os4 from "os";
+
+// src/adapters/helpers.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+function parseFrontmatterField(frontmatter, field) {
+  return frontmatter.match(new RegExp(`^${field}:\\s*(.+)$`, "m"))?.[1]?.trim() ?? "";
+}
+function parseSkillMd(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return { name: "", description: "" };
+  return { name: parseFrontmatterField(m[1], "name"), description: parseFrontmatterField(m[1], "description") };
+}
+function extractFirstLine(content) {
+  let inFm = false, fmClosed = false;
+  for (const line of content.split("\n")) {
+    if (!fmClosed && line.trim() === "---") {
+      inFm = !inFm;
+      if (!inFm) fmClosed = true;
+      continue;
+    }
+    if (inFm || !line.trim() || line.startsWith("#")) continue;
+    return line.trim();
+  }
+  return "";
+}
+function readDesc(filePath) {
+  try {
+    const content = fs5.readFileSync(filePath, "utf-8");
+    return parseSkillMd(content).description || extractFirstLine(content);
+  } catch {
+    return "";
+  }
+}
+function scanFlatSkills(dir, group) {
+  const skills = [];
+  const disabledDir2 = path5.join(dir, ".disabled");
+  for (const [d, status] of [[dir, "active"], [disabledDir2, "disabled"]]) {
+    if (!fs5.existsSync(d)) continue;
+    for (const file of fs5.readdirSync(d)) {
+      if (!file.endsWith(".md")) continue;
+      const fp = path5.join(d, file);
+      if (!fs5.statSync(fp).isFile()) continue;
+      skills.push({ name: file.slice(0, -3), status, description: readDesc(fp), ...group ? { group } : {} });
+    }
+  }
+  return skills;
+}
+function disableFlatSkill(name, dir) {
+  const src = path5.join(dir, `${name}.md`);
+  if (!fs5.existsSync(src)) throw new Error(`Skill "${name}" not found in ${dir}`);
+  const disDir = path5.join(dir, ".disabled");
+  fs5.mkdirSync(disDir, { recursive: true });
+  fs5.renameSync(src, path5.join(disDir, `${name}.md`));
+}
+function enableFlatSkill(name, dir) {
+  const src = path5.join(dir, ".disabled", `${name}.md`);
+  if (!fs5.existsSync(src)) throw new Error(`Skill "${name}" is not disabled`);
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.renameSync(src, path5.join(dir, `${name}.md`));
+}
+function scanDirSkills(dir, group) {
+  const skills = [];
+  const disabledDir2 = path5.join(dir, ".disabled");
+  for (const [d, status] of [[dir, "active"], [disabledDir2, "disabled"]]) {
+    if (!fs5.existsSync(d)) continue;
+    for (const entry of fs5.readdirSync(d)) {
+      if (entry === ".disabled") continue;
+      const ep = path5.join(d, entry);
+      if (!fs5.statSync(ep).isDirectory()) continue;
+      const skillMd = path5.join(ep, "SKILL.md");
+      let description = "";
+      if (fs5.existsSync(skillMd)) {
+        const content = fs5.readFileSync(skillMd, "utf-8");
+        description = parseSkillMd(content).description || extractFirstLine(content);
+      }
+      skills.push({ name: entry, status, description, ...group ? { group } : {} });
+    }
+  }
+  return skills;
+}
+function disableDirSkill(name, dir) {
+  const src = path5.join(dir, name);
+  if (!fs5.existsSync(src) || !fs5.statSync(src).isDirectory()) throw new Error(`Skill "${name}" not found in ${dir}`);
+  const disDir = path5.join(dir, ".disabled");
+  fs5.mkdirSync(disDir, { recursive: true });
+  fs5.renameSync(src, path5.join(disDir, name));
+}
+function enableDirSkill(name, dir) {
+  const src = path5.join(dir, ".disabled", name);
+  if (!fs5.existsSync(src)) throw new Error(`Skill "${name}" is not disabled`);
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.renameSync(src, path5.join(dir, name));
+}
+function findSkillDir(name, dirs, dirBased) {
+  for (const dir of dirs) {
+    const target = dirBased ? path5.join(dir, name) : path5.join(dir, `${name}.md`);
+    const disTarget = dirBased ? path5.join(dir, ".disabled", name) : path5.join(dir, ".disabled", `${name}.md`);
+    if (fs5.existsSync(target) || fs5.existsSync(disTarget)) return dir;
+  }
+  return null;
+}
+
+// src/adapters/gemini.ts
+var HOME = os4.homedir();
+var GeminiAdapter = class {
+  cliName = "gemini";
+  displayName = "Gemini CLI";
+  skillsDirs = [
+    path6.join(HOME, ".gemini", "skills"),
+    path6.join(HOME, ".agents", "skills")
+  ];
+  isInstalled() {
+    return fs6.existsSync(path6.join(HOME, ".gemini"));
+  }
+  scanSkills() {
+    const seen = /* @__PURE__ */ new Set();
+    const skills = [];
+    for (const [i, dir] of this.skillsDirs.entries()) {
+      const group = i === 0 ? void 0 : "shared";
+      for (const s of scanDirSkills(dir, group)) {
+        if (!seen.has(s.name)) {
+          seen.add(s.name);
+          skills.push(s);
+        }
+      }
+    }
+    return skills;
+  }
+  disableSkill(name) {
+    const dir = findSkillDir(name, this.skillsDirs, true);
+    if (!dir) throw new Error(`Skill "${name}" not found in Gemini skills directories`);
+    disableDirSkill(name, dir);
+  }
+  enableSkill(name) {
+    const dir = findSkillDir(name, this.skillsDirs, true);
+    if (!dir) throw new Error(`Skill "${name}" not found in Gemini skills directories`);
+    enableDirSkill(name, dir);
+  }
+};
+
+// src/adapters/codex.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+import * as os5 from "os";
+var HOME2 = os5.homedir();
+var CodexAdapter = class {
+  cliName = "codex";
+  displayName = "Codex CLI (OpenAI)";
+  skillsDirs = [
+    path7.join(HOME2, ".agents", "skills")
+  ];
+  isInstalled() {
+    return fs7.existsSync(path7.join(HOME2, ".codex"));
+  }
+  scanSkills() {
+    return scanDirSkills(this.skillsDirs[0]);
+  }
+  disableSkill(name) {
+    const dir = findSkillDir(name, this.skillsDirs, true);
+    if (!dir) throw new Error(`Skill "${name}" not found in Codex skills directory (${this.skillsDirs[0]})`);
+    disableDirSkill(name, dir);
+  }
+  enableSkill(name) {
+    const dir = findSkillDir(name, this.skillsDirs, true);
+    if (!dir) throw new Error(`Skill "${name}" not found in Codex skills directory`);
+    enableDirSkill(name, dir);
+  }
+};
+
+// src/adapters/factory.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
+import * as os6 from "os";
+var HOME3 = os6.homedir();
+var FACTORY_DIR = path8.join(HOME3, ".factory");
+var FactoryAdapter = class {
+  cliName = "droid";
+  displayName = "Factory Droid";
+  skillsDirs = [
+    path8.join(FACTORY_DIR, "droids"),
+    path8.join(FACTORY_DIR, "commands")
+  ];
+  isInstalled() {
+    return fs8.existsSync(FACTORY_DIR);
+  }
+  scanSkills() {
+    return [
+      ...scanFlatSkills(this.skillsDirs[0], "droid"),
+      ...scanFlatSkills(this.skillsDirs[1], "command")
+    ];
+  }
+  disableSkill(name) {
+    const dir = findSkillDir(name, this.skillsDirs, false);
+    if (!dir) throw new Error(`Skill "${name}" not found in Factory Droid directories`);
+    disableFlatSkill(name, dir);
+  }
+  enableSkill(name) {
+    const dir = findSkillDir(name, this.skillsDirs, false);
+    if (!dir) throw new Error(`Skill "${name}" not found in Factory Droid directories`);
+    enableFlatSkill(name, dir);
+  }
+};
+
+// src/adapters/amp.ts
+import * as fs9 from "fs";
+import * as path9 from "path";
+import * as os7 from "os";
+var HOME4 = os7.homedir();
+var AmpAdapter = class {
+  cliName = "amp";
+  displayName = "Amp (Sourcegraph)";
+  skillsDirs = [
+    path9.join(HOME4, ".config", "amp", "skills"),
+    path9.join(HOME4, ".agents", "skills")
+  ];
+  isInstalled() {
+    return fs9.existsSync(path9.join(HOME4, ".config", "amp"));
+  }
+  scanSkills() {
+    const seen = /* @__PURE__ */ new Set();
+    const skills = [];
+    for (const [i, dir] of this.skillsDirs.entries()) {
+      const group = i === 0 ? void 0 : "shared";
+      for (const s of scanDirSkills(dir, group)) {
+        if (!seen.has(s.name)) {
+          seen.add(s.name);
+          skills.push(s);
+        }
+      }
+    }
+    return skills;
+  }
+  disableSkill(name) {
+    const dir = findSkillDir(name, this.skillsDirs, true);
+    if (!dir) throw new Error(`Skill "${name}" not found in Amp skills directories`);
+    disableDirSkill(name, dir);
+  }
+  enableSkill(name) {
+    const dir = findSkillDir(name, this.skillsDirs, true);
+    if (!dir) throw new Error(`Skill "${name}" not found in Amp skills directories`);
+    enableDirSkill(name, dir);
+  }
+};
+
+// src/adapters/aider.ts
+import * as fs10 from "fs";
+import * as path10 from "path";
+import * as os8 from "os";
+var HOME5 = os8.homedir();
+var AIDER_SKILLS_DIR = path10.join(HOME5, ".aider", "skills");
+var AIDER_CONF = path10.join(HOME5, ".aider.conf.yml");
+var AiderAdapter = class {
+  cliName = "aider";
+  displayName = "Aider";
+  skillsDirs = [AIDER_SKILLS_DIR];
+  isInstalled() {
+    return fs10.existsSync(AIDER_CONF) || fs10.existsSync(path10.join(HOME5, ".aider"));
+  }
+  scanSkills() {
+    return scanFlatSkills(AIDER_SKILLS_DIR);
+  }
+  disableSkill(name) {
+    disableFlatSkill(name, AIDER_SKILLS_DIR);
+  }
+  enableSkill(name) {
+    enableFlatSkill(name, AIDER_SKILLS_DIR);
+  }
+  /** Returns the `read:` block to paste into ~/.aider.conf.yml */
+  generateAiderConfig() {
+    const active = this.scanSkills().filter((s) => s.status === "active");
+    if (!active.length) return "# No active aider skills\n";
+    return `read:
+${active.map((s) => `  - ${path10.join(AIDER_SKILLS_DIR, s.name + ".md")}`).join("\n")}
+`;
+  }
+};
+
+// src/adapters/index.ts
+import * as os9 from "os";
+import * as path11 from "path";
+var ADAPTERS = {
+  claude: (claudeDir) => new ClaudeAdapter(claudeDir ?? path11.join(os9.homedir(), ".claude")),
+  gemini: () => new GeminiAdapter(),
+  codex: () => new CodexAdapter(),
+  droid: () => new FactoryAdapter(),
+  amp: () => new AmpAdapter(),
+  aider: () => new AiderAdapter()
+};
+var CLI_NAMES = Object.keys(ADAPTERS);
+function getAdapter(cli, claudeDir) {
+  const factory = ADAPTERS[cli.toLowerCase()];
+  if (!factory) throw new Error(`Unknown CLI "${cli}". Valid options: ${CLI_NAMES.join(", ")}`);
+  return factory(claudeDir);
+}
+function getAllAdapters() {
+  return CLI_NAMES.map((name) => ADAPTERS[name]());
+}
+
+// src/profiles.ts
+import * as fs11 from "fs";
+import * as path12 from "path";
+import { homedir as homedir11 } from "os";
+var defaultClaudeDir4 = path12.join(homedir11(), ".claude");
 function profileStorePath(claudeDir) {
-  return path4.join(claudeDir, "skillctl", "profiles.json");
+  return path12.join(claudeDir, "skillctl", "profiles.json");
 }
 function readProfileStore(claudeDir = defaultClaudeDir4) {
   const filePath = profileStorePath(claudeDir);
   try {
-    const raw = fs4.readFileSync(filePath, "utf-8");
+    const raw = fs11.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     if (err.code === "ENOENT") {
-      return { active: null, profiles: {} };
+      return { active: null, previous: null, profiles: {} };
+    }
+    if (err instanceof SyntaxError) {
+      process.stderr.write("Warning: profiles.json is corrupt \u2014 resetting to empty store\n");
+      return { active: null, previous: null, profiles: {} };
     }
     throw err;
   }
 }
 function writeProfileStore(store, claudeDir) {
   const filePath = profileStorePath(claudeDir);
-  fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
+  fs11.mkdirSync(path12.dirname(filePath), { recursive: true });
   const tmp = filePath + ".tmp";
-  fs4.writeFileSync(tmp, JSON.stringify(store, null, 2));
-  fs4.renameSync(tmp, filePath);
+  fs11.writeFileSync(tmp, JSON.stringify(store, null, 2));
+  fs11.renameSync(tmp, filePath);
 }
 function saveProfile(name, skills, plugins, claudeDir = defaultClaudeDir4) {
   const store = readProfileStore(claudeDir);
   const profile = {
     created: store.profiles[name]?.created ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     skills,
     plugins
   };
@@ -207,21 +585,122 @@ function deleteProfile(name, claudeDir = defaultClaudeDir4) {
   delete store.profiles[name];
   writeProfileStore(store, claudeDir);
 }
-async function activateProfile(name, claudeDir = defaultClaudeDir4) {
+function renameProfile(oldName, newName, claudeDir = defaultClaudeDir4) {
+  const store = readProfileStore(claudeDir);
+  if (!store.profiles[oldName]) throw new Error(`Profile "${oldName}" does not exist`);
+  if (store.profiles[newName]) throw new Error(`Profile "${newName}" already exists`);
+  store.profiles[newName] = store.profiles[oldName];
+  delete store.profiles[oldName];
+  if (store.active === oldName) store.active = newName;
+  if (store.previous === oldName) store.previous = newName;
+  writeProfileStore(store, claudeDir);
+}
+function copyProfile(srcName, dstName, claudeDir = defaultClaudeDir4) {
+  const store = readProfileStore(claudeDir);
+  if (!store.profiles[srcName]) throw new Error(`Profile "${srcName}" does not exist`);
+  if (store.profiles[dstName]) throw new Error(`Profile "${dstName}" already exists`);
+  store.profiles[dstName] = {
+    ...store.profiles[srcName],
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeProfileStore(store, claudeDir);
+}
+function diffProfile(name, claudeDir = defaultClaudeDir4) {
   const store = readProfileStore(claudeDir);
   const profile = store.profiles[name];
-  if (!profile) {
-    throw new Error(`Profile "${name}" does not exist`);
+  if (!profile) throw new Error(`Profile "${name}" does not exist`);
+  const profileSkills = new Set(profile.skills);
+  const skillsDir2 = path12.join(claudeDir, "skills");
+  const disabledDir2 = path12.join(claudeDir, "skills", ".disabled");
+  const toDisable = [];
+  const toEnable = [];
+  if (fs11.existsSync(skillsDir2)) {
+    for (const file of fs11.readdirSync(skillsDir2)) {
+      if (!file.endsWith(".md") || !fs11.statSync(path12.join(skillsDir2, file)).isFile()) continue;
+      const n = file.slice(0, -3);
+      if (!profileSkills.has(n)) toDisable.push(n);
+    }
+  }
+  if (fs11.existsSync(disabledDir2)) {
+    for (const file of fs11.readdirSync(disabledDir2)) {
+      if (!file.endsWith(".md")) continue;
+      const n = file.slice(0, -3);
+      if (profileSkills.has(n)) toEnable.push(n);
+    }
   }
+  const profilePlugins = new Set(profile.plugins);
+  const toBlock = [];
+  const toUnblock = [];
+  try {
+    const raw = JSON.parse(fs11.readFileSync(path12.join(claudeDir, "plugins", "installed_plugins.json"), "utf-8"));
+    const installed = Object.keys(raw?.plugins ?? {});
+    let currentlyBlocked = /* @__PURE__ */ new Set();
+    try {
+      const blRaw = JSON.parse(fs11.readFileSync(path12.join(claudeDir, "plugins", "blocklist.json"), "utf-8"));
+      currentlyBlocked = new Set(blRaw.plugins.map((e) => e.plugin));
+    } catch {
+    }
+    for (const id of installed) {
+      if (!profilePlugins.has(id) && !currentlyBlocked.has(id)) toBlock.push(id);
+      if (profilePlugins.has(id) && currentlyBlocked.has(id)) toUnblock.push(id);
+    }
+  } catch {
+  }
+  return { toEnable, toDisable, toBlock, toUnblock };
+}
+function exportProfile(name, claudeDir = defaultClaudeDir4) {
+  const store = readProfileStore(claudeDir);
+  const profile = store.profiles[name];
+  if (!profile) throw new Error(`Profile "${name}" does not exist`);
+  return JSON.stringify({ name, ...profile }, null, 2);
+}
+function importProfile(jsonStr, claudeDir = defaultClaudeDir4) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    throw new Error("Invalid JSON in import file");
+  }
+  if (!parsed.name || !Array.isArray(parsed.skills) || !Array.isArray(parsed.plugins)) {
+    throw new Error('Import file must have "name", "skills", and "plugins" fields');
+  }
+  saveProfile(parsed.name, parsed.skills, parsed.plugins, claudeDir);
+  return parsed.name;
+}
+function validateProfile(name, claudeDir = defaultClaudeDir4) {
+  const store = readProfileStore(claudeDir);
+  const profile = store.profiles[name];
+  if (!profile) throw new Error(`Profile "${name}" does not exist`);
+  const skillsDir2 = path12.join(claudeDir, "skills");
+  const disabledDir2 = path12.join(claudeDir, "skills", ".disabled");
+  const onDisk = /* @__PURE__ */ new Set();
+  for (const dir of [skillsDir2, disabledDir2]) {
+    if (!fs11.existsSync(dir)) continue;
+    for (const file of fs11.readdirSync(dir)) {
+      if (file.endsWith(".md")) onDisk.add(file.slice(0, -3));
+    }
+  }
+  const validSkills = [];
+  const ghostSkills = [];
+  for (const skill of profile.skills) {
+    (onDisk.has(skill) ? validSkills : ghostSkills).push(skill);
+  }
+  return { validSkills, ghostSkills };
+}
+async function activateProfile(name, claudeDir = defaultClaudeDir4) {
+  const store = readProfileStore(claudeDir);
+  const profile = store.profiles[name];
+  if (!profile) throw new Error(`Profile "${name}" does not exist`);
   const profileSkills = new Set(profile.skills);
-  const skillsDir2 = path4.join(claudeDir, "skills");
-  const disabledDir2 = path4.join(claudeDir, "skills", ".disabled");
+  const skillsDir2 = path12.join(claudeDir, "skills");
+  const disabledDir2 = path12.join(claudeDir, "skills", ".disabled");
   const enabled = [];
   const disabled = [];
-  if (fs4.existsSync(skillsDir2)) {
-    for (const file of fs4.readdirSync(skillsDir2)) {
+  if (fs11.existsSync(skillsDir2)) {
+    for (const file of fs11.readdirSync(skillsDir2)) {
       if (!file.endsWith(".md")) continue;
-      const stat = fs4.statSync(path4.join(skillsDir2, file));
+      const stat = fs11.statSync(path12.join(skillsDir2, file));
       if (!stat.isFile()) continue;
       const skillName = file.slice(0, -3);
       if (!profileSkills.has(skillName)) {
@@ -230,8 +709,8 @@ async function activateProfile(name, claudeDir = defaultClaudeDir4) {
       }
     }
   }
-  if (fs4.existsSync(disabledDir2)) {
-    for (const file of fs4.readdirSync(disabledDir2)) {
+  if (fs11.existsSync(disabledDir2)) {
+    for (const file of fs11.readdirSync(disabledDir2)) {
       if (!file.endsWith(".md")) continue;
       const skillName = file.slice(0, -3);
       if (profileSkills.has(skillName)) {
@@ -241,26 +720,27 @@ async function activateProfile(name, claudeDir = defaultClaudeDir4) {
     }
   }
   const profilePlugins = new Set(profile.plugins);
-  const installedPath = path4.join(claudeDir, "plugins", "installed_plugins.json");
+  const installedPath = path12.join(claudeDir, "plugins", "installed_plugins.json");
   let pluginsBlocked = [];
   try {
-    const raw = JSON.parse(fs4.readFileSync(installedPath, "utf-8"));
+    const raw = JSON.parse(fs11.readFileSync(installedPath, "utf-8"));
     const allInstalled = Object.keys(raw?.plugins ?? {});
     pluginsBlocked = allInstalled.filter((id) => !profilePlugins.has(id));
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
   await setBlockedPlugins(pluginsBlocked, `blocked by profile: ${name}`, claudeDir);
+  store.previous = store.active;
   store.active = name;
   writeProfileStore(store, claudeDir);
   return { enabled, disabled, pluginsBlocked };
 }
 
 // src/catalog.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-import * as os3 from "os";
-var defaultClaudeDir5 = path5.join(os3.homedir(), ".claude");
+import * as fs12 from "fs";
+import * as path13 from "path";
+import * as os10 from "os";
+var defaultClaudeDir5 = path13.join(os10.homedir(), ".claude");
 function generateCatalog(claudeDir = defaultClaudeDir5) {
   const standalone = scanStandaloneSkills(claudeDir);
   const plugins = scanPlugins(claudeDir);
@@ -290,13 +770,26 @@ function generateCatalog(claudeDir = defaultClaudeDir5) {
     sections.push(`## Plugin: ${p.name} \u2014 DISABLED (${p.skills.length})`, "| Skill | Description |", "|-------|-------------|", rows(p.skills), "");
   }
   const content = sections.join("\n");
-  fs5.writeFileSync(path5.join(claudeDir, "SKILLS.md"), content);
+  fs12.writeFileSync(path13.join(claudeDir, "SKILLS.md"), content);
   return content;
 }
 
 // src/cli.ts
+process.on("unhandledRejection", (err) => {
+  process.stderr.write(`Error: ${err.message ?? err}
+`);
+  process.exit(1);
+});
+function getClaudeDir(opts) {
+  return opts["claudeDir"] ?? process.env["SKILLSWITCH_CLAUDE_DIR"] ?? defaultClaudeDir;
+}
+function validateProfileName(name) {
+  if (!name || name.trim() === "") throw new Error("Profile name cannot be empty");
+  if (name.length > 64) throw new Error("Profile name must be 64 characters or less");
+  if (/[/\\]/.test(name)) throw new Error('Profile name cannot contain "/" or "\\"');
+}
 var program = new Command();
-program.name("skillswitch").description("Manage Claude Code skills").version("0.1.0");
+program.name("skillswitch").description(`Manage AI CLI skills \u2014 Claude Code, Gemini CLI, Codex CLI, Factory Droid, Amp, Aider`).version("0.1.3").option("--claude-dir <path>", "Override the Claude config directory (default: ~/.claude)").option("--for <cli>", `Target CLI: ${CLI_NAMES.join(" | ")} (default: claude)`);
 function confirm(prompt) {
   return new Promise((resolve) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -306,25 +799,84 @@ function confirm(prompt) {
     });
   });
 }
-program.command("list").description("Show all skills grouped by source").option("--disabled", "Show only disabled skills").action((opts) => {
-  const standalone = scanStandaloneSkills();
-  const plugins = scanPlugins();
-  const ss = opts.disabled ? standalone.filter((s) => s.status === "disabled") : standalone;
+program.command("list").description("Show all skills grouped by source").option("--disabled", "Show only disabled skills").option("--enabled", "Show only enabled (active) skills").option("--json", "Output as JSON").action((opts) => {
+  const globalOpts = program.opts();
+  const cliTarget = globalOpts["for"] ?? "claude";
+  if (cliTarget !== "claude") {
+    const adapter = getAdapter(cliTarget);
+    const statusFilter2 = opts.disabled ? "disabled" : opts.enabled ? "active" : null;
+    let skills = adapter.scanSkills();
+    if (statusFilter2) skills = skills.filter((s) => s.status === statusFilter2);
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(skills, null, 2) + "\n");
+      return;
+    }
+    console.log(`
+${adapter.displayName} skills (${skills.length}):`);
+    for (const s of skills) console.log(`  ${s.name}${s.group ? ` [${s.group}]` : ""}${s.status === "disabled" ? " [disabled]" : ""}`);
+    return;
+  }
+  const claudeDir = getClaudeDir(globalOpts);
+  const standalone = scanStandaloneSkills(claudeDir);
+  const plugins = scanPlugins(claudeDir);
+  if (opts.json) {
+    const filter = opts.disabled ? "disabled" : opts.enabled ? "active" : null;
+    const ss2 = filter ? standalone.filter((s) => s.status === filter) : standalone;
+    const pp2 = filter ? plugins.filter((p) => p.status === (filter === "active" ? "active" : "disabled")) : plugins;
+    process.stdout.write(JSON.stringify({ standalone: ss2, plugins: pp2 }, null, 2) + "\n");
+    return;
+  }
+  const statusFilter = opts.disabled ? "disabled" : opts.enabled ? "active" : null;
+  const ss = statusFilter ? standalone.filter((s) => s.status === statusFilter) : standalone;
   console.log(`
 Standalone (${standalone.length} total):`);
   for (const s of ss) console.log(`  ${s.name}${s.status === "disabled" ? " [disabled]" : ""}`);
-  const pp = opts.disabled ? plugins.filter((p) => p.status === "disabled") : plugins;
-  for (const p of pp) console.log(`
+  const pp = statusFilter ? plugins.filter((p) => p.status === statusFilter) : plugins;
+  for (const p of pp) {
+    console.log(`
 ${p.id}${p.status === "disabled" ? " [DISABLED]" : ""} (${p.skills.length} skills)`);
+    for (const s of p.skills) console.log(`  ${s.name}${s.status === "disabled" ? " [disabled]" : ""}`);
+  }
 });
-program.command("search <query>").description("Search skills by name or description (substring match)").action((query) => {
+program.command("search <query>").description("Search skills by name or description (substring match)").option("--status <status>", "Filter by status: active or disabled").option("--json", "Output as JSON").action((query, opts) => {
+  const globalOpts = program.opts();
+  const cliTarget = globalOpts["for"] ?? "claude";
   const q = query.toLowerCase();
-  const standalone = scanStandaloneSkills();
-  const plugins = scanPlugins();
-  const matches = [
+  if (cliTarget !== "claude") {
+    const adapter = getAdapter(cliTarget);
+    let matches2 = adapter.scanSkills().filter((s) => s.name.includes(q) || s.description.toLowerCase().includes(q));
+    if (opts.status) matches2 = matches2.filter((s) => s.status === opts.status);
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(matches2, null, 2) + "\n");
+      return;
+    }
+    if (!matches2.length) {
+      console.log(`No ${adapter.displayName} skills matching "${query}".`);
+      return;
+    }
+    console.log(`
+${matches2.length} match(es) for "${query}" in ${adapter.displayName}:
+`);
+    for (const s of matches2) {
+      console.log(`  ${s.name} [${s.status}]${s.group ? ` (${s.group})` : ""}`);
+      if (s.description) console.log(`    ${s.description}`);
+    }
+    return;
+  }
+  const claudeDir = getClaudeDir(globalOpts);
+  const standalone = scanStandaloneSkills(claudeDir);
+  const plugins = scanPlugins(claudeDir);
+  let matches = [
     ...standalone.filter((s) => s.name.includes(q) || s.description.toLowerCase().includes(q)),
     ...plugins.flatMap((p) => p.skills).filter((s) => s.name.includes(q) || s.description.toLowerCase().includes(q))
   ];
+  if (opts.status) {
+    matches = matches.filter((s) => s.status === opts.status);
+  }
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(matches, null, 2) + "\n");
+    return;
+  }
   if (!matches.length) {
     console.log(`No skills matching "${query}".`);
     return;
@@ -337,101 +889,273 @@ ${matches.length} match(es) for "${query}":
     if (s.description) console.log(`    ${s.description}`);
   }
 });
-program.command("status").description("Show active profile and skill counts").action(() => {
-  const store = readProfileStore();
-  const standalone = scanStandaloneSkills();
-  const plugins = scanPlugins();
+program.command("status").description("Show active profile and skill counts").option("--json", "Output as JSON").action((opts) => {
+  const globalOpts = program.opts();
+  const cliTarget = globalOpts["for"] ?? "claude";
+  if (cliTarget !== "claude") {
+    const adapter = getAdapter(cliTarget);
+    const skills = adapter.scanSkills();
+    const active2 = skills.filter((s) => s.status === "active").length;
+    const disabled2 = skills.filter((s) => s.status === "disabled").length;
+    if (opts.json) {
+      process.stdout.write(JSON.stringify({ cli: adapter.displayName, active: active2, disabled: disabled2, total: active2 + disabled2 }, null, 2) + "\n");
+      return;
+    }
+    console.log(`CLI            : ${adapter.displayName}`);
+    console.log(`Enabled skills : ${active2}`);
+    console.log(`Disabled skills: ${disabled2}`);
+    console.log(`Total          : ${active2 + disabled2}`);
+    return;
+  }
+  const claudeDir = getClaudeDir(globalOpts);
+  const store = readProfileStore(claudeDir);
+  const standalone = scanStandaloneSkills(claudeDir);
+  const plugins = scanPlugins(claudeDir);
   const active = standalone.filter((s) => s.status === "active").length + plugins.filter((p) => p.status === "active").reduce((n, p) => n + p.skills.length, 0);
   const disabled = standalone.filter((s) => s.status === "disabled").length + plugins.filter((p) => p.status === "disabled").reduce((n, p) => n + p.skills.length, 0);
+  if (opts.json) {
+    process.stdout.write(JSON.stringify({ activeProfile: store.active, active, disabled, total: active + disabled }, null, 2) + "\n");
+    return;
+  }
   console.log(`Active profile : ${store.active ?? "none"}`);
   console.log(`Enabled skills : ${active}`);
   console.log(`Disabled skills: ${disabled}`);
   console.log(`Total          : ${active + disabled}`);
 });
-program.command("disable <name>").description("Disable a skill (substring match) or a plugin (--plugin)").option("--plugin", "Treat <name> as a full plugin ID (name@source)").option("--dry-run", "Preview without making changes").action(async (name, opts) => {
-  if (opts.plugin) {
-    if (opts.dryRun) {
-      console.log(`[dry-run] Would block plugin: ${name}`);
-      return;
+program.command("disable <name>").description("Disable a skill (substring match) or a plugin (--plugin)").option("--plugin", "Treat <name> as a full plugin ID (name@source)").option("--exact", "Require exact name match instead of substring match").option("--dry-run", "Preview without making changes").option("--quiet", "Suppress output except errors").action(async (name, opts) => {
+  const globalOpts = program.opts();
+  const cliTarget = globalOpts["for"] ?? "claude";
+  const log = (msg) => {
+    if (!opts.quiet) console.log(msg);
+  };
+  if (cliTarget !== "claude") {
+    try {
+      const adapter = getAdapter(cliTarget);
+      const matches = adapter.scanSkills().filter((s) => {
+        const hit = opts.exact ? s.name === name : s.name.includes(name);
+        return hit && s.status === "active";
+      });
+      if (!matches.length) {
+        console.log(`No active ${adapter.displayName} skills matching "${name}".`);
+        return;
+      }
+      if (matches.length > 1) {
+        console.log(`Matches: ${matches.map((s) => s.name).join(", ")}`);
+        if (!await confirm(`Disable all ${matches.length}? (y/N) `)) {
+          console.log("Aborted.");
+          return;
+        }
+      }
+      for (const s of matches) {
+        if (opts.dryRun) log(`[dry-run] Would disable: ${s.name}`);
+        else {
+          adapter.disableSkill(s.name);
+          log(`Disabled: ${s.name}`);
+        }
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
-    await blockPlugin(name, "skillswitch: manually disabled");
-    console.log(`Plugin blocked: ${name}`);
     return;
   }
-  const matches = scanStandaloneSkills().filter((s) => s.name.includes(name) && s.status === "active");
-  if (!matches.length) {
-    console.log(`No active skills matching "${name}".`);
-    return;
-  }
-  if (matches.length > 1) {
-    console.log(`Matches: ${matches.map((s) => s.name).join(", ")}`);
-    if (!await confirm(`Disable all ${matches.length}? (y/N) `)) {
-      console.log("Aborted.");
+  const claudeDir = getClaudeDir(globalOpts);
+  try {
+    if (opts.plugin) {
+      const plugins = scanPlugins(claudeDir);
+      const matched = plugins.filter(
+        (p) => opts.exact ? p.id === name : p.id.includes(name)
+      );
+      if (!matched.length) {
+        console.log(`No plugins matching "${name}".`);
+        return;
+      }
+      if (matched.length > 1 && !opts.exact) {
+        console.log(`Matches: ${matched.map((p) => p.id).join(", ")}`);
+        if (!await confirm(`Disable all ${matched.length} plugins? (y/N) `)) {
+          console.log("Aborted.");
+          return;
+        }
+      }
+      for (const p of matched) {
+        if (opts.dryRun) log(`[dry-run] Would block plugin: ${p.id}`);
+        else {
+          await blockPlugin(p.id, "skillswitch: manually disabled", claudeDir);
+          log(`Plugin blocked: ${p.id}`);
+        }
+      }
       return;
     }
-  }
-  for (const s of matches) {
-    if (opts.dryRun) console.log(`[dry-run] Would disable: ${s.name}`);
-    else {
-      disableSkill(s.name);
-      console.log(`Disabled: ${s.name}`);
+    const matches = scanStandaloneSkills(claudeDir).filter((s) => {
+      const hit = opts.exact ? s.name === name : s.name.includes(name);
+      return hit && s.status === "active";
+    });
+    if (!matches.length) {
+      console.log(`No active skills matching "${name}".`);
+      return;
     }
+    if (matches.length > 1) {
+      console.log(`Matches: ${matches.map((s) => s.name).join(", ")}`);
+      if (!await confirm(`Disable all ${matches.length}? (y/N) `)) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    for (const s of matches) {
+      if (opts.dryRun) log(`[dry-run] Would disable: ${s.name}`);
+      else {
+        disableSkill(s.name, claudeDir);
+        log(`Disabled: ${s.name}`);
+      }
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
   }
 });
-program.command("enable <name>").description("Enable a skill (substring match) or a plugin (--plugin)").option("--plugin", "Treat <name> as a full plugin ID (name@source)").option("--dry-run", "Preview without making changes").action(async (name, opts) => {
-  if (opts.plugin) {
-    if (opts.dryRun) {
-      console.log(`[dry-run] Would unblock plugin: ${name}`);
-      return;
+program.command("enable <name>").description("Enable a skill (substring match) or a plugin (--plugin)").option("--plugin", "Treat <name> as a full plugin ID (name@source)").option("--exact", "Require exact name match instead of substring match").option("--dry-run", "Preview without making changes").option("--quiet", "Suppress output except errors").action(async (name, opts) => {
+  const globalOpts = program.opts();
+  const cliTarget = globalOpts["for"] ?? "claude";
+  const log = (msg) => {
+    if (!opts.quiet) console.log(msg);
+  };
+  if (cliTarget !== "claude") {
+    try {
+      const adapter = getAdapter(cliTarget);
+      const matches = adapter.scanSkills().filter((s) => {
+        const hit = opts.exact ? s.name === name : s.name.includes(name);
+        return hit && s.status === "disabled";
+      });
+      if (!matches.length) {
+        console.log(`No disabled ${adapter.displayName} skills matching "${name}".`);
+        return;
+      }
+      if (matches.length > 1) {
+        console.log(`Matches: ${matches.map((s) => s.name).join(", ")}`);
+        if (!await confirm(`Enable all ${matches.length}? (y/N) `)) {
+          console.log("Aborted.");
+          return;
+        }
+      }
+      for (const s of matches) {
+        if (opts.dryRun) log(`[dry-run] Would enable: ${s.name}`);
+        else {
+          adapter.enableSkill(s.name);
+          log(`Enabled: ${s.name}`);
+        }
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
-    await unblockPlugin(name);
-    console.log(`Plugin unblocked: ${name}`);
     return;
   }
-  const matches = scanStandaloneSkills().filter((s) => s.name.includes(name) && s.status === "disabled");
-  if (!matches.length) {
-    console.log(`No disabled skills matching "${name}".`);
-    return;
-  }
-  if (matches.length > 1) {
-    console.log(`Matches: ${matches.map((s) => s.name).join(", ")}`);
-    if (!await confirm(`Enable all ${matches.length}? (y/N) `)) {
-      console.log("Aborted.");
+  const claudeDir = getClaudeDir(globalOpts);
+  try {
+    if (opts.plugin) {
+      const plugins = scanPlugins(claudeDir);
+      const matched = plugins.filter(
+        (p) => opts.exact ? p.id === name : p.id.includes(name)
+      );
+      if (!matched.length) {
+        console.log(`No plugins matching "${name}".`);
+        return;
+      }
+      for (const p of matched) {
+        if (opts.dryRun) {
+          log(`[dry-run] Would unblock plugin: ${p.id}`);
+          continue;
+        }
+        const wasBlocked = await unblockPlugin(p.id, claudeDir);
+        log(wasBlocked ? `Plugin unblocked: ${p.id}` : `Plugin was not blocked: ${p.id}`);
+      }
       return;
     }
-  }
-  for (const s of matches) {
-    if (opts.dryRun) console.log(`[dry-run] Would enable: ${s.name}`);
-    else {
-      enableSkill(s.name);
-      console.log(`Enabled: ${s.name}`);
+    const matches = scanStandaloneSkills(claudeDir).filter((s) => {
+      const hit = opts.exact ? s.name === name : s.name.includes(name);
+      return hit && s.status === "disabled";
+    });
+    if (!matches.length) {
+      console.log(`No disabled skills matching "${name}".`);
+      return;
+    }
+    if (matches.length > 1) {
+      console.log(`Matches: ${matches.map((s) => s.name).join(", ")}`);
+      if (!await confirm(`Enable all ${matches.length}? (y/N) `)) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    for (const s of matches) {
+      if (opts.dryRun) log(`[dry-run] Would enable: ${s.name}`);
+      else {
+        enableSkill(s.name, claudeDir);
+        log(`Enabled: ${s.name}`);
+      }
     }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
   }
 });
 var profileCmd = program.command("profile").description("Manage skill profiles");
 profileCmd.command("create <name>").description("Snapshot current enabled skills as a named profile").action((name) => {
-  const skills = scanStandaloneSkills().filter((s) => s.status === "active").map((s) => s.name);
-  const plugins = scanPlugins().filter((p) => p.status === "active").map((p) => p.id);
-  saveProfile(name, skills, plugins);
-  console.log(`Profile "${name}" saved: ${skills.length} skills, ${plugins.length} plugins.`);
+  try {
+    const claudeDir = getClaudeDir(program.opts());
+    validateProfileName(name);
+    const skills = scanStandaloneSkills(claudeDir).filter((s) => s.status === "active").map((s) => s.name);
+    const plugins = scanPlugins(claudeDir).filter((p) => p.status === "active").map((p) => p.id);
+    const store = readProfileStore(claudeDir);
+    if (store.profiles[name]) console.log(`Overwriting existing profile "${name}".`);
+    if (!skills.length && !plugins.length) console.warn(`Warning: no active skills or plugins found \u2014 profile may be empty by mistake.`);
+    saveProfile(name, skills, plugins, claudeDir);
+    console.log(`Profile "${name}" saved: ${skills.length} skills, ${plugins.length} plugins.`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
 });
-profileCmd.command("use <name>").description("Activate a profile").option("--dry-run", "Preview without making changes").action(async (name, opts) => {
-  if (opts.dryRun) {
-    const store = readProfileStore();
-    const p = store.profiles[name];
-    if (!p) {
-      console.log(`Profile "${name}" not found.`);
+profileCmd.command("use <name>").description("Activate a profile").option("--dry-run", "Preview without making changes").option("--quiet", "Suppress output except errors").action(async (name, opts) => {
+  const claudeDir = getClaudeDir(program.opts());
+  try {
+    if (opts.dryRun) {
+      const store = readProfileStore(claudeDir);
+      const p = store.profiles[name];
+      if (!p) {
+        console.log(`Profile "${name}" not found.`);
+        return;
+      }
+      const diff = diffProfile(name, claudeDir);
+      console.log(`[dry-run] Activating "${name}":`);
+      if (diff.toEnable.length) console.log(`  Enable  : ${diff.toEnable.join(", ")}`);
+      if (diff.toDisable.length) console.log(`  Disable : ${diff.toDisable.join(", ")}`);
+      if (diff.toBlock.length) console.log(`  Block   : ${diff.toBlock.join(", ")}`);
+      if (diff.toUnblock.length) console.log(`  Unblock : ${diff.toUnblock.join(", ")}`);
+      if (!diff.toEnable.length && !diff.toDisable.length && !diff.toBlock.length && !diff.toUnblock.length) {
+        console.log("  (no changes)");
+      }
       return;
     }
-    console.log(`[dry-run] Would activate "${name}": ${p.skills.length} skills, ${p.plugins.length} plugins.`);
-    return;
+    const result = await activateProfile(name, claudeDir);
+    if (!opts.quiet) {
+      console.log(`Activated "${name}".`);
+      if (result.enabled.length) console.log(`  Enabled : ${result.enabled.join(", ")}`);
+      if (result.disabled.length) console.log(`  Disabled: ${result.disabled.join(", ")}`);
+      if (result.pluginsBlocked.length) console.log(`  Blocked : ${result.pluginsBlocked.join(", ")}`);
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
   }
-  const result = await activateProfile(name);
-  console.log(`Activated "${name}": ${result.disabled.length} disabled, ${result.enabled.length} enabled, ${result.pluginsBlocked.length} plugins blocked.`);
 });
-profileCmd.command("list").description("List saved profiles").action(() => {
-  const store = readProfileStore();
+profileCmd.command("list").description("List saved profiles").option("--json", "Output as JSON").action((opts) => {
+  const claudeDir = getClaudeDir(program.opts());
+  const store = readProfileStore(claudeDir);
   const names = Object.keys(store.profiles);
+  if (opts.json) {
+    process.stdout.write(JSON.stringify({ active: store.active, previous: store.previous, profiles: store.profiles }, null, 2) + "\n");
+    return;
+  }
   if (!names.length) {
     console.log("No profiles saved.");
     return;
@@ -443,33 +1167,148 @@ profileCmd.command("list").description("List saved profiles").action(() => {
   }
 });
 profileCmd.command("show <name>").description("Show skills in a profile").action((name) => {
-  const store = readProfileStore();
+  const claudeDir = getClaudeDir(program.opts());
+  const store = readProfileStore(claudeDir);
   const p = store.profiles[name];
   if (!p) {
     console.log(`Profile "${name}" not found.`);
     return;
   }
-  console.log(`Profile "${name}" (${p.created.slice(0, 10)}):`);
+  console.log(`Profile "${name}" (created ${p.created.slice(0, 10)}):`);
   console.log(`  Skills  (${p.skills.length}): ${p.skills.join(", ") || "none"}`);
   console.log(`  Plugins (${p.plugins.length}): ${p.plugins.join(", ") || "none"}`);
 });
-profileCmd.command("delete <name>").description("Delete a saved profile").action((name) => {
+profileCmd.command("delete <name>").description("Delete a saved profile").option("--force", "Delete even if this is the active profile").action((name, opts) => {
   try {
-    deleteProfile(name);
+    const claudeDir = getClaudeDir(program.opts());
+    if (opts.force) {
+      const store = readProfileStore(claudeDir);
+      if (store.active === name) {
+        store.active = null;
+        if (!store.profiles[name]) {
+          console.log(`Profile "${name}" not found.`);
+          return;
+        }
+        delete store.profiles[name];
+        const storeFile = claudeDir + "/skillctl/profiles.json";
+        const { mkdirSync: mkdirSync4, writeFileSync: writeFileSync4, renameSync: renameSync4 } = fs13;
+        const dir = storeFile.replace(/\/[^/]+$/, "");
+        mkdirSync4(dir, { recursive: true });
+        writeFileSync4(storeFile + ".tmp", JSON.stringify(store, null, 2));
+        renameSync4(storeFile + ".tmp", storeFile);
+        console.log(`Profile "${name}" deleted.`);
+        return;
+      }
+    }
+    deleteProfile(name, claudeDir);
     console.log(`Profile "${name}" deleted.`);
-  } catch (e) {
-    console.error(e.message);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+profileCmd.command("rename <old> <new>").description("Rename a profile").action((oldName, newName) => {
+  try {
+    const claudeDir = getClaudeDir(program.opts());
+    validateProfileName(newName);
+    renameProfile(oldName, newName, claudeDir);
+    console.log(`Profile "${oldName}" renamed to "${newName}".`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
     process.exit(1);
   }
 });
-program.command("catalog").description("Generate ~/.claude/SKILLS.md catalog").action(() => {
-  generateCatalog();
-  console.log("Catalog written to ~/.claude/SKILLS.md");
-  console.log("Tip: use @~/.claude/SKILLS.md in any Claude session to reference it.");
+profileCmd.command("copy <src> <dst>").description("Copy a profile to a new name").action((srcName, dstName) => {
+  try {
+    const claudeDir = getClaudeDir(program.opts());
+    validateProfileName(dstName);
+    copyProfile(srcName, dstName, claudeDir);
+    console.log(`Profile "${srcName}" copied to "${dstName}".`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
 });
-program.command("audit").description("Report duplicates, disabled skill counts, and plugin orphans").action(() => {
-  const standalone = scanStandaloneSkills();
-  const plugins = scanPlugins();
+profileCmd.command("diff <name>").description("Show what would change when activating a profile").action((name) => {
+  try {
+    const claudeDir = getClaudeDir(program.opts());
+    const diff = diffProfile(name, claudeDir);
+    if (!diff.toEnable.length && !diff.toDisable.length && !diff.toBlock.length && !diff.toUnblock.length) {
+      console.log(`Profile "${name}" matches current state \u2014 no changes needed.`);
+      return;
+    }
+    console.log(`Diff for profile "${name}":`);
+    if (diff.toEnable.length) console.log(`  Enable  (+): ${diff.toEnable.join(", ")}`);
+    if (diff.toDisable.length) console.log(`  Disable (-): ${diff.toDisable.join(", ")}`);
+    if (diff.toBlock.length) console.log(`  Block   (-): ${diff.toBlock.join(", ")}`);
+    if (diff.toUnblock.length) console.log(`  Unblock (+): ${diff.toUnblock.join(", ")}`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+});
+profileCmd.command("export <name>").description("Export a profile to stdout or a file").option("--out <file>", "Write to file instead of stdout").action((name, opts) => {
+  try {
+    const claudeDir = getClaudeDir(program.opts());
+    const json = exportProfile(name, claudeDir);
+    if (opts.out) {
+      fs13.writeFileSync(opts.out, json);
+      console.log(`Profile "${name}" exported to ${opts.out}`);
+    } else {
+      process.stdout.write(json + "\n");
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+});
+profileCmd.command("import <file>").description("Import a profile from a JSON file").action((file) => {
+  try {
+    const claudeDir = getClaudeDir(program.opts());
+    const json = fs13.readFileSync(file, "utf-8");
+    const name = importProfile(json, claudeDir);
+    console.log(`Profile "${name}" imported.`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+});
+profileCmd.command("validate <name>").description("Check a profile for ghost skills (no longer on disk)").action((name) => {
+  try {
+    const claudeDir = getClaudeDir(program.opts());
+    const result = validateProfile(name, claudeDir);
+    if (!result.ghostSkills.length) {
+      console.log(`Profile "${name}" is valid \u2014 all ${result.validSkills.length} skills found on disk.`);
+      return;
+    }
+    console.log(`Profile "${name}" has ${result.ghostSkills.length} ghost skill(s):`);
+    result.ghostSkills.forEach((s) => console.log(`  ${s} (not found on disk)`));
+    if (result.validSkills.length) console.log(`${result.validSkills.length} skill(s) OK: ${result.validSkills.join(", ")}`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("catalog").description("Generate ~/.claude/SKILLS.md catalog").option("--out <path>", "Write to custom path instead of ~/.claude/SKILLS.md").action((opts) => {
+  try {
+    const claudeDir = getClaudeDir(program.opts());
+    const content = generateCatalog(claudeDir);
+    if (opts.out) {
+      fs13.writeFileSync(opts.out, content);
+      console.log(`Catalog written to ${opts.out}`);
+    } else {
+      console.log("Catalog written to ~/.claude/SKILLS.md");
+      console.log("Tip: use @~/.claude/SKILLS.md in any Claude session to reference it.");
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("audit").description("Report duplicates, disabled skill counts, and plugin orphans").option("--json", "Output as JSON").action((opts) => {
+  const claudeDir = getClaudeDir(program.opts());
+  const standalone = scanStandaloneSkills(claudeDir);
+  const plugins = scanPlugins(claudeDir);
   const standaloneNames = new Set(standalone.map((s) => s.name));
   const pluginBaseNames = plugins.flatMap((p) => p.skills.map((s) => {
     const parts = s.name.split(":");
@@ -478,6 +1317,10 @@ program.command("audit").description("Report duplicates, disabled skill counts,
   const duplicates = [...standaloneNames].filter((n) => pluginBaseNames.includes(n));
   const disabledStandalone = standalone.filter((s) => s.status === "disabled");
   const disabledPlugins = plugins.filter((p) => p.status === "disabled");
+  if (opts.json) {
+    process.stdout.write(JSON.stringify({ duplicates, disabledStandalone: disabledStandalone.map((s) => s.name), disabledPlugins: disabledPlugins.map((p) => p.id) }, null, 2) + "\n");
+    return;
+  }
   let found = false;
   if (duplicates.length) {
     found = true;
@@ -499,4 +1342,20 @@ Blocked plugins (${disabledPlugins.length}):`);
   }
   if (!found) console.log("No issues found.");
 });
+program.command("detect").description("Show which supported AI CLIs are installed").option("--json", "Output as JSON").action((opts) => {
+  const adapters = getAllAdapters();
+  const results = adapters.map((a) => ({ cli: a.cliName, name: a.displayName, installed: a.isInstalled() }));
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(results, null, 2) + "\n");
+    return;
+  }
+  console.log("\nDetected CLIs:");
+  for (const r of results) {
+    console.log(`  ${r.name.padEnd(20)} ${r.installed ? "installed" : "not found"}`);
+  }
+});
+program.command("aider-config").description("Print the read: block to paste into ~/.aider.conf.yml for active Aider skills").action(() => {
+  const adapter = new AiderAdapter();
+  process.stdout.write(adapter.generateAiderConfig());
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillswitch",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Manage Claude Code skills — profiles, disable/enable, catalog generation",
   "type": "module",
   "bin": {