@curdx/flow 1.1.1

package/cli/protocols.js

@@ -0,0 +1,124 @@
+/**
+ * Global protocol injection — manage a curdx-flow-owned block in ~/.claude/CLAUDE.md.
+ *
+ * Uses sentinel markers so the block is idempotent (re-install upgrades it)
+ * and reversible (uninstall removes it cleanly without touching user content).
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+
+const HOME = process.env.HOME || "";
+export const GLOBAL_CLAUDE_MD = join(HOME, ".claude", "CLAUDE.md");
+
+const SENTINEL_BEGIN =
+  "<!-- BEGIN curdx-flow protocols (auto-managed; do not edit between sentinels) -->";
+const SENTINEL_END = "<!-- END curdx-flow protocols -->";
+
+// Protocol block is itself in English — it's instructions for the model,
+// not user-facing prose. User chat output is still Chinese per the rule below.
+const PROTOCOL_BODY = `
+## Global Protocols (curdx-flow)
+
+All operations MUST strictly follow these system constraints:
+
+### Language separation
+- **Tool / persistence layer = English**: commit messages, code, comments, file names, function names, PR descriptions, CLI log output, error messages thrown by code, and any artifact persisted to the repository or shown in a developer terminal.
+- **Conversational layer = Simplified Chinese**: chat replies, explanations and reasoning shown directly to the human in a conversation interface (e.g. Claude Code chat).
+
+Rationale: English in the persistence/tool layer aligns with developer-tool industry norms (npm/git/cargo are all English) and keeps the codebase internationally collaborable. Chinese in the conversational layer matches the user's language preference. Mixing the two (e.g. Chinese commit messages, Chinese CLI log output) is a violation.
+
+### Discovery & reasoning
+- **Library / framework / API questions**: query \`context7\` MCP first. Do not rely on training memory.
+- **Planning / design / architecture review / epic decomposition**: use \`sequential-thinking\` MCP with at least 5 thoughts.
+- **Cross-session memory**: query \`claude-mem\` MCP at task start when available.
+
+### Three red lines (inherited from pua)
+1. **Closed loop**: claiming "done"? Provide evidence (build output / passing tests / curl result).
+2. **Fact-driven**: before saying "probably an env issue", verify it. Unverified attribution = blame-shifting.
+3. **Exhaust everything**: before saying "I cannot", complete the systematic 4-stage debugging.
+
+> Source: curdx-flow CLI installer (\`curdx-flow install\`). Remove with: \`curdx-flow uninstall --purge\`.
+`;
+
+const FULL_BLOCK = `${SENTINEL_BEGIN}\n${PROTOCOL_BODY.trim()}\n${SENTINEL_END}`;
+
+/**
+ * Read existing CLAUDE.md content; return "" if missing.
+ */
+function readGlobalMd() {
+  if (!existsSync(GLOBAL_CLAUDE_MD)) return "";
+  return readFileSync(GLOBAL_CLAUDE_MD, "utf-8");
+}
+
+/**
+ * Locate the sentinel block in the content.
+ * Returns { start, end } indices into content, or null if not found.
+ */
+function findBlock(content) {
+  const start = content.indexOf(SENTINEL_BEGIN);
+  if (start === -1) return null;
+  const endIdx = content.indexOf(SENTINEL_END, start);
+  if (endIdx === -1) return null;
+  return { start, end: endIdx + SENTINEL_END.length };
+}
+
+/**
+ * Inject (or upgrade) the protocol block in ~/.claude/CLAUDE.md.
+ * @returns {{action:"created"|"upgraded"|"unchanged", path:string}}
+ */
+export function injectGlobalProtocols() {
+  const path = GLOBAL_CLAUDE_MD;
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const existing = readGlobalMd();
+  const block = findBlock(existing);
+
+  if (!block) {
+    // Append — preserve all user content, add a separator if file had content
+    const sep = existing.length > 0 && !existing.endsWith("\n\n")
+      ? (existing.endsWith("\n") ? "\n" : "\n\n")
+      : "";
+    const next = existing + sep + FULL_BLOCK + "\n";
+    writeFileSync(path, next, "utf-8");
+    return { action: existing.length === 0 ? "created" : "created", path };
+  }
+
+  // Replace existing block (handle upgrade-in-place)
+  const currentBlock = existing.slice(block.start, block.end);
+  if (currentBlock === FULL_BLOCK) {
+    return { action: "unchanged", path };
+  }
+  const next =
+    existing.slice(0, block.start) + FULL_BLOCK + existing.slice(block.end);
+  writeFileSync(path, next, "utf-8");
+  return { action: "upgraded", path };
+}
+
+/**
+ * Remove the protocol block from ~/.claude/CLAUDE.md.
+ * @returns {{action:"removed"|"not-present"|"no-file", path:string}}
+ */
+export function removeGlobalProtocols() {
+  const path = GLOBAL_CLAUDE_MD;
+  if (!existsSync(path)) return { action: "no-file", path };
+
+  const existing = readGlobalMd();
+  const block = findBlock(existing);
+  if (!block) return { action: "not-present", path };
+
+  // Trim leading/trailing whitespace adjacent to the block
+  let start = block.start;
+  let end = block.end;
+  // Eat one trailing newline if present
+  if (existing[end] === "\n") end++;
+  // Eat one leading newline if previous char is also newline (collapse blank lines)
+  if (start > 0 && existing[start - 1] === "\n" && existing[start - 2] === "\n") {
+    start--;
+  }
+
+  const next = existing.slice(0, start) + existing.slice(end);
+  writeFileSync(path, next, "utf-8");
+  return { action: "removed", path };
+}

package/cli/uninstall.js

@@ -0,0 +1,238 @@
+/**
+ * uninstall command — remove curdx-flow plugin (and optionally recommended plugins / artifacts).
+ */
+
+import { existsSync, lstatSync, unlinkSync, rmSync, readlinkSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  color,
+  log,
+  run,
+  confirm,
+  multiSelect,
+  claudeVersion,
+  listPlugins,
+} from "./utils.js";
+import { removeGlobalProtocols, GLOBAL_CLAUDE_MD } from "./protocols.js";
+
+const HOME = process.env.HOME || "";
+
+// Keep aligned with install.js
+const RECOMMENDED = [
+  { name: "pua", uninstallSpec: "pua@pua-skills" },
+  { name: "claude-mem", uninstallSpec: "claude-mem@thedotmack" },
+  {
+    name: "frontend-design",
+    uninstallSpec: "frontend-design@claude-plugins-official",
+  },
+];
+
+// 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 uninstall(args = []) {
+  const yes = args.includes("--yes") || args.includes("-y");
+  const purge = args.includes("--purge");
+  const keepRecommended = args.includes("--keep-recommended");
+
+  log.title("🗑️  CurDX-Flow Uninstaller");
+
+  // ---------- Step 1: claude CLI present? ----------
+  const cv = claudeVersion();
+  if (!cv) {
+    log.err("claude CLI not found, cannot uninstall plugin.");
+    process.exit(1);
+  }
+
+  // ---------- Step 2: confirmation ----------
+  if (!yes) {
+    const ok = await confirm(
+      `This will uninstall the ${color.bold("curdx-flow")} plugin. Continue?`,
+      false
+    );
+    if (!ok) {
+      log.info("Cancelled");
+      return;
+    }
+  }
+
+  // ---------- Step 3: uninstall curdx-flow plugin ----------
+  log.blank();
+  log.step(1, 4, "Uninstalling curdx-flow plugin...");
+  const installed = listPlugins();
+  const curdx = installed.find((p) => p.name === "curdx-flow");
+  if (!curdx) {
+    log.info("curdx-flow not installed, skipping");
+  } else {
+    const r = await run(
+      "claude",
+      ["plugin", "uninstall", "curdx-flow@curdx-flow-marketplace"],
+      { silent: true }
+    );
+    if (r.code === 0) {
+      log.ok("curdx-flow uninstalled");
+    } else {
+      log.err(`Uninstall failed: ${r.stderr.trim() || r.stdout.trim()}`);
+    }
+  }
+
+  // ---------- Step 4: optionally uninstall recommended ----------
+  log.blank();
+  log.step(2, 4, "Recommended plugins");
+  if (keepRecommended) {
+    log.info("Keeping recommended plugins (--keep-recommended)");
+  } else {
+    const currentlyInstalled = listPlugins();
+    const presentRecs = RECOMMENDED.filter((r) =>
+      currentlyInstalled.find((p) => p.name === r.name)
+    );
+
+    if (presentRecs.length === 0) {
+      log.info("No installed recommended plugins");
+    } else {
+      let toRemove;
+      if (yes) {
+        toRemove = []; // Default to none — user must opt in explicitly
+        log.info(
+          color.dim("--yes mode: keeping recommended plugins (use --purge to remove them)")
+        );
+      } else {
+        const choices = presentRecs.map((r) => ({
+          label: color.bold(r.name),
+          value: r.name,
+          hint: "",
+        }));
+        toRemove = await multiSelect(
+          "Which recommended plugins to also uninstall? (default: none)",
+          choices,
+          [] // default: nothing checked
+        );
+      }
+
+      for (const name of toRemove) {
+        const rec = presentRecs.find((r) => r.name === name);
+        log.blank();
+        console.log(`  ${color.cyan("⏳")} Uninstalling ${color.bold(rec.name)}...`);
+        const r = await run(
+          "claude",
+          ["plugin", "uninstall", rec.uninstallSpec],
+          { silent: true }
+        );
+        if (r.code === 0) {
+          console.log(`  ${color.green("✓")} ${rec.name} uninstalled`);
+        } else {
+          console.log(
+            `  ${color.red("✗")} ${rec.name} uninstall failed: ${r.stderr.trim().split("\n").pop()}`
+          );
+        }
+      }
+    }
+  }
+
+  // ---------- Step 5: cleanup symlinks (only with --purge) ----------
+  log.blank();
+  log.step(3, 4, "Runtime symlinks");
+  if (!purge) {
+    log.info(
+      color.dim("Keeping ~/.local/bin/bun, ~/.local/bin/uv (use --purge to remove)")
+    );
+    log.info(
+      color.dim("Reason: these bun/uv binaries may be used by other tools — confirm before deleting")
+    );
+  } else {
+    for (const link of MANAGED_SYMLINKS) {
+      if (!existsSync(link) && !isBrokenSymlink(link)) {
+        continue;
+      }
+      try {
+        const stat = lstatSync(link);
+        if (!stat.isSymbolicLink()) {
+          log.warn(
+            `${link} is not a symlink (likely a real file placed by the user), skipping`
+          );
+          continue;
+        }
+        const target = readlinkSync(link);
+        unlinkSync(link);
+        log.ok(`Removed symlink ${link} ${color.dim(`(was → ${target})`)}`);
+      } catch (err) {
+        log.warn(`Failed to remove ${link}: ${err.message}`);
+      }
+    }
+  }
+
+  // ---------- Step 5.5: remove global protocols block ----------
+  log.blank();
+  console.log(color.dim("Removing global protocols from ~/.claude/CLAUDE.md..."));
+  try {
+    const r = removeGlobalProtocols();
+    if (r.action === "removed") {
+      log.ok(`Global protocols removed ${color.dim(`(${GLOBAL_CLAUDE_MD})`)}`);
+    } else if (r.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}`);
+  }
+
+  // ---------- Step 6: project .flow/ ----------
+  log.blank();
+  log.step(4, 4, "Project state directory");
+  const flowDir = join(process.cwd(), ".flow");
+  if (!existsSync(flowDir)) {
+    log.info(".flow/ does not exist, skipping");
+  } else if (yes) {
+    log.info(
+      color.dim("--yes mode: keeping .flow/ (contains specs & decisions — confirm by hand before deleting)")
+    );
+  } else {
+    const ok = await confirm(
+      `${color.red("DANGER:")} delete the ${color.bold(".flow/")} directory of the current project? ${color.dim("(includes all specs / decisions, not recoverable)")}`,
+      false
+    );
+    if (ok) {
+      try {
+        rmSync(flowDir, { recursive: true, force: true });
+        log.ok(`Removed ${flowDir}`);
+      } catch (err) {
+        log.err(`Removal failed: ${err.message}`);
+      }
+    } else {
+      log.info("Keeping .flow/");
+    }
+  }
+
+  // ---------- Summary ----------
+  log.blank();
+  console.log(color.bold("✅ Uninstall complete"));
+  if (!purge) {
+    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 isBrokenSymlink(p) {
+  try {
+    return lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}

package/cli/upgrade.js

@@ -0,0 +1,75 @@
+/**
+ * upgrade command — update curdx-flow + recommended plugins to latest.
+ */
+
+import { color, log, run, listPlugins, claudeVersion } from "./utils.js";
+
+const PLUGINS_TO_UPDATE = [
+  "curdx-flow@curdx-flow-marketplace",
+  "pua@pua-skills",
+  "claude-mem@thedotmack",
+  "frontend-design@claude-plugins-official",
+];
+
+export async function upgrade(args = []) {
+  log.title("⬆️  CurDX-Flow upgrade");
+
+  if (!claudeVersion()) {
+    log.err("claude CLI not found");
+    process.exit(1);
+  }
+
+  // Refresh marketplaces first
+  log.step(1, 2, "Refreshing marketplaces...");
+  const marketplaces = ["curdx-flow-marketplace", "pua", "thedotmack"];
+  for (const mp of marketplaces) {
+    const r = await run(
+      "claude",
+      ["plugin", "marketplace", "update", mp],
+      { silent: true }
+    );
+    if (r.code === 0) {
+      log.ok(`   ${mp}`);
+    } else {
+      // Not a fatal — might not be added
+      if (!r.stderr.includes("not found")) {
+        log.warn(`   ${mp}: ${r.stderr.trim().split("\n").pop()}`);
+      }
+    }
+  }
+
+  // Update each plugin
+  log.blank();
+  log.step(2, 2, "Updating installed plugins...");
+  const installed = listPlugins();
+  const installedNames = new Set(installed.map((p) => p.name));
+
+  for (const spec of PLUGINS_TO_UPDATE) {
+    const pluginName = spec.split("@")[0];
+    if (!installedNames.has(pluginName)) {
+      log.info(`   ${pluginName.padEnd(22)} not installed, skipping`);
+      continue;
+    }
+
+    const r = await run("claude", ["plugin", "update", spec], { silent: true });
+    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)} ${r.stderr.trim().split("\n").pop()}`);
+    }
+  }
+
+  log.blank();
+  log.ok("Upgrade complete");
+  console.log(color.dim("   Some changes require a Claude Code restart to take effect"));
+}