a11y-devkit-deploy 0.9.0 → 0.9.2

package/README.md

@@ -22,6 +22,7 @@ a11y-devkit-deploy
 
 - `--local` / `--global`: Skip the scope prompt.
 - `--yes`: Use defaults (local scope, all IDEs, install skills).
+- `--uninstall`: Remove skills and MCP entries installed by this tool.
 
 ## After Installation
 

package/config/a11y.json

@@ -161,10 +161,15 @@
         "a11y-remediator-skill",
         "web-standards-skill",
         "a11y-audit-fix-agent-orchestrator-skill",
-        "a11y-validator-skill",
-        "playwright"
+        "a11y-validator-skill"
       ],
-      "mcpServers": ["wcag", "aria", "magentaa11y", "a11y-personas"]
+      "mcpServers": [
+        "wcag",
+        "aria",
+        "magentaa11y",
+        "a11y-personas",
+        "playwright"
+      ]
     },
     {
       "id": "developer-ios",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "a11y-devkit-deploy",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "CLI to deploy a11y skills and MCP servers across IDEs",
   "license": "MIT",
   "type": "module",

package/src/cli.js

@@ -25,8 +25,8 @@ import prompts from "prompts";
 
 import { header, info, warn, success, startSpinner, formatPath } from "./ui.js";
 import { getPlatform, getHostApplicationPaths, getTempDir, getMcpRepoDir } from "./paths.js";
-import { installSkillsFromNpm, cleanupTemp } from "./installers/skills.js";
-import { installMcpConfig } from "./installers/mcp.js";
+import { installSkillsFromNpm, uninstallSkillsFromTargets, cleanupTemp } from "./installers/skills.js";
+import { installMcpConfig, removeMcpConfig } from "./installers/mcp.js";
 import { getGitMcpPrompts, parseArgsString } from "./prompts/git-mcp.js";
 import { installGitMcp } from "./installers/git-mcp.js";
 
@@ -55,6 +55,7 @@ function parseArgs(argv) {
         ? "local"
         : null,
     gitMcp: args.has("--git-mcp"),
+    uninstall: args.has("--uninstall"),
   };
 }
 
@@ -80,10 +81,22 @@ async function run() {
     `A11y Devkit Deploy v${pkg.version}`,
     args.gitMcp
       ? "Install MCP server from Git repository"
-      : "Install skills + MCP servers across host applications",
+      : args.uninstall
+        ? "Uninstall skills + MCP servers installed by this tool"
+        : "Install skills + MCP servers across host applications",
   );
   info(`Detected OS: ${formatOs(platformInfo)}`);
 
+  if (args.uninstall && args.gitMcp) {
+    warn("--uninstall cannot be used with --git-mcp.");
+    process.exit(1);
+  }
+
+  if (args.uninstall) {
+    await runUninstall(projectRoot, platformInfo, config, hostPaths, args);
+    return;
+  }
+
   // Branch to Git MCP installation flow
   if (args.gitMcp) {
     await runGitMcpInstallation(projectRoot, platformInfo, config, hostPaths, args);
@@ -340,6 +353,191 @@ async function run() {
   info("Documentation: https://github.com/joe-watkins/a11y-devkit#readme");
 }
 
+async function runUninstall(projectRoot, platformInfo, config, hostPaths, args) {
+  console.log("\n");
+  info("Removing skills and MCP servers installed by this tool");
+  console.log("");
+
+  let removeSkills = true;
+  let removeMcp = true;
+  let scope = args.scope;
+  let mcpScope = null;
+  let hostSelection = config.hostApplications.map((host) => host.id);
+
+  if (!args.autoYes) {
+    const removeResponse = await prompts(
+      {
+        type: "multiselect",
+        name: "targets",
+        message: "Remove which items?",
+        choices: [
+          { title: "Skills", value: "skills" },
+          { title: "MCP servers", value: "mcp" },
+        ],
+        initial: [0, 1],
+      },
+      {
+        onCancel: () => {
+          warn("Uninstall cancelled.");
+          process.exit(0);
+        },
+      },
+    );
+
+    const selectedTargets = removeResponse.targets || [];
+    removeSkills = selectedTargets.includes("skills");
+    removeMcp = selectedTargets.includes("mcp");
+
+    if (!removeSkills && !removeMcp) {
+      warn("No items selected to uninstall.");
+      process.exit(0);
+    }
+  }
+
+  if (!args.autoYes) {
+    const hostChoices = config.hostApplications.map((host) => ({
+      title: host.displayName,
+      value: host.id,
+    }));
+
+    const questions = [];
+
+    if (removeSkills && !scope) {
+      questions.push({
+        type: "select",
+        name: "scope",
+        message: "Remove skills locally or globally?",
+        choices: [
+          {
+            title: `Local to this project (${formatPath(projectRoot)}) [recommended]`,
+            value: "local",
+          },
+          { title: "Global for this user", value: "global" },
+        ],
+        initial: 0,
+      });
+    }
+
+    if (removeMcp) {
+      questions.push({
+        type: "select",
+        name: "mcpScope",
+        message: "Remove MCP configs locally or globally?",
+        choices: [
+          {
+            title: `Local to this project (${formatPath(projectRoot)})`,
+            value: "local",
+            description:
+              "Remove from project-level host application config folders (version-controllable)",
+          },
+          {
+            title: "Global for this user",
+            value: "global",
+            description: "Remove from user-level host application config folders",
+          },
+        ],
+        initial: 0,
+      });
+    }
+
+    questions.push({
+      type: "multiselect",
+      name: "hosts",
+      message: "Remove from which host applications?",
+      choices: hostChoices,
+      initial: hostChoices.map((_, index) => index),
+    });
+
+    const response = await prompts(questions, {
+      onCancel: () => {
+        warn("Uninstall cancelled.");
+        process.exit(0);
+      },
+    });
+
+    scope = scope || response.scope;
+    mcpScope = response.mcpScope || mcpScope;
+    hostSelection = response.hosts || hostSelection;
+  }
+
+  if (removeSkills && !scope) {
+    scope = "local";
+  }
+
+  if (removeMcp && !mcpScope) {
+    mcpScope = "local";
+  }
+
+  if (!hostSelection.length) {
+    warn("No host applications selected. Uninstall requires at least one host application.");
+    process.exit(1);
+  }
+
+  if (removeSkills) {
+    info(`Skills scope: ${scope === "local" ? "Local" : "Global"}`);
+  }
+  if (removeMcp) {
+    info(`MCP scope: ${mcpScope === "local" ? "Local" : "Global"}`);
+  }
+
+  if (removeSkills) {
+    const skillsSpinner = startSpinner("Removing skills...");
+    try {
+      const skillTargets =
+        scope === "local"
+          ? hostSelection.map((host) => hostPaths[host].localSkillsDir)
+          : hostSelection.map((host) => hostPaths[host].skillsDir);
+
+      const skillNames = config.skills.map((skill) =>
+        typeof skill === "string" ? skill : skill.npmName,
+      );
+
+      const result = await uninstallSkillsFromTargets(
+        skillNames,
+        skillTargets,
+        config.skillsFolder,
+        config.readmeTemplate,
+      );
+      skillsSpinner.succeed(
+        `Removed ${result.removed} skill folder(s) from ${skillTargets.length} host application location(s).`,
+      );
+    } catch (error) {
+      skillsSpinner.fail(`Failed to remove skills: ${error.message}`);
+    }
+  }
+
+  if (removeMcp) {
+    const mcpSpinner = startSpinner("Removing MCP configurations...");
+    const mcpConfigPaths =
+      mcpScope === "local"
+        ? hostSelection.map((host) => hostPaths[host].localMcpConfig)
+        : hostSelection.map((host) => hostPaths[host].mcpConfig);
+
+    let removedCount = 0;
+    const serverNames = config.mcpServers.map((server) => server.name);
+
+    for (let i = 0; i < hostSelection.length; i++) {
+      const host = hostSelection[i];
+      const result = await removeMcpConfig(
+        mcpConfigPaths[i],
+        serverNames,
+        hostPaths[host].mcpServerKey,
+      );
+      removedCount += result.removed;
+    }
+
+    if (removedCount > 0) {
+      mcpSpinner.succeed(
+        `Removed ${removedCount} MCP entries from ${hostSelection.length} host application(s) (${mcpScope} scope).`,
+      );
+    } else {
+      mcpSpinner.succeed("No matching MCP entries found to remove.");
+    }
+  }
+
+  success("Uninstall complete.");
+}
+
 async function runGitMcpInstallation(projectRoot, platformInfo, config, hostPaths, args) {
   // Check if --yes flag is used with --git-mcp
   if (args.autoYes) {

package/src/installers/mcp.js

@@ -49,6 +49,39 @@ function mergeServers(existing, incoming, serverKey = "servers") {
   return merged;
 }
 
+function removeServers(existing, removeNames, serverKey = "servers") {
+  const existingServers = existing[serverKey] && typeof existing[serverKey] === "object"
+    ? existing[serverKey]
+    : null;
+
+  if (!existingServers) {
+    return { updated: existing, removed: 0 };
+  }
+
+  const updatedServers = { ...existingServers };
+  let removed = 0;
+
+  for (const name of removeNames) {
+    if (Object.prototype.hasOwnProperty.call(updatedServers, name)) {
+      delete updatedServers[name];
+      removed++;
+    }
+  }
+
+  if (removed === 0) {
+    return { updated: existing, removed: 0 };
+  }
+
+  const updated = { ...existing };
+  if (Object.keys(updatedServers).length === 0) {
+    delete updated[serverKey];
+  } else {
+    updated[serverKey] = updatedServers;
+  }
+
+  return { updated, removed };
+}
+
 async function installMcpConfig(configPath, servers, serverKey = "servers") {
   await fs.mkdir(path.dirname(configPath), { recursive: true });
   const existing = await loadJson(configPath);
@@ -56,6 +89,23 @@ async function installMcpConfig(configPath, servers, serverKey = "servers") {
   await fs.writeFile(configPath, `${JSON.stringify(updated, null, 2)}\n`, "utf8");
 }
 
+async function removeMcpConfig(configPath, serverNames, serverKey = "servers") {
+  if (!(await pathExists(configPath))) {
+    return { removed: 0, changed: false };
+  }
+
+  const existing = await loadJson(configPath);
+  const { updated, removed } = removeServers(existing, serverNames, serverKey);
+
+  if (removed === 0) {
+    return { removed: 0, changed: false };
+  }
+
+  await fs.writeFile(configPath, `${JSON.stringify(updated, null, 2)}\n`, "utf8");
+  return { removed, changed: true };
+}
+
 export {
-  installMcpConfig
+  installMcpConfig,
+  removeMcpConfig
 };

package/src/installers/skills.js

@@ -15,6 +15,10 @@ async function pathExists(target) {
   }
 }
 
+function getSkillDirName(skillPackageName) {
+  return skillPackageName.replace(/-skill$/, "");
+}
+
 function run(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
@@ -53,6 +57,17 @@ async function cleanupTemp(tempDir) {
   }
 }
 
+async function removeDirIfEmpty(targetDir) {
+  if (!(await pathExists(targetDir))) {
+    return;
+  }
+
+  const entries = await fs.readdir(targetDir);
+  if (entries.length === 0) {
+    await fs.rmdir(targetDir);
+  }
+}
+
 /**
  * Install skills from npm packages into IDE skills directories.
  *
@@ -116,7 +131,7 @@ async function installSkillsFromNpm(
 
       if (await pathExists(skillMdPath)) {
         // Create skill directory in target (use package name without -skill suffix)
-        const skillDirName = skill.replace(/-skill$/, "");
+        const skillDirName = getSkillDirName(skill);
         const targetSkillDir = path.join(skillsDir, skillDirName);
         await fs.mkdir(targetSkillDir, { recursive: true });
 
@@ -146,4 +161,49 @@ async function installSkillsFromNpm(
   };
 }
 
-export { installSkillsFromNpm, cleanupTemp };
+/**
+ * Remove skills installed by this tool from target directories.
+ *
+ * @param {string[]} skills - Array of npm package names
+ * @param {string[]} targetDirs - Array of target directories to uninstall from
+ * @param {string} skillsFolder - Optional subfolder name used for bundled skills
+ * @param {string} readmeTemplate - README template filename from templates folder
+ * @returns {Promise<{removed: number}>}
+ */
+async function uninstallSkillsFromTargets(
+  skills,
+  targetDirs,
+  skillsFolder = null,
+  readmeTemplate = "deploy-README.md",
+) {
+  let removedCount = 0;
+
+  for (const targetDir of targetDirs) {
+    const skillsDir = skillsFolder
+      ? path.join(targetDir, skillsFolder)
+      : targetDir;
+
+    for (const skill of skills) {
+      const skillDirName = getSkillDirName(skill);
+      const targetSkillDir = path.join(skillsDir, skillDirName);
+
+      if (await pathExists(targetSkillDir)) {
+        await fs.rm(targetSkillDir, { recursive: true, force: true });
+        removedCount++;
+      }
+    }
+
+    const readmePath = path.join(skillsDir, "a11y-devkit-README.md");
+    if (await pathExists(readmePath)) {
+      await fs.rm(readmePath, { force: true });
+    }
+
+    if (skillsFolder) {
+      await removeDirIfEmpty(skillsDir);
+    }
+  }
+
+  return { removed: removedCount };
+}
+
+export { installSkillsFromNpm, uninstallSkillsFromTargets, cleanupTemp };