agents-inc 0.171.0 → 0.173.0

package/dist/commands/uninstall.js

@@ -1,59 +1,62 @@
 #!/usr/bin/env node
 import {
-  RemovalPlanConfirm
-} from "../chunk-5FM77WKW.js";
+  Confirm
+} from "../chunk-OZXAJNLA.js";
 import {
   promptConfirm
 } from "../chunk-P6CYS4JK.js";
-import "../chunk-OZXAJNLA.js";
+import {
+  summaryPanelBlock
+} from "../chunk-Q6WRR4BN.js";
+import "../chunk-N33AKFLR.js";
 import {
   lazyGateDeps,
   mutateGlobal,
   propagateGlobalRemoval
-} from "../chunk-S2SKVJT2.js";
-import "../chunk-EOKNEGRD.js";
+} from "../chunk-VSPC74SS.js";
+import "../chunk-VR6QTK5Z.js";
 import {
   loadAgentDefs
-} from "../chunk-7IVLVEHX.js";
-import "../chunk-WII6GOPM.js";
+} from "../chunk-ITQF35UQ.js";
+import "../chunk-BRZA7ZCX.js";
 import {
   listAgentFilesOf,
   splitAgentsByProvenance
-} from "../chunk-AWWCRL5A.js";
+} from "../chunk-EHJIQDXR.js";
 import "../chunk-KIK5EZYD.js";
+import "../chunk-G7NUK3BF.js";
 import {
   providerFlag,
   providerNamedBy,
   refuseAnAmbiguousInstallation
-} from "../chunk-W4KAY26P.js";
+} from "../chunk-2RTBSLSR.js";
 import {
   BaseCommand,
   EXIT_CODES
-} from "../chunk-QIR56IDM.js";
+} from "../chunk-LJQXQTFC.js";
 import {
   ConfigLoadError,
   INFO_MESSAGES,
   SUCCESS_MESSAGES,
-  UNINSTALL_PLAN,
   agentCodec,
   buildMarketplacePluginRef,
-  compiledAgentsRemoval,
+  configFileRemoved,
   directoryExists,
   fileExists,
   getErrorMessage,
   getProjectPluginsDir,
   hostAt,
+  isAgentName,
   isHomeDirectory,
   listDirectories,
   listPluginNames,
   loadProjectConfigAt,
   loadSkillsMatrixFromSource,
-  localSkillsRemoval,
   notInstalledHere,
   parseMarketplacePluginRef,
   pluginLeftRegistered,
   providerInUse,
-  readForkedFromMetadata,
+  readLocalSkillMetadata,
   registeredProjectUpdateSkipped,
   registeredProjectsUpdateFailed,
   registeredProjectsUpdated,
@@ -66,21 +69,22 @@ import {
   uninstallNeedsTerminal,
   uninstallSkillMetadataUnreadable,
   unmarkedAgentsKept
-} from "../chunk-3YYHL76L.js";
+} from "../chunk-WVFBBZEP.js";
 import {
   plural
-} from "../chunk-24OD7IP4.js";
+} from "../chunk-7OG635DK.js";
 import {
   CLAUDE_DIR,
   DEFAULT_BRANDING,
   EJECT_SOURCE,
-  STANDARD_FILES
-} from "../chunk-A6OWEJGC.js";
+  STANDARD_FILES,
+  isActiveAt
+} from "../chunk-MHAQWMNJ.js";
 import "../chunk-GHHJYNAN.js";
 
 // src/cli/commands/uninstall.tsx
 import "react";
-import { unique } from "remeda";
+import { unique, uniqueBy } from "remeda";
 import path from "path";
 import { Flags } from "@oclif/core";
 import { jsx } from "react/jsx-runtime";
@@ -96,16 +100,73 @@ function buildRemovalPlan(target) {
     kept: keptStatements(target, agents)
   };
 }
+function removalPanel(plan, target) {
+  const kept = target.scope === "project" ? globalEntriesOf(target.config) : NOTHING_KEPT;
+  return {
+    skillConfigs: kept.skills,
+    agentConfigs: kept.agents,
+    installedSkillConfigs: [...removedSkills(plan, target), ...kept.skills],
+    installedAgentConfigs: [...namedAgentRemovals(plan, target.scope).named, ...kept.agents],
+    isInitMode: false,
+    skillNames: namesTheCopiesRecord(target.cliSkills),
+    stackName: void 0
+  };
+}
+function namesTheCopiesRecord(cliSkills) {
+  return new Map(
+    cliSkills.flatMap(
+      ({ skillId, displayName }) => displayName === void 0 ? [] : [[skillId, displayName]]
+    )
+  );
+}
+var NOTHING_KEPT = { skills: [], agents: [] };
+function globalEntriesOf(config) {
+  if (config === null) return NOTHING_KEPT;
+  return {
+    skills: config.skills.filter((skill) => isActiveAt(skill, "global")),
+    agents: config.agents.filter((agent) => isActiveAt(agent, "global"))
+  };
+}
+function removedSkills(plan, target) {
+  const copied = new Set(planEntries(plan, "skills").flatMap((entry) => entry.skillNames));
+  const plugins = new Set(planEntries(plan, "plugins").flatMap((entry) => entry.names));
+  const marketplaceName = target.config?.marketplaceName;
+  const copies = target.cliSkills.filter(({ dirName }) => copied.has(dirName)).map(({ skillId }) => ({ id: skillId, scope: target.scope, origin: EJECT_SOURCE }));
+  const pluginSkills = (target.config?.skills ?? []).filter((skill) => !skill.excluded).filter((skill) => pluginRefsOf(skill, marketplaceName).some((ref) => plugins.has(ref))).map((skill) => ({ ...skill, scope: target.scope }));
+  return uniqueBy([...copies, ...pluginSkills], (skill) => skill.id);
+}
+function namedAgentRemovals(plan, scope) {
+  const entries = planEntries(plan, "agents");
+  const names = entries.flatMap((entry) => entry.agentNames);
+  return {
+    named: names.filter(isAgentName).map((name) => ({ name, scope })),
+    files: entries.flatMap(
+      (entry) => entry.agentNames.filter((name) => !isAgentName(name)).map((name) => path.join(entry.agentsDir, `${name}${entry.codec.extension}`))
+    )
+  };
+}
 function hasAnythingToRemove(plan) {
   return plan.entries.length > 0;
 }
+function removedFileLines(plan, scope) {
+  const configFiles = planEntries(plan, "config").flatMap(
+    (entry) => entry.fileNames.map((fileName) => `${entry.sourceDir}/${fileName}`)
+  );
+  return [...namedAgentRemovals(plan, scope).files, ...configFiles].map(configFileRemoved);
+}
 function pluginsEntry(target) {
   if (!target.hasPlugins) return [];
   return [{ kind: "plugins", pluginsDir: target.pluginsDir, names: [...target.cliPluginNames] }];
 }
 function localSkillsEntry(target) {
   if (target.cliSkills.length === 0) return [];
-  return [{ kind: "skills", skillsDir: target.skillsDir, skillNames: [...target.cliSkills] }];
+  return [
+    {
+      kind: "skills",
+      skillsDir: target.skillsDir,
+      skillNames: target.cliSkills.map(({ dirName }) => dirName)
+    }
+  ];
 }
 function compiledAgentsEntry(target) {
   const agentNames = identifiableAgents(target);
@@ -138,49 +199,6 @@ function planEntry(plan, kind) {
     (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.sourceDir}/${fileName}`)
-      };
-    default: {
-      const _exhaustive = entry;
-      return _exhaustive;
-    }
-  }
-}
-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 UNINSTALL_CONFIRM_MESSAGE = "Are you sure you want to uninstall?";
 var Uninstall = class _Uninstall extends BaseCommand {
   /** Replaced in `run` before anything prints. */
@@ -223,7 +241,7 @@ var Uninstall = class _Uninstall extends BaseCommand {
       this.reportNothingToUninstall();
       return;
     }
-    const approved = await this.removalApproved(plan, flags.yes, namedProvider);
+    const approved = await this.removalApproved(plan, target, flags.yes, namedProvider);
     if (!approved) this.cancelUninstall();
     await this.executeUninstall(plan, target, projectDir);
     this.reportSuccess();
@@ -240,9 +258,10 @@ var Uninstall = class _Uninstall extends BaseCommand {
     this.log("");
     this.log(INFO_MESSAGES.NO_CHANGES_MADE);
   }
-  async removalApproved(plan, skipConfirmation, namedProvider) {
-    if (!skipConfirmation) return this.confirmRemoval(plan, namedProvider);
-    this.printRemovalPlan(plan);
+  /** With `--yes` nothing is asked, so the plan prints where the question would be. */
+  async removalApproved(plan, target, skipConfirmation, namedProvider) {
+    if (!skipConfirmation) return this.confirmRemoval(plan, target, namedProvider);
+    this.showRemovalPlan(plan, target);
     return true;
   }
   cancelUninstall() {
@@ -250,36 +269,22 @@ var Uninstall = class _Uninstall extends BaseCommand {
     this.log("Uninstall cancelled");
     this.exit(EXIT_CODES.CANCELLED);
   }
-  printRemovalPlan(plan) {
-    this.log(UNINSTALL_PLAN.PREVIEW_HEADING);
-    this.log("");
-    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);
+  showRemovalPlan(plan, target) {
+    const lines = summaryPanelBlock(
+      removalPanel(plan, target),
+      removedFileLines(plan, target.scope),
+      plan.kept
+    );
+    for (const line of lines) {
+      this.log(line);
     }
-    this.log("");
   }
-  async confirmRemoval(plan, namedProvider) {
+  async confirmRemoval(plan, target, namedProvider) {
     if (!process.stdin.isTTY) {
       this.error(uninstallNeedsTerminal(namedProvider), { exit: EXIT_CODES.ERROR });
     }
-    const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx(
-      RemovalPlanConfirm,
-      {
-        heading: UNINSTALL_PLAN.PREVIEW_HEADING,
-        sections: planSections(plan.entries),
-        statements: plan.kept,
-        message: UNINSTALL_CONFIRM_MESSAGE,
-        onConfirm,
-        onCancel
-      }
-    ));
+    this.showRemovalPlan(plan, target);
+    const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx(Confirm, { message: UNINSTALL_CONFIRM_MESSAGE, onConfirm, onCancel }));
     return outcome === "confirmed";
   }
   async executeUninstall(plan, target, projectDir) {
@@ -288,15 +293,18 @@ var Uninstall = class _Uninstall extends BaseCommand {
     await this.removePlannedPlugins(planEntry(plan, "plugins"), target.config, projectDir);
     await this.removeLocalFilesOrFail(plan, target);
     if (!isGlobalUninstall) {
-      await this.deregisterProject(projectDir);
+      await this.deregisterProject(projectDir, target.provider);
       return;
     }
     if (propagation) await this.updateRegisteredProjects(propagation);
   }
   /** Degrades: a missing or corrupt global config must never fail the uninstall. */
-  async deregisterProject(projectDir) {
+  async deregisterProject(projectDir, provider) {
     try {
-      await mutateGlobal({ kind: "deregister-project", projectDir }, lazyGateDeps(projectDir));
+      await mutateGlobal(
+        { kind: "deregister-project", projectDir, provider },
+        lazyGateDeps(projectDir)
+      );
     } catch (error) {
       this.warn(`Could not update the global project registry: ${getErrorMessage(error)}`);
     }
@@ -380,22 +388,27 @@ var Uninstall = class _Uninstall extends BaseCommand {
     this.reportDirCleanup(target.sourceRoot.relName, cleanup.sourceRoot);
     this.reportDirCleanup(CLAUDE_DIR, cleanup.claudeDir);
   }
-  reportSourceFolderCleanup(folder) {
-    if (folder.dirRemoved) {
-      this.logSuccess(`Removed ${folder.relName}/`);
-    } else if (folder.manifestRemoved) {
-      this.logSuccess(`Removed CLI config from ${folder.relName}/`);
-    } else if (folder.kept) {
-      this.log(`Kept ${folder.relName}/ (contains user content)`);
+  reportSourceFolderCleanup({ relName, outcome }) {
+    if (outcome === "config-removed") {
+      this.logSuccess(`Removed CLI config from ${relName}/`);
+      return;
     }
+    this.reportDirCleanup(relName, outcome);
   }
   reportDirCleanup(relName, cleanup) {
-    if (cleanup.removed) {
-      this.logSuccess(`Removed ${relName}/`);
-      return;
-    }
-    if (cleanup.kept) {
-      this.log(`Kept ${relName}/ (contains user content)`);
+    switch (cleanup) {
+      case "removed":
+        this.logSuccess(`Removed ${relName}/`);
+        return;
+      case "kept":
+        this.log(`Kept ${relName}/ (contains user content)`);
+        return;
+      case "untouched":
+        return;
+      default: {
+        const _exhaustive = cleanup;
+        return _exhaustive;
+      }
     }
   }
   async removePlannedPlugins(entry, config, projectDir) {
@@ -508,6 +521,8 @@ async function detectUninstallTarget(projectDir, handlers) {
   const activeConfig = config === null ? null : activeConfigOf(config);
   const cliPluginNames = await pluginsThisRunRemoves(projectDir, activeConfig);
   return {
+    scope: isHomeDirectory(projectDir) ? "global" : "project",
+    provider,
     hasPlugins: cliPluginNames.length > 0,
     cliPluginNames,
     cliSkills,
@@ -539,17 +554,22 @@ function thisRunOwnsAnyPlugin(projectDir) {
 async function skillsThisCliInstalled(skillsDir, onMetadataUnreadable) {
   const dirNames = await listDirectories(skillsDir);
   const skills = await Promise.all(
-    dirNames.map(async (name) => ({
-      name,
-      forkedFrom: await readSkillProvenance(skillsDir, name, onMetadataUnreadable)
+    dirNames.map(async (dirName) => ({
+      dirName,
+      metadata: await readCopyMetadata(skillsDir, dirName, onMetadataUnreadable)
     }))
   );
-  return skills.filter((skill) => skill.forkedFrom !== null).map((skill) => skill.name);
+  return skills.flatMap(
+    ({ dirName, metadata }) => metadata?.forkedFrom === void 0 ? [] : [{ dirName, skillId: metadata.forkedFrom.skillId, displayName: recordedName(metadata) }]
+  );
 }
-async function readSkillProvenance(skillsDir, dirName, onUnreadable) {
+function recordedName(metadata) {
+  return typeof metadata.displayName === "string" ? metadata.displayName : void 0;
+}
+async function readCopyMetadata(skillsDir, dirName, onUnreadable) {
   const skillDir = path.join(skillsDir, dirName);
   try {
-    return await readForkedFromMetadata(skillDir);
+    return await readLocalSkillMetadata(skillDir);
   } catch {
     return onUnreadable(path.join(skillDir, STANDARD_FILES.METADATA_YAML));
   }
@@ -619,11 +639,11 @@ function nothingWasObserved() {
   return "absent";
 }
 async function removeConfigManifest(entry) {
-  if (!entry) return { manifestRemoved: false, dirRemoved: false };
+  if (!entry) return false;
   await Promise.all(
     entry.fileNames.map((fileName) => remove(path.join(entry.sourceDir, fileName)))
   );
-  return { manifestRemoved: true, dirRemoved: await removeDirIfEmpty(entry.sourceDir) };
+  return true;
 }
 async function cleanupEmptyDirs(target, manifestEntries) {
   await removeDirIfEmpty(target.skillsDir);
@@ -632,32 +652,27 @@ async function cleanupEmptyDirs(target, manifestEntries) {
     target.sourceFolder,
     manifestEntries.find((entry) => entry.sourceDir === target.sourceFolder.dir)
   );
-  const sourceRoot = await cleanupSourceRoot(target.sourceRoot, sourceFolder.dirRemoved);
+  const sourceRoot = await cleanupSourceRoot(target.sourceRoot, sourceFolder.outcome === "removed");
   const claudeDir = await cleanupClaudeDir(target);
   return { sourceFolder, sourceRoot, claudeDir };
 }
 async function cleanupSourceFolder(folder, entry) {
-  const manifest = await removeConfigManifest(entry);
-  const dirRemoved = manifest.dirRemoved || await removeDirIfEmpty(folder.dir);
-  const kept = !dirRemoved && await directoryExists(folder.dir);
-  return {
-    relName: folder.relName,
-    manifestRemoved: manifest.manifestRemoved,
-    dirRemoved,
-    kept
-  };
+  const manifestRemoved = await removeConfigManifest(entry);
+  const dir = await removeDirUnlessUserContent(folder.dir);
+  const outcome = manifestRemoved && dir !== "removed" ? "config-removed" : dir;
+  return { relName: folder.relName, outcome };
 }
 async function cleanupSourceRoot(sourceRoot, providerDirRemoved) {
-  if (!providerDirRemoved) return { removed: false, kept: false };
+  if (!providerDirRemoved) return "untouched";
   return removeDirUnlessUserContent(sourceRoot.dir);
 }
 async function cleanupClaudeDir(target) {
-  if (!target.hasClaudeDir) return { removed: false, kept: false };
+  if (!target.hasClaudeDir) return "untouched";
   return removeDirUnlessUserContent(target.claudeDir);
 }
 async function removeDirUnlessUserContent(dir) {
-  const removed = await removeDirIfEmpty(dir);
-  return { removed, kept: !removed && await directoryExists(dir) };
+  if (await removeDirIfEmpty(dir)) return "removed";
+  return await directoryExists(dir) ? "kept" : "untouched";
 }
 async function listAgentFiles(agentsDir, codec) {
   try {