@curdx/flow 2.2.3 → 2.2.4

package/cli/lib/doctor-runtime-environment.js

@@ -0,0 +1,196 @@
+const ENV_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max", "auto"];
+const PINNED_MODEL_ENV_FAMILIES = [
+  {
+    modelVar: "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    capsVar: "ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES",
+    label: "Opus",
+  },
+  {
+    modelVar: "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    capsVar: "ANTHROPIC_DEFAULT_SONNET_MODEL_SUPPORTED_CAPABILITIES",
+    label: "Sonnet",
+  },
+  {
+    modelVar: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    capsVar: "ANTHROPIC_DEFAULT_HAIKU_MODEL_SUPPORTED_CAPABILITIES",
+    label: "Haiku",
+  },
+  {
+    modelVar: "ANTHROPIC_CUSTOM_MODEL_OPTION",
+    capsVar: "ANTHROPIC_CUSTOM_MODEL_OPTION_SUPPORTED_CAPABILITIES",
+    label: "Custom model option",
+  },
+];
+
+function envFlagEnabled(value) {
+  if (value === true || value === 1) return true;
+  if (typeof value !== "string") return false;
+  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+
+function normalizedEnvValue(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+function stripExtendedContextSuffix(modelId) {
+  return modelId.replace(/\[1m\]$/i, "");
+}
+
+function looksProviderSpecificModelId(modelId) {
+  const normalized = stripExtendedContextSuffix(modelId);
+  if (normalized.includes(":") || normalized.includes("/")) return true;
+  if (/^(?:us\.)?anthropic\./i.test(normalized)) return true;
+  if (!/^claude-(?:opus|sonnet|haiku)-/i.test(normalized)) return true;
+  return false;
+}
+
+function positiveIntegerFromEnv(value) {
+  const normalized = normalizedEnvValue(value);
+  if (!normalized) return null;
+  if (!/^[0-9]+$/.test(normalized)) return Number.NaN;
+  const parsed = Number(normalized);
+  return parsed > 0 ? parsed : Number.NaN;
+}
+
+export function inspectRuntimeEnvironment(env = process.env) {
+  const entries = [];
+  const inCi = envFlagEnabled(env.CI);
+
+  if (envFlagEnabled(env.CLAUDE_CODE_SIMPLE)) {
+    entries.push({
+      level: "err",
+      text: "CLAUDE_CODE_SIMPLE     enabled (bare/simple mode)",
+      details: [
+        "official docs: this disables auto-discovery of hooks, skills, plugins, MCP servers, auto memory, and CLAUDE.md",
+        "CurDX-Flow cannot load correctly in this mode; unset it before launching Claude Code",
+      ],
+    });
+  }
+
+  if (envFlagEnabled(env.CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT)) {
+    entries.push({
+      level: "warn",
+      text: "CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT enabled",
+      details: [
+        "official docs: discovery still works, but Claude runs with the minimal system prompt and collapsed tool descriptions",
+        "CurDX-Flow may still load, but planning/review behavior can degrade versus the normal Claude Code prompt",
+      ],
+    });
+  }
+
+  const effortLevel = normalizedEnvValue(env.CLAUDE_CODE_EFFORT_LEVEL);
+  if (effortLevel && !ENV_EFFORT_LEVELS.includes(effortLevel)) {
+    entries.push({
+      level: "warn",
+      text: `CLAUDE_CODE_EFFORT_LEVEL invalid (${effortLevel})`,
+      details: [
+        `expected one of: ${ENV_EFFORT_LEVELS.join(", ")}`,
+        "invalid effort env values can make sessions harder to reason about; remove or correct it",
+      ],
+    });
+  } else if (effortLevel === "low" || effortLevel === "medium") {
+    entries.push({
+      level: "warn",
+      text: `CLAUDE_CODE_EFFORT_LEVEL ${effortLevel}`,
+      details: [
+        "this takes precedence over /effort and settings effortLevel",
+        "CurDX-Flow planning, verification, and review-heavy turns usually work better at high or xhigh",
+      ],
+    });
+  } else if (effortLevel) {
+    entries.push({
+      level: "info",
+      text: `CLAUDE_CODE_EFFORT_LEVEL ${effortLevel}`,
+      details: [
+        "session effort is pinned through the environment for this process",
+      ],
+    });
+  }
+
+  if (envFlagEnabled(env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS)) {
+    entries.push({
+      level: "info",
+      text: "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS enabled",
+      details: [
+        "official docs: this enables experimental team surfaces such as SendMessage / TeamCreate / TeamDelete",
+        "CurDX-Flow does not depend on these runtime-gated tools, but this explains why teammate features may appear in this session",
+      ],
+    });
+  }
+
+  const syncPluginInstall = envFlagEnabled(env.CLAUDE_CODE_SYNC_PLUGIN_INSTALL);
+  const syncPluginInstallTimeout = positiveIntegerFromEnv(
+    env.CLAUDE_CODE_SYNC_PLUGIN_INSTALL_TIMEOUT_MS
+  );
+  const pluginSeedDir = normalizedEnvValue(env.CLAUDE_CODE_PLUGIN_SEED_DIR);
+
+  if (normalizedEnvValue(env.CLAUDE_CODE_SYNC_PLUGIN_INSTALL_TIMEOUT_MS)) {
+    if (Number.isNaN(syncPluginInstallTimeout)) {
+      entries.push({
+        level: "warn",
+        text: "CLAUDE_CODE_SYNC_PLUGIN_INSTALL_TIMEOUT_MS invalid",
+        details: [
+          "expected a positive integer timeout in milliseconds",
+          "invalid timeout values can make headless plugin-install behavior harder to reason about",
+        ],
+      });
+    } else if (!syncPluginInstall) {
+      entries.push({
+        level: "warn",
+        text: "CLAUDE_CODE_SYNC_PLUGIN_INSTALL_TIMEOUT_MS set without CLAUDE_CODE_SYNC_PLUGIN_INSTALL",
+        details: [
+          "official docs: the timeout only applies when synchronous plugin installation is enabled",
+          "set CLAUDE_CODE_SYNC_PLUGIN_INSTALL=1 or remove the timeout override",
+        ],
+      });
+    }
+  }
+
+  if (pluginSeedDir) {
+    entries.push({
+      level: "info",
+      text: "CLAUDE_CODE_PLUGIN_SEED_DIR configured",
+      details: [
+        `seed dir: ${pluginSeedDir}`,
+        "official docs: pre-populated plugin seeds let containers and CI start with marketplaces/plugins already available",
+      ],
+    });
+  }
+
+  if (inCi && !syncPluginInstall && !pluginSeedDir) {
+    entries.push({
+      level: "warn",
+      text: "CI environment without synchronous or seeded plugin availability",
+      details: [
+        "prefer claude --bare -p for CI so runs do not inherit local hooks, skills, plugins, MCP discovery, or CLAUDE.md unexpectedly",
+        "official docs: in non-interactive/headless mode, marketplace plugins may install in the background and miss the first turn",
+        "set CLAUDE_CODE_SYNC_PLUGIN_INSTALL=1 for headless runs that depend on plugin availability on turn one",
+        "or pre-populate plugins with CLAUDE_CODE_PLUGIN_SEED_DIR in containers/CI images",
+        "if the run needs project assets in bare mode, pass them explicitly with --plugin-dir, --settings, or --mcp-config",
+      ],
+    });
+  }
+
+  for (const family of PINNED_MODEL_ENV_FAMILIES) {
+    const modelId = normalizedEnvValue(env[family.modelVar]);
+    if (!modelId) continue;
+
+    const caps = normalizedEnvValue(env[family.capsVar]);
+    if (!looksProviderSpecificModelId(modelId) || caps) continue;
+
+    entries.push({
+      level: "warn",
+      text: `${family.modelVar} uses a provider-specific/custom model id`,
+      details: [
+        `${family.label} pinned to: ${modelId}`,
+        `${family.capsVar} is unset`,
+        "official docs: custom/provider model IDs can disable Claude Code feature detection for effort and thinking",
+        `declare ${family.capsVar} when pinning custom Bedrock / Vertex / Foundry / gateway model IDs`,
+      ],
+    });
+  }
+
+  return { entries };
+}

package/cli/lib/semver.js

@@ -93,3 +93,17 @@ export function isVersionNewer(latestVersion, currentVersion) {
 export function isVersionAtLeast(version, minimumVersion) {
   return compareVersions(version, minimumVersion) >= 0;
 }
+
+export function deriveNpmDistTag(version) {
+  const { prerelease } = parseVersion(version);
+
+  if (prerelease.length === 0) {
+    return "latest";
+  }
+
+  const namedChannel = prerelease.find(
+    (token) => typeof token === "string" && token.length > 0
+  );
+
+  return namedChannel || "prerelease";
+}

package/cli/uninstall-actions.js

@@ -0,0 +1,323 @@
+import { existsSync, lstatSync, unlinkSync, rmSync, readlinkSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+import { REQUIRED_PLUGINS, RECOMMENDED_PLUGINS, BUNDLED_MCPS } from "./registry.js";
+import {
+  removeMcp,
+  removePluginMarketplace,
+  uninstallPlugin,
+} from "./lib/claude-ops.js";
+import {
+  confirm,
+  color,
+  listPlugins,
+  log,
+  resultLastLine,
+  resultOutput,
+} from "./utils.js";
+import {
+  UNINSTALL_STEP_COUNT,
+  getInstalledTargets,
+  getManagedMarketplaceIds,
+  selectRecommendedPluginsToRemove,
+  shouldKeepBundledMcps,
+  shouldKeepRequiredPlugins,
+} from "./uninstall-workflow.js";
+
+const HOME = homedir();
+
+const RECOMMENDED = RECOMMENDED_PLUGINS.map(toUninstallTarget);
+const REQUIRED = REQUIRED_PLUGINS.map(toUninstallTarget);
+
+// Symlinks created by install.js (only cleaned with --purge)
+const MANAGED_SYMLINKS = [
+  join(HOME, ".local", "bin", "bun"),
+  join(HOME, ".local", "bin", "uv"),
+];
+
+export async function uninstallCurdxFlowPlugin(
+  {
+    listPluginsImpl = listPlugins,
+    uninstallPluginImpl = uninstallPlugin,
+    logImpl = log,
+    resultOutputImpl = resultOutput,
+  } = {}
+) {
+  logImpl.blank();
+  logImpl.step(1, UNINSTALL_STEP_COUNT, "Uninstalling curdx-flow plugin...");
+  const curdx = listPluginsImpl().find((plugin) => plugin.name === "curdx-flow");
+  if (!curdx) {
+    logImpl.info("curdx-flow not installed, skipping");
+    return;
+  }
+
+  const result = await uninstallPluginImpl({
+    scope: "user",
+    uninstallSpec: "curdx-flow@curdx-flow-marketplace",
+  });
+  if (result.code === 0) {
+    logImpl.ok("curdx-flow uninstalled");
+    return;
+  }
+
+  logImpl.err(`Uninstall failed: ${resultOutputImpl(result)}`);
+}
+
+export async function maybeUninstallRecommendedPlugins(
+  { yes, keepRecommended },
+  {
+    getInstalledTargetsImpl = getInstalledTargets,
+    selectRecommendedPluginsToRemoveImpl = selectRecommendedPluginsToRemove,
+    uninstallNamedPluginImpl = uninstallNamedPlugin,
+    logImpl = log,
+  } = {}
+) {
+  logImpl.blank();
+  logImpl.step(2, UNINSTALL_STEP_COUNT, "Recommended plugins");
+  if (keepRecommended) {
+    logImpl.info("Keeping recommended plugins (--keep-recommended)");
+    return;
+  }
+
+  const present = getInstalledTargetsImpl(RECOMMENDED);
+  if (present.length === 0) {
+    logImpl.info("No installed recommended plugins");
+    return;
+  }
+
+  const selected = await selectRecommendedPluginsToRemoveImpl({ yes, present });
+  for (const name of selected) {
+    const entry = present.find((plugin) => plugin.name === name);
+    if (!entry) continue;
+    await uninstallNamedPluginImpl(entry);
+  }
+}
+
+export async function uninstallNamedPlugin(
+  entry,
+  {
+    uninstallPluginImpl = uninstallPlugin,
+    resultLastLineImpl = resultLastLine,
+  } = {}
+) {
+  log.blank();
+  console.log(`  ${color.cyan("▸")} Uninstalling ${color.bold(entry.name)}...`);
+  const result = await uninstallPluginImpl(entry);
+  if (result.code === 0) {
+    console.log(`  ${color.green("✓")} ${entry.name} uninstalled`);
+    return;
+  }
+
+  console.log(
+    `  ${color.red("✗")} ${entry.name} uninstall failed: ${resultLastLineImpl(result)}`
+  );
+}
+
+export async function maybeRemoveBundledMcps(
+  { yes, keepRecommended },
+  {
+    shouldKeepBundledMcpsImpl = shouldKeepBundledMcps,
+    confirmImpl = confirm,
+    removeMcpImpl = removeMcp,
+    logImpl = log,
+  } = {}
+) {
+  logImpl.blank();
+  logImpl.info("Required MCP servers (context7, sequential-thinking)");
+  if (shouldKeepBundledMcpsImpl({ yes, keepRecommended })) {
+    logImpl.info(
+      color.dim("--yes or --keep-recommended: keeping user-level MCPs (remove manually with `claude mcp remove <name>`)")
+    );
+    return;
+  }
+
+  const removeMcps = await confirmImpl(
+    `Remove user-level MCPs registered by install (${BUNDLED_MCPS.map((mcp) => mcp.name).join(", ")})? ${color.dim("(keeps them if other tools depend on them)")}`,
+    false
+  );
+  if (!removeMcps) {
+    logImpl.info("Keeping user-level MCPs");
+    return;
+  }
+
+  for (const mcp of BUNDLED_MCPS) {
+    const result = await removeMcpImpl({ name: mcp.name });
+    if (result.code === 0) {
+      logImpl.ok(`  ${mcp.name.padEnd(22)} removed`);
+    } else {
+      logImpl.info(`  ${mcp.name.padEnd(22)} ${color.dim("not present or already removed")}`);
+    }
+  }
+}
+
+export async function maybeUninstallRequiredPlugins(
+  { yes },
+  {
+    shouldKeepRequiredPluginsImpl = shouldKeepRequiredPlugins,
+    confirmImpl = confirm,
+    uninstallPluginImpl = uninstallPlugin,
+    logImpl = log,
+  } = {}
+) {
+  logImpl.blank();
+  logImpl.info("Required companion plugins");
+  if (shouldKeepRequiredPluginsImpl({ yes })) {
+    logImpl.info(
+      color.dim("--yes mode: keeping required companion plugins (use --purge to remove them)")
+    );
+    return;
+  }
+
+  const removeRequired = await confirmImpl(
+    `Remove required companion plugins (${REQUIRED.map((plugin) => plugin.name).join(", ")})? ${color.dim("(keeps shared tools available if other workflows depend on them)")}`,
+    false
+  );
+  if (!removeRequired) {
+    logImpl.info("Keeping required companion plugins");
+    return;
+  }
+
+  for (const plugin of REQUIRED) {
+    const result = await uninstallPluginImpl(plugin);
+    if (result.code === 0) {
+      logImpl.ok(`  ${plugin.name.padEnd(22)} uninstalled`);
+    } else {
+      logImpl.info(`  ${plugin.name.padEnd(22)} ${color.dim("not present or already removed")}`);
+    }
+  }
+}
+
+export async function maybePurgeRuntimeArtifacts(
+  { purge },
+  {
+    purgeManagedMarketplacesImpl = purgeManagedMarketplaces,
+    removeManagedSymlinksImpl = removeManagedSymlinks,
+    logImpl = log,
+  } = {}
+) {
+  logImpl.blank();
+  logImpl.step(3, UNINSTALL_STEP_COUNT, "Runtime symlinks and marketplaces");
+  if (!purge) {
+    logImpl.info(
+      color.dim("Keeping ~/.local/bin/bun, ~/.local/bin/uv (use --purge to remove)")
+    );
+    logImpl.info(
+      color.dim("Reason: these bun/uv binaries may be used by other tools — confirm before deleting")
+    );
+    return;
+  }
+
+  await purgeManagedMarketplacesImpl();
+  removeManagedSymlinksImpl();
+}
+
+export async function maybeRemoveProjectState(
+  { yes },
+  {
+    cwd = process.cwd(),
+    confirmImpl = confirm,
+    existsSyncImpl = existsSync,
+    rmSyncImpl = rmSync,
+    logImpl = log,
+  } = {}
+) {
+  logImpl.blank();
+  logImpl.step(4, UNINSTALL_STEP_COUNT, "Project state directory");
+  const flowDir = join(cwd, ".flow");
+  if (!existsSyncImpl(flowDir)) {
+    logImpl.info(".flow/ does not exist, skipping");
+    return;
+  }
+
+  if (yes) {
+    logImpl.info(
+      color.dim("--yes mode: keeping .flow/ (contains specs & decisions — confirm by hand before deleting)")
+    );
+    return;
+  }
+
+  const ok = await confirmImpl(
+    `${color.red("DANGER:")} delete the ${color.bold(".flow/")} directory of the current project? ${color.dim("(includes all specs / decisions, not recoverable)")}`,
+    false
+  );
+  if (!ok) {
+    logImpl.info("Keeping .flow/");
+    return;
+  }
+
+  try {
+    rmSyncImpl(flowDir, { recursive: true, force: true });
+    logImpl.ok(`Removed ${flowDir}`);
+  } catch (err) {
+    logImpl.err(`Removal failed: ${err.message}`);
+  }
+}
+
+async function purgeManagedMarketplaces(
+  {
+    getManagedMarketplaceIdsImpl = getManagedMarketplaceIds,
+    removePluginMarketplaceImpl = removePluginMarketplace,
+    logImpl = log,
+  } = {}
+) {
+  const marketplaceIds = getManagedMarketplaceIdsImpl(RECOMMENDED.concat(REQUIRED));
+
+  for (const marketplaceId of marketplaceIds) {
+    const result = await removePluginMarketplaceImpl(marketplaceId);
+    if (result.code === 0) {
+      logImpl.ok(`Removed marketplace ${marketplaceId}`);
+    } else if (!result.stderr.includes("not found")) {
+      logImpl.warn(`Failed to remove marketplace ${marketplaceId}: ${resultLastLine(result)}`);
+    }
+  }
+}
+
+function removeManagedSymlinks(
+  {
+    existsSyncImpl = existsSync,
+    isBrokenSymlinkImpl = isBrokenSymlink,
+    lstatSyncImpl = lstatSync,
+    readlinkSyncImpl = readlinkSync,
+    unlinkSyncImpl = unlinkSync,
+    logImpl = log,
+  } = {}
+) {
+  for (const link of MANAGED_SYMLINKS) {
+    if (!existsSyncImpl(link) && !isBrokenSymlinkImpl(link)) {
+      continue;
+    }
+    try {
+      const stat = lstatSyncImpl(link);
+      if (!stat.isSymbolicLink()) {
+        logImpl.warn(
+          `${link} is not a symlink (likely a real file placed by the user), skipping`
+        );
+        continue;
+      }
+      const target = readlinkSyncImpl(link);
+      unlinkSyncImpl(link);
+      logImpl.ok(`Removed symlink ${link} ${color.dim(`(was → ${target})`)}`);
+    } catch (err) {
+      logImpl.warn(`Failed to remove ${link}: ${err.message}`);
+    }
+  }
+}
+
+function toUninstallTarget(entry) {
+  return {
+    name: entry.name,
+    uninstallSpec: entry.uninstallSpec,
+    uninstallArgs: entry.uninstallArgs || [],
+    marketplaceId: entry.marketplaceId,
+    scope: entry.scope,
+  };
+}
+
+function isBrokenSymlink(pathname) {
+  try {
+    return lstatSync(pathname).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}