agents-inc 0.153.0 → 0.154.0

package/dist/commands/uninstall.js

@@ -5,28 +5,31 @@ import {
 import {
   promptConfirm
 } from "../chunk-OJJLYHM3.js";
-import "../chunk-F7Z5I6GU.js";
-import "../chunk-REKOWTIB.js";
-import "../chunk-NXGMM5YN.js";
+import "../chunk-XMEIVWAS.js";
+import "../chunk-ZU6DAR4S.js";
+import "../chunk-UW44KSYL.js";
 import {
   loadAgentDefs
-} from "../chunk-FRWKCE6R.js";
+} from "../chunk-PRJD5MMQ.js";
 import {
   listAgentMdFiles
-} from "../chunk-FIHTAFST.js";
+} from "../chunk-TUQF577Z.js";
 import "../chunk-JFLVEFFP.js";
 import {
   BaseCommand,
   EXIT_CODES
-} from "../chunk-X5XJ6WKO.js";
-import "../chunk-TY6CAOL7.js";
+} from "../chunk-FMYHWKGG.js";
+import "../chunk-7VZV4O6B.js";
 import "../chunk-K3O3YQYG.js";
 import {
   ConfigLoadError,
   INFO_MESSAGES,
   SUCCESS_MESSAGES,
+  UNINSTALL_PLAN,
   buildMarketplacePluginRef,
   claudePluginUninstallBestEffort,
+  compiledAgentsKept,
+  compiledAgentsRemoval,
   getProjectPluginsDir,
   isClaudeCLIAvailable,
   isHomeDirectory,
@@ -34,6 +37,7 @@ import {
   listPluginNames,
   loadProjectConfigFromDir,
   loadSkillsMatrixFromSource,
+  localSkillsRemoval,
   mutateGlobal,
   parseMarketplacePluginRef,
   propagateGlobalRemoval,
@@ -43,15 +47,16 @@ import {
   registeredProjectsUpdated,
   resolveInstallPaths,
   toClaudePluginScope
-} from "../chunk-NXQAY5U7.js";
+} from "../chunk-CBF4ZYV3.js";
 import {
   directoryExists,
   fileExists,
   getErrorMessage,
   listDirectories,
-  remove
-} from "../chunk-U2YSGBHA.js";
-import "../chunk-35VOK7XE.js";
+  remove,
+  removeDirIfEmpty
+} from "../chunk-4VCWL2IG.js";
+import "../chunk-IPJOMAWC.js";
 import "../chunk-VASLW636.js";
 import {
   CLAUDE_DIR,
@@ -67,39 +72,104 @@ import "../chunk-VZRO7RYT.js";
 import "react";
 import { partition } from "remeda";
 import path from "path";
-import { readdir } from "fs/promises";
 import { Flags } from "@oclif/core";
 import { Box, Text, useApp } from "ink";
 import { jsx, jsxs } from "react/jsx-runtime";
 function buildRemovalPlan(target) {
-  const sections = [];
-  if (target.hasPlugins) {
-    sections.push({ label: "Plugins:", items: [...target.cliPluginNames] });
-  }
-  if (target.hasLocalSkills || target.hasLocalAgents) {
-    const items = [];
-    if (target.hasLocalSkills) items.push(`${target.skillsDir}/ (matching sources)`);
-    if (target.hasLocalAgents) items.push(`${target.agentsDir}/ (CLI-compiled)`);
-    sections.push({ label: "CLI-managed files:", items });
-  }
-  if (target.hasClaudeSrcConfig || target.hasClaudeSrcConfigTypes) {
-    const items = [];
-    if (target.hasClaudeSrcConfig) {
-      items.push(`${target.claudeSrcDir}/${STANDARD_FILES.CONFIG_TS}`);
-    }
-    if (target.hasClaudeSrcConfigTypes) {
-      items.push(`${target.claudeSrcDir}/${STANDARD_FILES.CONFIG_TYPES_TS}`);
+  const agents = compiledAgentsEntry(target);
+  return {
+    entries: [
+      ...pluginsEntry(target),
+      ...localSkillsEntry(target),
+      ...agents,
+      ...configManifestEntry(target)
+    ],
+    kept: keptStatements(target, agents)
+  };
+}
+function hasAnythingToRemove(plan) {
+  return plan.entries.length > 0;
+}
+function pluginsEntry(target) {
+  if (!target.hasPlugins) return [];
+  return [{ kind: "plugins", pluginsDir: target.pluginsDir, names: [...target.cliPluginNames] }];
+}
+function localSkillsEntry(target) {
+  if (!target.hasLocalSkills) return [];
+  return [{ kind: "skills", skillsDir: target.skillsDir }];
+}
+function compiledAgentsEntry(target) {
+  if (!target.hasLocalAgents) return [];
+  if (target.configuredAgents.length === 0) return [];
+  return [{ kind: "agents", agentsDir: target.agentsDir, agentNames: target.configuredAgents }];
+}
+function configManifestEntry(target) {
+  const fileNames = [
+    ...target.hasClaudeSrcConfig ? [STANDARD_FILES.CONFIG_TS] : [],
+    ...target.hasClaudeSrcConfigTypes ? [STANDARD_FILES.CONFIG_TYPES_TS] : []
+  ];
+  if (fileNames.length === 0) return [];
+  return [{ kind: "config", claudeSrcDir: target.claudeSrcDir, fileNames }];
+}
+function keptStatements(target, agentRemovals) {
+  if (!target.hasLocalAgents) return [];
+  if (agentRemovals.length > 0) return [];
+  return [compiledAgentsKept(target.agentsDir)];
+}
+function planEntry(plan, kind) {
+  return plan.entries.find(
+    (entry) => entry.kind === kind
+  );
+}
+function describeEntry(entry) {
+  switch (entry.kind) {
+    case "plugins":
+      return { label: UNINSTALL_PLAN.PLUGINS_HEADING, items: entry.names };
+    case "skills":
+      return {
+        label: UNINSTALL_PLAN.CLI_MANAGED_FILES_HEADING,
+        items: [localSkillsRemoval(entry.skillsDir)]
+      };
+    case "agents":
+      return {
+        label: UNINSTALL_PLAN.CLI_MANAGED_FILES_HEADING,
+        items: [compiledAgentsRemoval(entry.agentsDir)]
+      };
+    case "config":
+      return {
+        label: UNINSTALL_PLAN.CONFIG_HEADING,
+        items: entry.fileNames.map((fileName) => `${entry.claudeSrcDir}/${fileName}`)
+      };
+    default: {
+      const _exhaustive = entry;
+      return _exhaustive;
     }
-    sections.push({ label: "Config:", items });
   }
-  return sections;
 }
-var UninstallConfirm = ({ target, onConfirm, onCancel }) => {
+var PLAN_SECTION_ORDER = [
+  UNINSTALL_PLAN.PLUGINS_HEADING,
+  UNINSTALL_PLAN.CLI_MANAGED_FILES_HEADING,
+  UNINSTALL_PLAN.CONFIG_HEADING
+];
+function planSections(entries) {
+  const described = entries.map(describeEntry);
+  return PLAN_SECTION_ORDER.flatMap(
+    (label) => sectionWithItems(label, itemsUnder(described, label))
+  );
+}
+function itemsUnder(described, label) {
+  return described.filter((section) => section.label === label).flatMap((section) => section.items);
+}
+function sectionWithItems(label, items) {
+  if (items.length === 0) return [];
+  return [{ label, items }];
+}
+var UninstallConfirm = ({ plan, onConfirm, onCancel }) => {
   const { exit } = useApp();
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx(Text, { bold: true, children: "The following will be removed:" }),
+    /* @__PURE__ */ jsx(Text, { bold: true, children: UNINSTALL_PLAN.PREVIEW_HEADING }),
     /* @__PURE__ */ jsx(Text, { children: " " }),
-    buildRemovalPlan(target).map((section) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    planSections(plan.entries).map((section) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
       /* @__PURE__ */ jsxs(Text, { color: CLI_COLORS.ERROR, children: [
         " ",
         section.label
@@ -109,6 +179,10 @@ var UninstallConfirm = ({ target, onConfirm, onCancel }) => {
         item
       ] }, item))
     ] }, section.label)),
+    plan.kept.map((statement) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: statement })
+    ] }, statement)),
     /* @__PURE__ */ jsx(Text, { children: " " }),
     /* @__PURE__ */ jsx(
       Confirm,
@@ -151,17 +225,18 @@ var Uninstall = class _Uninstall extends BaseCommand {
         `Could not read the project config \u2014 plugins and compiled agents it lists may be left behind: ${reason}`
       )
     );
-    if (!hasAnythingToRemove(target)) {
+    const plan = buildRemovalPlan(target);
+    if (!hasAnythingToRemove(plan)) {
       this.reportNothingToUninstall();
       return;
     }
-    const confirmed = flags.yes ? this.printRemovalPlan(target) : await this.confirmRemoval(target);
+    const confirmed = flags.yes ? this.printRemovalPlan(plan) : await this.confirmRemoval(plan);
     if (!confirmed) {
       this.log("");
       this.log("Uninstall cancelled");
       this.exit(EXIT_CODES.CANCELLED);
     }
-    await this.executeUninstall(target, projectDir);
+    await this.executeUninstall(plan, target, projectDir);
     this.reportSuccess();
   }
   printHeader() {
@@ -176,45 +251,32 @@ var Uninstall = class _Uninstall extends BaseCommand {
     this.log("");
     this.log(INFO_MESSAGES.NO_CHANGES_MADE);
   }
-  printRemovalPlan(target) {
-    this.log("The following will be removed:");
+  printRemovalPlan(plan) {
+    this.log(UNINSTALL_PLAN.PREVIEW_HEADING);
     this.log("");
-    for (const section of buildRemovalPlan(target)) {
+    for (const section of planSections(plan.entries)) {
       this.log(`  ${section.label}`);
       for (const item of section.items) {
         this.log(`    ${item}`);
       }
     }
+    for (const statement of plan.kept) {
+      this.log("");
+      this.log(statement);
+    }
     this.log("");
     return true;
   }
-  async confirmRemoval(target) {
-    const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx(UninstallConfirm, { target, onConfirm, onCancel }));
+  async confirmRemoval(plan) {
+    const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx(UninstallConfirm, { plan, onConfirm, onCancel }));
     return outcome === "confirmed";
   }
-  async executeUninstall(target, projectDir) {
+  async executeUninstall(plan, target, projectDir) {
     const isGlobalUninstall = isHomeDirectory(projectDir);
     const propagation = isGlobalUninstall ? await this.prepareGlobalPropagation(target, projectDir) : null;
-    if (target.hasPlugins) {
-      this.log("Uninstalling plugins...");
-      try {
-        const pluginResult = await uninstallPlugins(
-          target,
-          projectDir,
-          (name) => this.log(`  Uninstalled plugin '${name}'`)
-        );
-        this.logSuccess(
-          `Uninstalled ${pluginResult.totalUninstalled} ${pluginResult.totalUninstalled === 1 ? "plugin" : "plugins"}`
-        );
-      } catch (error) {
-        this.log("Plugin uninstall failed");
-        this.error(getErrorMessage(error), {
-          exit: EXIT_CODES.ERROR
-        });
-      }
-    }
+    await this.removePlannedPlugins(planEntry(plan, "plugins"), target.config, projectDir);
     try {
-      await this.removeLocalFiles(target);
+      await this.removeLocalFiles(plan, target);
     } catch (error) {
       this.log("Failed to remove local files");
       this.error(getErrorMessage(error), {
@@ -299,27 +361,14 @@ var Uninstall = class _Uninstall extends BaseCommand {
     this.logSuccess(SUCCESS_MESSAGES.UNINSTALL_COMPLETE);
     this.log("");
   }
-  async removeLocalFiles(target) {
-    const skillResult = await removeMatchingSkills(
-      target,
-      (dirName) => this.log(`  Uninstalled skill '${dirName}'`),
-      (dirName) => this.warn(`Skipping '${dirName}': not created by ${DEFAULT_BRANDING.NAME} CLI`)
-    );
-    if (skillResult.removedCount > 0) {
-      this.logSuccess(
-        `Removed ${skillResult.removedCount} CLI-installed ${skillResult.removedCount === 1 ? "skill" : "skills"}`
-      );
-    }
-    const agentResult = await removeMatchingAgents(
-      target,
-      (agentName) => this.log(`  Uninstalled agent '${agentName}'`)
-    );
-    if (agentResult.removedCount > 0) {
-      this.logSuccess(
-        `Removed ${agentResult.removedCount} compiled ${agentResult.removedCount === 1 ? "agent" : "agents"}`
-      );
-    }
-    const cleanup = await cleanupEmptyDirs(target);
+  /**
+   * Each step acts only when the plan carries its entry, so what the user was shown and
+   * what this run removes are the same list read twice.
+   */
+  async removeLocalFiles(plan, target) {
+    await this.removePlannedSkills(planEntry(plan, "skills"));
+    await this.removePlannedAgents(planEntry(plan, "agents"));
+    const cleanup = await cleanupEmptyDirs(target, planEntry(plan, "config"));
     if (cleanup.claudeSrcDirRemoved) {
       this.logSuccess(`Removed ${CLAUDE_SRC_DIR}/`);
     } else if (cleanup.claudeSrcManifestRemoved) {
@@ -331,10 +380,50 @@ var Uninstall = class _Uninstall extends BaseCommand {
       this.log(`Kept ${CLAUDE_DIR}/ (contains user content)`);
     }
   }
+  async removePlannedPlugins(entry, config, projectDir) {
+    if (!entry) return;
+    this.log("Uninstalling plugins...");
+    try {
+      const pluginResult = await uninstallPlugins(
+        entry,
+        config,
+        projectDir,
+        (name) => this.log(`  Uninstalled plugin '${name}'`)
+      );
+      this.logSuccess(
+        `Uninstalled ${pluginResult.totalUninstalled} ${pluginResult.totalUninstalled === 1 ? "plugin" : "plugins"}`
+      );
+    } catch (error) {
+      this.log("Plugin uninstall failed");
+      this.error(getErrorMessage(error), {
+        exit: EXIT_CODES.ERROR
+      });
+    }
+  }
+  async removePlannedSkills(entry) {
+    if (!entry) return;
+    const result = await removeMatchingSkills(
+      entry,
+      (dirName) => this.log(`  Uninstalled skill '${dirName}'`),
+      (dirName) => this.warn(`Skipping '${dirName}': not created by ${DEFAULT_BRANDING.NAME} CLI`)
+    );
+    if (result.removedCount === 0) return;
+    this.logSuccess(
+      `Removed ${result.removedCount} CLI-installed ${result.removedCount === 1 ? "skill" : "skills"}`
+    );
+  }
+  async removePlannedAgents(entry) {
+    if (!entry) return;
+    const result = await removeMatchingAgents(
+      entry,
+      (agentName) => this.log(`  Uninstalled agent '${agentName}'`)
+    );
+    if (result.removedCount === 0) return;
+    this.logSuccess(
+      `Removed ${result.removedCount} compiled ${result.removedCount === 1 ? "agent" : "agents"}`
+    );
+  }
 };
-function hasAnythingToRemove(target) {
-  return target.hasPlugins || target.hasLocalSkills || target.hasLocalAgents || target.hasClaudeSrcConfig || target.hasClaudeSrcConfigTypes;
-}
 function collectConfiguredAgents(config) {
   if (!config?.agents) return [];
   return config.agents.map((a) => a.name);
@@ -418,24 +507,15 @@ async function detectUninstallTarget(projectDir, onConfigLoadFailed) {
 function shouldRemoveSkill(forkedFrom) {
   return forkedFrom !== null;
 }
-async function removeMatchingSkills(target, onRemoved, onSkipped) {
-  if (!target.hasLocalSkills) {
-    return {
-      removedCount: 0,
-      skippedCount: 0,
-      removedNames: [],
-      skippedNames: [],
-      dirCleaned: false
-    };
-  }
-  const classified = await classifySkillDirs(target.skillsDir);
+async function removeMatchingSkills(entry, onRemoved, onSkipped) {
+  const classified = await classifySkillDirs(entry.skillsDir);
   const removedNames = await removeClassifiedSkills(
     classified.toRemove,
-    target.skillsDir,
+    entry.skillsDir,
     onRemoved
   );
   classified.toSkip.forEach((name) => onSkipped?.(name));
-  const dirCleaned = await cleanupSkillsDir(target.skillsDir, classified.toSkip.length === 0);
+  const dirCleaned = await cleanupSkillsDir(entry.skillsDir, classified.toSkip.length === 0);
   return {
     removedCount: removedNames.length,
     skippedCount: classified.toSkip.length,
@@ -466,68 +546,47 @@ async function cleanupSkillsDir(dir, allRemoved) {
   if (!allRemoved) return false;
   return removeDirIfEmpty(dir);
 }
-async function removeDirIfEmpty(dir) {
-  if (!await directoryExists(dir)) return false;
-  if (!await isDirectoryEmpty(dir)) return false;
-  await remove(dir);
-  return true;
-}
-async function removeMatchingAgents(target, onRemoved) {
-  if (!target.hasLocalAgents) {
-    return { removedCount: 0, removedNames: [], dirCleaned: false };
-  }
-  if (target.configuredAgents.length === 0) {
-    return { removedCount: 0, removedNames: [], dirCleaned: false };
-  }
-  const agentFiles = await listAgentFiles(target.agentsDir);
-  const removedNames = agentFiles.map((agentFile) => agentFile.replace(/\.md$/, "")).filter((agentName) => target.configuredAgents.includes(agentName));
+async function removeMatchingAgents(entry, onRemoved) {
+  const agentFiles = await listAgentFiles(entry.agentsDir);
+  const removedNames = agentFiles.map((agentFile) => agentFile.replace(/\.md$/, "")).filter((agentName) => entry.agentNames.includes(agentName));
   for (const agentName of removedNames) {
-    await remove(path.join(target.agentsDir, `${agentName}.md`));
+    await remove(path.join(entry.agentsDir, `${agentName}.md`));
     onRemoved?.(agentName);
   }
-  const dirCleaned = await removeDirIfEmpty(target.agentsDir);
+  const dirCleaned = await removeDirIfEmpty(entry.agentsDir);
   return {
     removedCount: removedNames.length,
     removedNames,
     dirCleaned
   };
 }
-async function uninstallPlugins(target, projectDir, onUninstalled) {
-  if (!target.hasPlugins) {
-    return { uninstalledNames: [], totalUninstalled: 0 };
-  }
+async function uninstallPlugins(entry, config, projectDir, onUninstalled) {
   const cliAvailable = await isClaudeCLIAvailable();
-  for (const pluginName of target.cliPluginNames) {
+  for (const pluginName of entry.names) {
     if (cliAvailable) {
       const skillId = parseMarketplacePluginRef(pluginName);
-      const skillConfig = target.config?.skills.find((s) => s.id === skillId);
+      const skillConfig = config?.skills.find((s) => s.id === skillId);
       const primaryScope = toClaudePluginScope(skillConfig?.scope);
       await claudePluginUninstallBestEffort(pluginName, primaryScope, projectDir);
     }
-    const pluginPath = path.join(target.pluginsDir, pluginName);
+    const pluginPath = path.join(entry.pluginsDir, pluginName);
     await remove(pluginPath);
     onUninstalled?.(pluginName);
   }
   return {
-    uninstalledNames: target.cliPluginNames,
-    totalUninstalled: target.cliPluginNames.length
+    uninstalledNames: entry.names,
+    totalUninstalled: entry.names.length
   };
 }
-async function removeConfigManifest(target) {
-  let manifestRemoved = false;
-  if (target.hasClaudeSrcConfig) {
-    await remove(path.join(target.claudeSrcDir, STANDARD_FILES.CONFIG_TS));
-    manifestRemoved = true;
-  }
-  if (target.hasClaudeSrcConfigTypes) {
-    await remove(path.join(target.claudeSrcDir, STANDARD_FILES.CONFIG_TYPES_TS));
-    manifestRemoved = true;
-  }
-  const dirRemoved = manifestRemoved && await removeDirIfEmpty(target.claudeSrcDir);
-  return { manifestRemoved, dirRemoved };
+async function removeConfigManifest(entry) {
+  if (!entry) return { manifestRemoved: false, dirRemoved: false };
+  await Promise.all(
+    entry.fileNames.map((fileName) => remove(path.join(entry.claudeSrcDir, fileName)))
+  );
+  return { manifestRemoved: true, dirRemoved: await removeDirIfEmpty(entry.claudeSrcDir) };
 }
-async function cleanupEmptyDirs(target) {
-  const manifest = await removeConfigManifest(target);
+async function cleanupEmptyDirs(target, manifestEntry) {
+  const manifest = await removeConfigManifest(manifestEntry);
   const claudeDirRemoved = target.hasClaudeDir && await removeDirIfEmpty(target.claudeDir);
   const claudeDirKept = !claudeDirRemoved && target.hasClaudeDir && await directoryExists(target.claudeDir);
   return {
@@ -537,14 +596,6 @@ async function cleanupEmptyDirs(target) {
     claudeDirKept
   };
 }
-async function isDirectoryEmpty(dirPath) {
-  try {
-    const allEntries = await readdir(dirPath);
-    return allEntries.length === 0;
-  } catch {
-    return true;
-  }
-}
 async function listAgentFiles(agentsDir) {
   try {
     return await listAgentMdFiles(agentsDir);