@curdx/flow 2.0.19 → 2.0.20

package/cli/uninstall.js

@@ -12,17 +12,27 @@ import {
   resultLastLine,
   resultOutput,
   confirm,
-  multiSelect,
-  claudeVersion,
   listPlugins,
 } from "./utils.js";
-import { removeGlobalProtocols, GLOBAL_CLAUDE_MD } from "./protocols.js";
 import { REQUIRED_PLUGINS, RECOMMENDED_PLUGINS, BUNDLED_MCPS } from "./registry.js";
 import {
   removeMcp,
   removePluginMarketplace,
   uninstallPlugin,
 } from "./lib/claude-ops.js";
+import {
+  createUninstallContext,
+  ensureClaudeCliAvailableForUninstall,
+  getInstalledTargets,
+  getManagedMarketplaceIds,
+  printUninstallSummary,
+  removeProtocolsStep,
+  selectRecommendedPluginsToRemove,
+  shouldKeepBundledMcps,
+  shouldKeepRequiredPlugins,
+  UNINSTALL_STEP_COUNT,
+  confirmUninstallStep,
+} from "./uninstall-workflow.js";
 
 const HOME = homedir();
 
@@ -36,45 +46,30 @@ const MANAGED_SYMLINKS = [
 ];
 
 export async function uninstall(args = []) {
-  const yes = args.includes("--yes") || args.includes("-y");
-  const purge = args.includes("--purge");
-  const keepRecommended = args.includes("--keep-recommended");
+  const context = createUninstallContext(args);
 
   log.title("🗑️  CurdX-Flow Uninstaller");
 
-  const cv = claudeVersion();
-  if (!cv) {
-    log.err("claude CLI not found, cannot uninstall plugin.");
-    process.exit(1);
-  }
+  ensureClaudeCliAvailableForUninstall();
 
-  if (!(await confirmUninstall({ yes }))) {
-    log.info("Cancelled");
+  if (!(await confirmUninstallStep(context))) {
     return;
   }
 
   await uninstallCurdxFlowPlugin();
-  await maybeUninstallRecommendedPlugins({ yes, keepRecommended });
-  await maybeRemoveBundledMcps({ yes, keepRecommended });
-  await maybeUninstallRequiredPlugins({ yes });
-  await maybePurgeRuntimeArtifacts({ purge });
-  removeProtocols();
-  await maybeRemoveProjectState({ yes });
-
-  printSummary({ purge });
-}
-
-async function confirmUninstall({ yes }) {
-  if (yes) return true;
-  return confirm(
-    `This will uninstall the ${color.bold("curdx-flow")} plugin. Continue?`,
-    false
-  );
+  await maybeUninstallRecommendedPlugins(context);
+  await maybeRemoveBundledMcps(context);
+  await maybeUninstallRequiredPlugins(context);
+  await maybePurgeRuntimeArtifacts(context);
+  removeProtocolsStep();
+  await maybeRemoveProjectState(context);
+
+  printUninstallSummary(context);
 }
 
 async function uninstallCurdxFlowPlugin() {
   log.blank();
-  log.step(1, 4, "Uninstalling curdx-flow plugin...");
+  log.step(1, UNINSTALL_STEP_COUNT, "Uninstalling curdx-flow plugin...");
   const curdx = listPlugins().find((plugin) => plugin.name === "curdx-flow");
   if (!curdx) {
     log.info("curdx-flow not installed, skipping");
@@ -95,22 +90,19 @@ async function uninstallCurdxFlowPlugin() {
 
 async function maybeUninstallRecommendedPlugins({ yes, keepRecommended }) {
   log.blank();
-  log.step(2, 4, "Recommended plugins");
+  log.step(2, UNINSTALL_STEP_COUNT, "Recommended plugins");
   if (keepRecommended) {
     log.info("Keeping recommended plugins (--keep-recommended)");
     return;
   }
 
-  const currentlyInstalled = listPlugins();
-  const present = RECOMMENDED.filter((entry) =>
-    currentlyInstalled.some((plugin) => plugin.name === entry.name)
-  );
+  const present = getInstalledTargets(RECOMMENDED);
   if (present.length === 0) {
     log.info("No installed recommended plugins");
     return;
   }
 
-  const selected = await selectPluginsToRemove({ yes, present });
+  const selected = await selectRecommendedPluginsToRemove({ yes, present });
   for (const name of selected) {
     const entry = present.find((plugin) => plugin.name === name);
     if (!entry) continue;
@@ -118,26 +110,6 @@ async function maybeUninstallRecommendedPlugins({ yes, keepRecommended }) {
   }
 }
 
-async function selectPluginsToRemove({ yes, present }) {
-  if (yes) {
-    log.info(
-      color.dim("--yes mode: keeping recommended plugins (use --purge to remove them)")
-    );
-    return [];
-  }
-
-  const choices = present.map((entry) => ({
-    label: color.bold(entry.name),
-    value: entry.name,
-    hint: "",
-  }));
-  return multiSelect(
-    "Which recommended plugins to also uninstall? (default: none)",
-    choices,
-    []
-  );
-}
-
 async function uninstallNamedPlugin(entry) {
   log.blank();
   console.log(`  ${color.cyan("▸")} Uninstalling ${color.bold(entry.name)}...`);
@@ -155,7 +127,7 @@ async function uninstallNamedPlugin(entry) {
 async function maybeRemoveBundledMcps({ yes, keepRecommended }) {
   log.blank();
   log.info("Required MCP servers (context7, sequential-thinking)");
-  if (keepRecommended || yes) {
+  if (shouldKeepBundledMcps({ yes, keepRecommended })) {
     log.info(
       color.dim("--yes or --keep-recommended: keeping user-level MCPs (remove manually with `claude mcp remove <name>`)")
     );
@@ -184,7 +156,7 @@ async function maybeRemoveBundledMcps({ yes, keepRecommended }) {
 async function maybeUninstallRequiredPlugins({ yes }) {
   log.blank();
   log.info("Required companion plugins");
-  if (yes) {
+  if (shouldKeepRequiredPlugins({ yes })) {
     log.info(
       color.dim("--yes mode: keeping required companion plugins (use --purge to remove them)")
     );
@@ -212,7 +184,7 @@ async function maybeUninstallRequiredPlugins({ yes }) {
 
 async function maybePurgeRuntimeArtifacts({ purge }) {
   log.blank();
-  log.step(3, 4, "Runtime symlinks and marketplaces");
+  log.step(3, UNINSTALL_STEP_COUNT, "Runtime symlinks and marketplaces");
   if (!purge) {
     log.info(
       color.dim("Keeping ~/.local/bin/bun, ~/.local/bin/uv (use --purge to remove)")
@@ -228,14 +200,7 @@ async function maybePurgeRuntimeArtifacts({ purge }) {
 }
 
 async function purgeManagedMarketplaces() {
-  const marketplaceIds = [
-    ...new Set(
-      RECOMMENDED
-        .concat(REQUIRED)
-        .map((entry) => entry.marketplaceId)
-        .filter((id) => id && id !== "claude-plugins-official")
-    ),
-  ];
+  const marketplaceIds = getManagedMarketplaceIds(RECOMMENDED.concat(REQUIRED));
 
   for (const marketplaceId of marketplaceIds) {
     const result = await removePluginMarketplace(marketplaceId);
@@ -269,26 +234,9 @@ function removeManagedSymlinks() {
   }
 }
 
-function removeProtocols() {
-  log.blank();
-  console.log(color.dim("Removing global protocols from ~/.claude/CLAUDE.md..."));
-  try {
-    const result = removeGlobalProtocols();
-    if (result.action === "removed") {
-      log.ok(`Global protocols removed ${color.dim(`(${GLOBAL_CLAUDE_MD})`)}`);
-    } else if (result.action === "not-present") {
-      log.info("Global protocols not present, skipping");
-    } else {
-      log.info("~/.claude/CLAUDE.md does not exist, skipping");
-    }
-  } catch (err) {
-    log.warn(`Protocol removal failed: ${err.message}`);
-  }
-}
-
 async function maybeRemoveProjectState({ yes }) {
   log.blank();
-  log.step(4, 4, "Project state directory");
+  log.step(4, UNINSTALL_STEP_COUNT, "Project state directory");
   const flowDir = join(process.cwd(), ".flow");
   if (!existsSync(flowDir)) {
     log.info(".flow/ does not exist, skipping");
@@ -319,27 +267,6 @@ async function maybeRemoveProjectState({ yes }) {
   }
 }
 
-function printSummary({ purge }) {
-  log.blank();
-  console.log(color.bold("✅ Uninstall complete"));
-  if (purge) return;
-
-  console.log(
-    color.dim(
-      `\nArtifacts kept:\n` +
-        `  - ~/.local/bin/bun, ~/.local/bin/uv (symlinks; use --purge to remove)\n` +
-        `  - bun/uv binaries themselves (~/.bun/bin/bun, ~/.local/bin/uv real installs)\n` +
-        `  - claude-mem data (~/.claude-mem/)\n` +
-        `  - claude marketplace cache`
-    )
-  );
-  console.log(
-    color.dim(
-      `\nFully purge: ${color.cyan("curdx-flow uninstall --purge")}`
-    )
-  );
-}
-
 function toUninstallTarget(entry) {
   return {
     name: entry.name,

package/cli/upgrade-workflow.js

@@ -0,0 +1,80 @@
+import { claudeVersion, color, listPlugins, log, resultLastLine } from "./utils.js";
+
+export const UPGRADE_STEP_COUNT = 2;
+
+export function ensureClaudeCliAvailableForUpgrade(
+  { claudeVersionImpl = claudeVersion, logImpl = log, exitImpl = process.exit } = {}
+) {
+  const version = claudeVersionImpl();
+  if (!version) {
+    logImpl.err("claude CLI not found");
+    exitImpl(1);
+    return null;
+  }
+
+  return version;
+}
+
+export function getInstalledPluginNames({ listPluginsImpl = listPlugins } = {}) {
+  return new Set(listPluginsImpl().map((plugin) => plugin.name));
+}
+
+export function getPluginNameFromSpec(spec) {
+  return String(spec).split("@")[0];
+}
+
+export function classifyPluginUpdateResult(result) {
+  if (result.code !== 0) {
+    return {
+      status: "failed",
+      message: resultLastLine(result),
+    };
+  }
+
+  if (!result.stdout.includes("updated from")) {
+    return {
+      status: "unchanged",
+      message: "already up to date",
+    };
+  }
+
+  const match = result.stdout.match(/updated from (\S+) to (\S+)/);
+  if (!match) {
+    return {
+      status: "updated",
+      message: "updated",
+    };
+  }
+
+  return {
+    status: "updated",
+    from: match[1],
+    to: match[2],
+    message: color.dim(`${match[1]} → ${match[2]}`),
+  };
+}
+
+export async function refreshMarketplaces(
+  marketplaceIds,
+  { updatePluginMarketplaceImpl, logImpl = log } = {}
+) {
+  logImpl.step(1, UPGRADE_STEP_COUNT, "Refreshing marketplaces...");
+
+  for (const marketplaceId of marketplaceIds) {
+    const result = await updatePluginMarketplaceImpl(marketplaceId);
+    if (result.code === 0) {
+      logImpl.ok(`   ${marketplaceId}`);
+      continue;
+    }
+
+    if (!result.stderr.includes("not found")) {
+      logImpl.warn(`   ${marketplaceId}: ${resultLastLine(result)}`);
+    }
+  }
+}
+
+export function printUpgradeSummary({ logImpl = log } = {}) {
+  logImpl.blank();
+  logImpl.ok("Upgrade complete");
+  console.log(color.dim("   Some changes require a Claude Code restart to take effect"));
+}

package/cli/upgrade.js

@@ -2,7 +2,7 @@
  * upgrade command — update curdx-flow + recommended plugins to latest.
  */
 
-import { color, log, listPlugins, claudeVersion, resultLastLine } from "./utils.js";
+import { log } from "./utils.js";
 import {
   PLUGINS_TO_UPDATE,
   MARKETPLACES_TO_REFRESH,
@@ -11,61 +11,53 @@ import {
   updatePlugin,
   updatePluginMarketplace,
 } from "./lib/claude-ops.js";
+import {
+  classifyPluginUpdateResult,
+  ensureClaudeCliAvailableForUpgrade,
+  getInstalledPluginNames,
+  getPluginNameFromSpec,
+  printUpgradeSummary,
+  refreshMarketplaces,
+  UPGRADE_STEP_COUNT,
+} from "./upgrade-workflow.js";
 
 export async function upgrade(args = []) {
   log.title("⬆️  CurdX-Flow upgrade");
 
-  if (!claudeVersion()) {
-    log.err("claude CLI not found");
-    process.exit(1);
-  }
+  ensureClaudeCliAvailableForUpgrade();
 
   // Refresh marketplaces first (derived from cli/registry.js)
-  log.step(1, 2, "Refreshing marketplaces...");
-  for (const mp of MARKETPLACES_TO_REFRESH) {
-    const r = await updatePluginMarketplace(mp);
-    if (r.code === 0) {
-      log.ok(`   ${mp}`);
-    } else {
-      // Not a fatal — might not be added
-      if (!r.stderr.includes("not found")) {
-        log.warn(`   ${mp}: ${resultLastLine(r)}`);
-      }
-    }
-  }
+  await refreshMarketplaces(MARKETPLACES_TO_REFRESH, {
+    updatePluginMarketplaceImpl: updatePluginMarketplace,
+  });
 
   // Update each plugin
   log.blank();
-  log.step(2, 2, "Updating installed plugins...");
-  const installed = listPlugins();
-  const installedNames = new Set(installed.map((p) => p.name));
+  log.step(2, UPGRADE_STEP_COUNT, "Updating installed plugins...");
+  const installedNames = getInstalledPluginNames();
 
   for (const spec of PLUGINS_TO_UPDATE) {
-    const pluginName = spec.split("@")[0];
+    const pluginName = getPluginNameFromSpec(spec);
     if (!installedNames.has(pluginName)) {
       log.info(`   ${pluginName.padEnd(22)} not installed, skipping`);
       continue;
     }
 
-    const r = await updatePlugin(spec);
-    if (r.code === 0) {
-      const updated = r.stdout.includes("updated from");
-      if (updated) {
-        const m = r.stdout.match(/updated from (\S+) to (\S+)/);
-        if (m) {
-          log.ok(`   ${pluginName.padEnd(22)} ${color.dim(`${m[1]} → ${m[2]}`)}`);
-        } else {
-          log.ok(`   ${pluginName.padEnd(22)} updated`);
-        }
-      } else {
-        log.info(`   ${pluginName.padEnd(22)} already up to date`);
-      }
-    } else {
-      log.warn(`   ${pluginName.padEnd(22)} ${resultLastLine(r)}`);
+    const result = await updatePlugin(spec);
+    const status = classifyPluginUpdateResult(result);
+
+    if (status.status === "updated") {
+      log.ok(`   ${pluginName.padEnd(22)} ${status.message}`);
+      continue;
     }
+
+    if (status.status === "unchanged") {
+      log.info(`   ${pluginName.padEnd(22)} ${status.message}`);
+      continue;
+    }
+
+    log.warn(`   ${pluginName.padEnd(22)} ${status.message}`);
   }
 
-  log.blank();
-  log.ok("Upgrade complete");
-  console.log(color.dim("   Some changes require a Claude Code restart to take effect"));
+  printUpgradeSummary();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curdx/flow",
-  "version": "2.0.19",
+  "version": "2.0.20",
   "description": "CLI installer for CurdX-Flow — AI engineering workflow meta-framework for Claude Code",
   "type": "module",
   "bin": {