@curdx/flow 1.1.1

package/cli/utils.js

@@ -0,0 +1,337 @@
+/**
+ * Shared utilities for curdx-flow CLI.
+ * Zero npm deps — only Node built-ins.
+ */
+
+import { spawn, spawnSync } from "node:child_process";
+import { createInterface } from "node:readline";
+
+export const VERSION = "1.1.1";
+
+// ---------- Color helpers (no chalk dep) ----------
+const isTTY = process.stdout.isTTY && process.env.TERM !== "dumb";
+const c = (code) => (s) => isTTY ? `\x1b[${code}m${s}\x1b[0m` : String(s);
+
+export const color = {
+  red: c("31"),
+  green: c("32"),
+  yellow: c("33"),
+  blue: c("34"),
+  magenta: c("35"),
+  cyan: c("36"),
+  dim: c("2"),
+  bold: c("1"),
+  underline: c("4"),
+};
+
+// ---------- Logging helpers ----------
+export const log = {
+  info: (msg) => console.log(`${color.cyan("ℹ")}  ${msg}`),
+  ok: (msg) => console.log(`${color.green("✓")}  ${msg}`),
+  warn: (msg) => console.log(`${color.yellow("⚠")}  ${msg}`),
+  err: (msg) => console.error(`${color.red("✗")}  ${msg}`),
+  step: (n, total, msg) =>
+    console.log(`${color.dim(`[${n}/${total}]`)} ${msg}`),
+  blank: () => console.log(""),
+  title: (msg) => console.log(`\n${color.bold(msg)}\n`),
+};
+
+// ---------- Run shell command ----------
+/**
+ * Run a command, stream output live. Returns { code, stdout, stderr }.
+ */
+export function run(cmd, args = [], opts = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      stdio: opts.silent ? ["ignore", "pipe", "pipe"] : "inherit",
+      env: { ...process.env, ...opts.env },
+      cwd: opts.cwd || process.cwd(),
+      shell: false,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    if (opts.silent) {
+      child.stdout.on("data", (d) => (stdout += d.toString()));
+      child.stderr.on("data", (d) => (stderr += d.toString()));
+    }
+
+    child.on("close", (code) => resolve({ code, stdout, stderr }));
+    child.on("error", (err) => resolve({ code: -1, stdout: "", stderr: err.message }));
+  });
+}
+
+/**
+ * Sync run — for quick checks (e.g. "which claude").
+ */
+export function runSync(cmd, args = []) {
+  const res = spawnSync(cmd, args, { encoding: "utf-8", shell: false });
+  return {
+    code: res.status ?? -1,
+    stdout: res.stdout ?? "",
+    stderr: res.stderr ?? "",
+  };
+}
+
+// ---------- Check if a command exists ----------
+export function has(cmd) {
+  const res = runSync("which", [cmd]);
+  return res.code === 0 && res.stdout.trim().length > 0;
+}
+
+// ---------- Interactive prompts (readline, no deps) ----------
+/**
+ * Ask user a yes/no question. Default applies on empty input.
+ */
+export function confirm(message, defaultYes = true) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    const hint = defaultYes ? "[Y/n]" : "[y/N]";
+    rl.question(`${color.cyan("?")}  ${message} ${color.dim(hint)} `, (ans) => {
+      rl.close();
+      const v = ans.trim().toLowerCase();
+      if (v === "") return resolve(defaultYes);
+      resolve(v === "y" || v === "yes");
+    });
+  });
+}
+
+/**
+ * Ask user to pick from a list. Returns selected value or null if aborted.
+ */
+export function select(message, choices, defaultIndex = 0) {
+  return new Promise((resolve) => {
+    console.log(`${color.cyan("?")}  ${message}`);
+    choices.forEach((ch, i) => {
+      const marker = i === defaultIndex ? color.green("▸") : " ";
+      console.log(`   ${marker} ${color.bold(String(i + 1))}. ${ch.label}`);
+    });
+
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(
+      `   ${color.dim(`(default: ${defaultIndex + 1}, q to abort) `)}`,
+      (ans) => {
+        rl.close();
+        const v = ans.trim().toLowerCase();
+        if (v === "q") return resolve(null);
+        if (v === "") return resolve(choices[defaultIndex].value);
+        const n = parseInt(v, 10);
+        if (Number.isInteger(n) && n >= 1 && n <= choices.length) {
+          return resolve(choices[n - 1].value);
+        }
+        console.log(color.yellow("  (invalid, using default)"));
+        resolve(choices[defaultIndex].value);
+      }
+    );
+  });
+}
+
+/**
+ * Multi-select (checkbox-style via comma-separated input).
+ * Returns array of selected values.
+ */
+export function multiSelect(message, choices, defaults = null) {
+  return new Promise((resolve) => {
+    const defaultSet = new Set(
+      defaults ?? choices.map((_, i) => i)
+    );
+    console.log(`${color.cyan("?")}  ${message}`);
+    choices.forEach((ch, i) => {
+      const checked = defaultSet.has(i)
+        ? color.green("[x]")
+        : color.dim("[ ]");
+      console.log(`   ${checked} ${color.bold(String(i + 1))}. ${ch.label}${ch.hint ? color.dim(` — ${ch.hint}`) : ""}`);
+    });
+    console.log(
+      color.dim(
+        "   (comma-separated selection, e.g. 1,3  |  a=all  |  n=none  |  Enter=default)"
+      )
+    );
+
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(`   > `, (ans) => {
+      rl.close();
+      const v = ans.trim().toLowerCase();
+      let selected;
+      if (v === "") {
+        selected = [...defaultSet];
+      } else if (v === "a" || v === "all") {
+        selected = choices.map((_, i) => i);
+      } else if (v === "n" || v === "none") {
+        selected = [];
+      } else {
+        selected = v
+          .split(/[,\s]+/)
+          .map((x) => parseInt(x, 10) - 1)
+          .filter((i) => Number.isInteger(i) && i >= 0 && i < choices.length);
+      }
+      resolve(selected.map((i) => choices[i].value));
+    });
+  });
+}
+
+// ---------- Claude CLI helpers ----------
+/** Get claude CLI version, or null if not installed. */
+export function claudeVersion() {
+  if (!has("claude")) return null;
+  const res = runSync("claude", ["--version"]);
+  if (res.code !== 0) return null;
+  // Output like "2.1.114 (Claude Code)"
+  const m = res.stdout.match(/(\d+\.\d+\.\d+)/);
+  return m ? m[1] : res.stdout.trim().split("\n")[0];
+}
+
+/** List installed plugins via `claude plugin list`. Returns array of { name, version, status }. */
+export function listPlugins() {
+  const res = runSync("claude", ["plugin", "list"]);
+  if (res.code !== 0) return [];
+  const out = res.stdout;
+  const plugins = [];
+  // Parse format like:
+  //   ❯ curdx-flow@curdx-flow-marketplace
+  //     Version: 1.1.1
+  //     Scope: user
+  //     Status: ✔ enabled
+  const blocks = out.split(/\n\s*❯\s*/).slice(1);
+  for (const block of blocks) {
+    const lines = block.split("\n");
+    const name = lines[0].trim().split("@")[0];
+    const version = (block.match(/Version:\s*(\S+)/) || [])[1];
+    const status = block.includes("✔") ? "enabled" : block.includes("✘") ? "failed" : "unknown";
+    plugins.push({ name, version, status, raw: block });
+  }
+  return plugins;
+}
+
+/** List MCPs via `claude mcp list`. Returns array of { name, status }. */
+export function listMcps() {
+  const res = runSync("claude", ["mcp", "list"]);
+  if (res.code !== 0) return [];
+  const lines = res.stdout.split("\n");
+  const mcps = [];
+  for (const line of lines) {
+    // Rough parse — adjust if format differs
+    const m = line.match(/^\s*([a-z0-9-]+)\s*[:\-]/i);
+    if (m) mcps.push({ name: m[1], status: "registered" });
+  }
+  return mcps;
+}
+
+// ---------- Paths ----------
+export function pluginCacheDir(pluginName = "curdx-flow", marketplace = "curdx-flow-marketplace") {
+  return `${process.env.HOME}/.claude/plugins/cache/${marketplace}/${pluginName}`;
+}
+
+// ---------- Runtime PATH guards (bun / uv) ----------
+// claude-mem hard-codes `command: "bun"` in its .mcp.json, but bun installs to
+// ~/.bun/bin which is not on PATH when Claude Code spawns MCP servers
+// (macOS non-interactive shells do not source .zshrc). This module provides
+// detection + self-healing: create a symlink to the user-level bun install
+// in a PATH-visible directory.
+
+import { existsSync, mkdirSync, symlinkSync, lstatSync, unlinkSync, readlinkSync } from "node:fs";
+import { join } from "node:path";
+
+const HOME = process.env.HOME || "";
+
+/** Candidate bun install locations (priority order) */
+const BUN_CANDIDATES = [
+  join(HOME, ".bun", "bin", "bun"),
+  "/opt/homebrew/bin/bun",
+  "/usr/local/bin/bun",
+  "/home/linuxbrew/.linuxbrew/bin/bun",
+];
+
+/** Candidate uv install locations */
+const UV_CANDIDATES = [
+  join(HOME, ".local", "bin", "uv"),
+  join(HOME, ".cargo", "bin", "uv"),
+  "/opt/homebrew/bin/uv",
+  "/usr/local/bin/uv",
+];
+
+/** PATH-visible directories where symlinks can be created (priority order; use if exists, else try to create) */
+const SYMLINK_TARGET_DIRS = [
+  join(HOME, ".local", "bin"),
+  join(HOME, ".npm-global", "bin"),
+];
+
+/** Find the absolute path of a runtime that actually exists */
+function findRuntime(candidates) {
+  for (const p of candidates) if (existsSync(p)) return p;
+  return null;
+}
+
+/** Whether the current PATH can resolve this command */
+function inPath(cmd) {
+  return has(cmd);
+}
+
+/** Find a writable PATH-visible directory for symlink creation */
+function findSymlinkDir() {
+  const pathDirs = (process.env.PATH || "").split(":").filter(Boolean);
+  for (const d of SYMLINK_TARGET_DIRS) {
+    if (pathDirs.includes(d)) {
+      try {
+        if (!existsSync(d)) mkdirSync(d, { recursive: true });
+        return d;
+      } catch {
+        // continue
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Ensure cmd is resolvable on PATH. If it is installed but not visible
+ * on PATH, create a symlink automatically.
+ * @returns {{status:"ok"|"linked"|"missing"|"path-unwritable", path?:string, link?:string}}
+ */
+export function ensureRuntimeInPath(cmd, candidates) {
+  if (inPath(cmd)) return { status: "ok" };
+
+  const realPath = findRuntime(candidates);
+  if (!realPath) return { status: "missing" };
+
+  const linkDir = findSymlinkDir();
+  if (!linkDir) return { status: "path-unwritable", path: realPath };
+
+  const linkPath = join(linkDir, cmd);
+  // If it already exists and points to the same target, return idempotently
+  if (existsSync(linkPath)) {
+    try {
+      const stat = lstatSync(linkPath);
+      if (stat.isSymbolicLink() && readlinkSync(linkPath) === realPath) {
+        return { status: "ok", path: realPath, link: linkPath };
+      }
+      // Old symlink/file points elsewhere — overwrite
+      unlinkSync(linkPath);
+    } catch {
+      // ignore
+    }
+  }
+  try {
+    symlinkSync(realPath, linkPath);
+    return { status: "linked", path: realPath, link: linkPath };
+  } catch (err) {
+    return { status: "path-unwritable", path: realPath };
+  }
+}
+
+/** One-shot: ensure both bun and uv (claude-mem's runtimes) are resolvable on PATH */
+export function ensureClaudeMemRuntimes() {
+  return {
+    bun: ensureRuntimeInPath("bun", BUN_CANDIDATES),
+    uv: ensureRuntimeInPath("uv", UV_CANDIDATES),
+  };
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@curdx/flow",
+  "version": "1.1.1",
+  "description": "CLI installer for CurDX-Flow — AI engineering workflow meta-framework for Claude Code",
+  "type": "module",
+  "bin": {
+    "curdx-flow": "bin/curdx-flow.js"
+  },
+  "scripts": {
+    "prepublishOnly": "node bin/curdx-flow.js --version"
+  },
+  "files": [
+    "bin/",
+    "cli/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/curdx/curdx-flow.git"
+  },
+  "homepage": "https://github.com/curdx/curdx-flow",
+  "bugs": "https://github.com/curdx/curdx-flow/issues",
+  "license": "MIT",
+  "author": "wdx <bydongxin@gmail.com>",
+  "keywords": [
+    "claude-code",
+    "cli",
+    "installer",
+    "ai-engineering",
+    "curdx-flow"
+  ]
+}