@curdx/flow 3.0.0 → 3.1.0

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

@@ -1,196 +0,0 @@
-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/frontmatter.js

@@ -1,44 +0,0 @@
-import { readFileSync } from "node:fs";
-import YAML from "yaml";
-
-function formatYamlErrors(errors) {
-  return errors.map((error) => error.message).join("; ");
-}
-
-export function extractFrontmatterBlock(text, sourceLabel = "frontmatter") {
-  const match = text.match(/^---\n([\s\S]*?)\n---(?:\n|$)/);
-  if (!match) {
-    throw new Error(`${sourceLabel}: missing YAML frontmatter`);
-  }
-
-  return match[1];
-}
-
-export function parseFrontmatterBlock(block, sourceLabel = "frontmatter") {
-  const document = YAML.parseDocument(block, {
-    strict: true,
-    uniqueKeys: true,
-  });
-
-  if (document.errors.length > 0) {
-    throw new Error(`${sourceLabel}: invalid YAML (${formatYamlErrors(document.errors)})`);
-  }
-
-  const value = document.toJS();
-  if (value == null) return {};
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${sourceLabel}: frontmatter must parse to an object`);
-  }
-
-  return value;
-}
-
-export function readFrontmatter(filePath) {
-  const text = readFileSync(filePath, "utf-8");
-  const block = extractFrontmatterBlock(text, filePath);
-  return parseFrontmatterBlock(block, filePath);
-}
-
-export function readFrontmatterFields(filePath) {
-  return Object.keys(readFrontmatter(filePath));
-}

package/cli/lib/json-schema.js

@@ -1,57 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import Ajv from "ajv";
-
-const ajv = new Ajv({
-  allErrors: true,
-  allowUnionTypes: true,
-  strict: false,
-});
-
-const validatorCache = new Map();
-
-function formatParams(params = {}) {
-  if (params.missingProperty) return ` missingProperty=${params.missingProperty}`;
-  if (params.additionalProperty) return ` additionalProperty=${params.additionalProperty}`;
-  return "";
-}
-
-export function readJsonFile(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf-8"));
-}
-
-export function formatAjvErrors(errors = []) {
-  return errors.map((error) => {
-    const where = error.instancePath || error.schemaPath || "(root)";
-    return `${where}: ${error.message}${formatParams(error.params)}`;
-  });
-}
-
-function getSchemaValidator(schemaPath) {
-  const absPath = resolve(schemaPath);
-  if (validatorCache.has(absPath)) return validatorCache.get(absPath);
-
-  const schema = readJsonFile(absPath);
-  const validate = ajv.compile(schema);
-  const entry = { absPath, schema, validate };
-  validatorCache.set(absPath, entry);
-  return entry;
-}
-
-export function validateAgainstSchemaFile(schemaPath, data) {
-  const { validate } = getSchemaValidator(schemaPath);
-  const valid = Boolean(validate(data));
-  return {
-    valid,
-    errors: valid ? [] : formatAjvErrors(validate.errors),
-  };
-}
-
-export function validateSchemaFile(schemaPath) {
-  const schema = readJsonFile(resolve(schemaPath));
-  const valid = ajv.validateSchema(schema);
-  return {
-    valid,
-    errors: valid ? [] : formatAjvErrors(ajv.errors),
-  };
-}

package/cli/lib/logging.js

@@ -1,25 +0,0 @@
-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"),
-};
-
-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`),
-};

package/cli/lib/process.js

@@ -1,60 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-
-/**
- * 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 = [], opts = {}) {
-  const res = spawnSync(cmd, args, {
-    encoding: "utf-8",
-    shell: false,
-    cwd: opts.cwd,
-    env: opts.env ? { ...process.env, ...opts.env } : process.env,
-  });
-  return {
-    code: res.status ?? -1,
-    stdout: res.stdout ?? "",
-    stderr: res.stderr ?? "",
-  };
-}
-
-export function has(cmd) {
-  const res = runSync("which", [cmd]);
-  return res.code === 0 && res.stdout.trim().length > 0;
-}
-
-export function resultOutput(result) {
-  return (result?.stderr || "").trim() || (result?.stdout || "").trim();
-}
-
-export function resultLastLine(result) {
-  const output = resultOutput(result);
-  if (!output) return "";
-  const lines = output.split(/\r?\n/).filter(Boolean);
-  return lines.at(-1) || "";
-}

package/cli/lib/prompts.js

@@ -1,135 +0,0 @@
-import { createInterface } from "node:readline";
-
-import { color } from "./logging.js";
-
-let _clack = null;
-
-async function getClack() {
-  if (!_clack) {
-    _clack = await import("@clack/prompts");
-  }
-  return _clack;
-}
-
-async function handleCancel(value, message = "Operation cancelled") {
-  const clack = await getClack();
-  if (clack.isCancel(value)) {
-    clack.cancel(message);
-    process.exit(0);
-  }
-  return false;
-}
-
-export async function select(options) {
-  const clack = await getClack();
-  const result = await clack.select({
-    message: options.message,
-    options: options.options,
-    initialValue: options.initialValue,
-  });
-  await handleCancel(result);
-  return result;
-}
-
-export async function multiselectClack(options) {
-  const clack = await getClack();
-  const result = await clack.multiselect({
-    message: options.message,
-    options: options.options,
-    initialValues: options.initialValues || [],
-    required: options.required !== undefined ? options.required : false,
-  });
-  await handleCancel(result);
-  return result;
-}
-
-export async function text(options) {
-  const clack = await getClack();
-  const result = await clack.text({
-    message: options.message,
-    placeholder: options.placeholder,
-    defaultValue: options.defaultValue,
-    validate: options.validate,
-  });
-  await handleCancel(result);
-  return result;
-}
-
-export async function spinner() {
-  const clack = await getClack();
-  return clack.spinner();
-}
-
-export async function intro(message) {
-  const clack = await getClack();
-  clack.intro(message);
-}
-
-export async function outro(message) {
-  const clack = await getClack();
-  clack.outro(message);
-}
-
-export async function note(message, title) {
-  const clack = await getClack();
-  clack.note(message, title);
-}
-
-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");
-    });
-  });
-}
-
-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));
-    });
-  });
-}

package/cli/lib/runtime.js

@@ -1,107 +0,0 @@
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readlinkSync,
-  symlinkSync,
-  unlinkSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-import { has } from "./process.js";
-
-const HOME = homedir();
-
-const BUN_CANDIDATES = [
-  join(HOME, ".bun", "bin", "bun"),
-  "/opt/homebrew/bin/bun",
-  "/usr/local/bin/bun",
-  "/home/linuxbrew/.linuxbrew/bin/bun",
-];
-
-const UV_CANDIDATES = [
-  join(HOME, ".local", "bin", "uv"),
-  join(HOME, ".cargo", "bin", "uv"),
-  "/opt/homebrew/bin/uv",
-  "/usr/local/bin/uv",
-];
-
-const SYMLINK_TARGET_DIRS = [
-  join(HOME, ".local", "bin"),
-  join(HOME, ".npm-global", "bin"),
-];
-
-function findRuntime(candidates) {
-  for (const p of candidates) if (existsSync(p)) return p;
-  return null;
-}
-
-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;
-}
-
-function getRuntimeStatus(cmd, candidates, { repair = false } = {}) {
-  if (has(cmd)) return { status: "ok" };
-  const realPath = findRuntime(candidates);
-  if (!realPath) return { status: "missing" };
-
-  const linkDir = findSymlinkDir();
-  if (!linkDir) return { status: "path-unwritable", path: realPath };
-
-  if (!repair) {
-    return { status: "linkable", path: realPath, link: join(linkDir, cmd) };
-  }
-
-  const linkPath = join(linkDir, cmd);
-  if (existsSync(linkPath)) {
-    try {
-      const stat = lstatSync(linkPath);
-      if (stat.isSymbolicLink() && readlinkSync(linkPath) === realPath) {
-        return { status: "ok", path: realPath, link: linkPath };
-      }
-      unlinkSync(linkPath);
-    } catch {
-      // ignore
-    }
-  }
-  try {
-    symlinkSync(realPath, linkPath);
-    return { status: "linked", path: realPath, link: linkPath };
-  } catch {
-    return { status: "path-unwritable", path: realPath };
-  }
-}
-
-export function inspectRuntimeInPath(cmd, candidates) {
-  return getRuntimeStatus(cmd, candidates, { repair: false });
-}
-
-export function ensureRuntimeInPath(cmd, candidates) {
-  return getRuntimeStatus(cmd, candidates, { repair: true });
-}
-
-export function inspectClaudeMemRuntimes() {
-  return {
-    bun: inspectRuntimeInPath("bun", BUN_CANDIDATES),
-    uv: inspectRuntimeInPath("uv", UV_CANDIDATES),
-  };
-}
-
-export function ensureClaudeMemRuntimes() {
-  return {
-    bun: ensureRuntimeInPath("bun", BUN_CANDIDATES),
-    uv: ensureRuntimeInPath("uv", UV_CANDIDATES),
-  };
-}