@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-U3EO3X4B.mjs

@@ -0,0 +1,649 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  listServices
+} from "./flow-weaver-chunk-MSI2UJES.mjs";
+import {
+  load
+} from "./flow-weaver-chunk-3BSYCWPL.mjs";
+import {
+  VERSION
+} from "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import {
+  MIN_NODE_MAJOR
+} from "./flow-weaver-chunk-DRN7KPWY.mjs";
+
+// src/cli/commands/doctor.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+function stripJsonComments(text) {
+  let result = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === '"') {
+      const start = i;
+      i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === "\\") i++;
+        i++;
+      }
+      i++;
+      result += text.slice(start, i);
+      continue;
+    }
+    if (text[i] === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      continue;
+    }
+    if (text[i] === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    result += text[i];
+    i++;
+  }
+  return result;
+}
+function detectProjectModuleFormat(cwd) {
+  const pkgPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      if (pkg.type === "module") {
+        return { format: "esm", source: "package.json", details: '"type": "module"' };
+      }
+      if (pkg.type === "commonjs" || !pkg.type) {
+        return {
+          format: "cjs",
+          source: "package.json",
+          details: pkg.type ? '"type": "commonjs"' : 'no "type" field (defaults to CommonJS)'
+        };
+      }
+    } catch {
+    }
+  }
+  const { parsed } = readTsconfig(cwd);
+  if (parsed) {
+    const compilerOptions = parsed.compilerOptions ?? {};
+    const mod = typeof compilerOptions.module === "string" ? compilerOptions.module.toLowerCase() : void 0;
+    if (mod === "commonjs") {
+      return { format: "cjs", source: "tsconfig", details: '"module": "commonjs"' };
+    }
+    if (mod && ["es2015", "es2020", "es2022", "esnext", "nodenext", "node16"].includes(mod)) {
+      return {
+        format: "esm",
+        source: "tsconfig",
+        details: `"module": "${compilerOptions.module}"`
+      };
+    }
+  }
+  return { format: "esm", source: "default", details: "defaulting to ESM" };
+}
+var PACKAGE_NAME = "@synergenius/flow-weaver";
+function realpathOr(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function isFlowWeaverPackageRoot(dir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+    return pkg.name === PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
+function serverInstallInfo() {
+  let here;
+  try {
+    here = path.dirname(fileURLToPath(import.meta.url));
+  } catch {
+    here = __dirname;
+  }
+  let dir = here;
+  for (let depth = 0; depth < 8; depth++) {
+    if (isFlowWeaverPackageRoot(dir)) {
+      return { version: VERSION, installPath: realpathOr(dir) };
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { version: VERSION, installPath: realpathOr(here) };
+}
+function checkServerInstall(cwd) {
+  const { version, installPath } = serverInstallInfo();
+  const checked = realpathOr(path.resolve(cwd));
+  if (isFlowWeaverPackageRoot(checked) && checked !== installPath) {
+    return {
+      name: "Running install",
+      status: "warn",
+      message: `This is a Flow Weaver checkout, but the running server is ${PACKAGE_NAME} ${version} from ${installPath}`,
+      fix: `Edits and rebuilds here do not reach the running server. Restart the MCP server from ${path.join(checked, "dist", "cli", "flow-weaver.mjs")}, or rebuild the install it runs from.`
+    };
+  }
+  return {
+    name: "Running install",
+    status: "pass",
+    message: `${PACKAGE_NAME} ${version} running from ${installPath}`
+  };
+}
+function checkNodeVersion(version = process.version) {
+  const major = parseInt(version.slice(1), 10);
+  if (major >= MIN_NODE_MAJOR) {
+    return {
+      name: "Node.js version",
+      status: "pass",
+      message: `Node.js ${version} (>= ${MIN_NODE_MAJOR} required)`
+    };
+  }
+  return {
+    name: "Node.js version",
+    status: "fail",
+    message: `Node.js ${version} is below the minimum (${MIN_NODE_MAJOR})`,
+    fix: `Install Node.js ${MIN_NODE_MAJOR} or later: https://nodejs.org`
+  };
+}
+function checkTypeScriptVersion(cwd) {
+  const tsPath = path.join(cwd, "node_modules", "typescript", "package.json");
+  if (!fs.existsSync(tsPath)) {
+    return {
+      name: "TypeScript version",
+      status: "fail",
+      message: "TypeScript is not installed locally",
+      fix: "npm install -D typescript"
+    };
+  }
+  try {
+    const tsPkg = JSON.parse(fs.readFileSync(tsPath, "utf8"));
+    const major = parseInt(tsPkg.version.split(".")[0], 10);
+    if (major >= 5) {
+      return {
+        name: "TypeScript version",
+        status: "pass",
+        message: `TypeScript ${tsPkg.version} (>= 5.0 required)`
+      };
+    }
+    return {
+      name: "TypeScript version",
+      status: "fail",
+      message: `TypeScript ${tsPkg.version} is below the minimum (5.0)`,
+      fix: "npm install -D typescript@latest"
+    };
+  } catch {
+    return {
+      name: "TypeScript version",
+      status: "fail",
+      message: "Could not read TypeScript version",
+      fix: "npm install -D typescript@latest"
+    };
+  }
+}
+function checkPackageJsonType(cwd) {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    return {
+      name: 'package.json "type"',
+      status: "fail",
+      message: "No package.json found",
+      fix: "Run npm init -y"
+    };
+  }
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    if (pkg.type === "module") {
+      return {
+        name: 'package.json "type"',
+        status: "pass",
+        message: '"type": "module" is set (ESM project)'
+      };
+    }
+    if (pkg.type === "commonjs") {
+      return {
+        name: 'package.json "type"',
+        status: "pass",
+        message: '"type": "commonjs" is set (CJS project)'
+      };
+    }
+    return {
+      name: 'package.json "type"',
+      status: "pass",
+      message: 'No "type" field (defaults to CommonJS)',
+      details: 'Add "type": "module" if you prefer ESM'
+    };
+  } catch {
+    return {
+      name: 'package.json "type"',
+      status: "fail",
+      message: "Could not parse package.json",
+      fix: "Fix JSON syntax in package.json"
+    };
+  }
+}
+function readTsconfigAt(tsconfigPath, compilerOptions, depth) {
+  if (depth > 10 || !fs.existsSync(tsconfigPath)) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(stripJsonComments(fs.readFileSync(tsconfigPath, "utf8")));
+  } catch {
+    return;
+  }
+  const base = parsed.extends;
+  const bases = typeof base === "string" ? [base] : Array.isArray(base) ? base : [];
+  for (const b of bases) {
+    if (typeof b !== "string") continue;
+    readTsconfigAt(resolveExtends(b, path.dirname(tsconfigPath)), compilerOptions, depth + 1);
+  }
+  const own = parsed.compilerOptions ?? {};
+  Object.assign(compilerOptions, own);
+}
+function resolveExtends(ref, fromDir) {
+  if (ref.startsWith(".") || ref.startsWith("/")) {
+    return ref.endsWith(".json") ? path.resolve(fromDir, ref) : path.resolve(fromDir, `${ref}.json`);
+  }
+  const withExt = ref.endsWith(".json") ? ref : `${ref}/tsconfig.json`;
+  return path.join(fromDir, "node_modules", withExt);
+}
+function readTsconfig(cwd) {
+  const tsconfigPath = path.join(cwd, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) {
+    return { parsed: null, error: "No tsconfig.json found" };
+  }
+  try {
+    JSON.parse(stripJsonComments(fs.readFileSync(tsconfigPath, "utf8")));
+  } catch {
+    return { parsed: null, error: "Could not parse tsconfig.json" };
+  }
+  const compilerOptions = {};
+  readTsconfigAt(tsconfigPath, compilerOptions, 0);
+  return { parsed: { compilerOptions } };
+}
+function checkTsconfigModule(cwd) {
+  const { parsed, error } = readTsconfig(cwd);
+  if (!parsed) {
+    return {
+      name: 'tsconfig "module"',
+      status: "warn",
+      message: error ?? "No tsconfig.json found",
+      fix: 'Create a tsconfig.json with appropriate "module" setting'
+    };
+  }
+  const compilerOptions = parsed.compilerOptions ?? {};
+  const mod = typeof compilerOptions.module === "string" ? compilerOptions.module.toLowerCase() : void 0;
+  if (!mod) {
+    return {
+      name: 'tsconfig "module"',
+      status: "warn",
+      message: '"module" is not set in compilerOptions',
+      fix: 'Set "module" in tsconfig.json compilerOptions (e.g., "nodenext" for ESM, "commonjs" for CJS)'
+    };
+  }
+  const detection = detectProjectModuleFormat(cwd);
+  if (mod === "commonjs") {
+    if (detection.format === "cjs") {
+      return {
+        name: 'tsconfig "module"',
+        status: "pass",
+        message: '"module": "commonjs" (CJS project)'
+      };
+    }
+    return {
+      name: 'tsconfig "module"',
+      status: "warn",
+      message: '"module" is "commonjs" but package.json suggests ESM',
+      fix: 'Align tsconfig.json "module" with package.json "type"'
+    };
+  }
+  const esmModules = ["es2015", "es2020", "es2022", "esnext", "nodenext", "node16"];
+  if (esmModules.includes(mod)) {
+    if (detection.format === "esm") {
+      return {
+        name: 'tsconfig "module"',
+        status: "pass",
+        message: `"module": "${compilerOptions.module}" (ESM project)`
+      };
+    }
+    return {
+      name: 'tsconfig "module"',
+      status: "warn",
+      message: `"module" is "${compilerOptions.module}" but package.json suggests CJS`,
+      fix: 'Align tsconfig.json "module" with package.json "type"'
+    };
+  }
+  return {
+    name: 'tsconfig "module"',
+    status: "pass",
+    message: `"module": "${compilerOptions.module}"`
+  };
+}
+function checkTsconfigModuleResolution(cwd) {
+  const { parsed, error } = readTsconfig(cwd);
+  if (!parsed) {
+    return {
+      name: 'tsconfig "moduleResolution"',
+      status: "warn",
+      message: error ?? "No tsconfig.json found",
+      fix: 'Create a tsconfig.json with "moduleResolution": "nodenext" or "bundler"'
+    };
+  }
+  const compilerOptions = parsed.compilerOptions ?? {};
+  const res = typeof compilerOptions.moduleResolution === "string" ? compilerOptions.moduleResolution.toLowerCase() : void 0;
+  if (!res) {
+    return {
+      name: 'tsconfig "moduleResolution"',
+      status: "warn",
+      message: '"moduleResolution" is not set in compilerOptions',
+      fix: 'Set "moduleResolution": "nodenext" in tsconfig.json compilerOptions'
+    };
+  }
+  if (res === "node") {
+    return {
+      name: 'tsconfig "moduleResolution"',
+      status: "fail",
+      message: '"moduleResolution" is "node" (Node10), which cannot resolve ESM exports',
+      fix: 'Set "moduleResolution": "nodenext" or "bundler" in tsconfig.json'
+    };
+  }
+  return {
+    name: 'tsconfig "moduleResolution"',
+    status: "pass",
+    message: `"moduleResolution": "${compilerOptions.moduleResolution}"`
+  };
+}
+function checkFlowWeaverInstalled(cwd) {
+  if (isFlowWeaverPackageRoot(realpathOr(path.resolve(cwd)))) {
+    return {
+      name: "@synergenius/flow-weaver installed",
+      status: "pass",
+      message: "This is the Flow Weaver source checkout (not a dependency)"
+    };
+  }
+  const pkgPath = path.join(cwd, "node_modules", "@synergenius", "flow-weaver", "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      return {
+        name: "@synergenius/flow-weaver installed",
+        status: "pass",
+        message: `@synergenius/flow-weaver ${pkg.version} is installed`
+      };
+    } catch {
+      return {
+        name: "@synergenius/flow-weaver installed",
+        status: "pass",
+        message: "@synergenius/flow-weaver is installed"
+      };
+    }
+  }
+  return {
+    name: "@synergenius/flow-weaver installed",
+    status: "fail",
+    message: "@synergenius/flow-weaver is not installed",
+    fix: "npm install @synergenius/flow-weaver"
+  };
+}
+function checkFlowWeaverVersion(cwd) {
+  const libraryPath = path.join(cwd, "node_modules", "@synergenius", "flow-weaver");
+  const pkgPath = path.join(libraryPath, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    return {
+      name: "Library version",
+      status: "pass",
+      message: "Skipped (library not installed)"
+    };
+  }
+  try {
+    const projectPkgPath = path.join(cwd, "package.json");
+    if (fs.existsSync(projectPkgPath)) {
+      const projectPkg = JSON.parse(fs.readFileSync(projectPkgPath, "utf8"));
+      const depSpec = projectPkg.dependencies?.["@synergenius/flow-weaver"] ?? projectPkg.devDependencies?.["@synergenius/flow-weaver"];
+      if (typeof depSpec === "string" && (depSpec.startsWith("file:") || depSpec.startsWith("link:") || depSpec.startsWith("workspace:"))) {
+        return {
+          name: "Library version",
+          status: "pass",
+          message: "Local dependency (version check skipped)"
+        };
+      }
+    }
+    if (fs.lstatSync(libraryPath).isSymbolicLink()) {
+      return {
+        name: "Library version",
+        status: "pass",
+        message: "Linked dependency (version check skipped)"
+      };
+    }
+  } catch {
+  }
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const currentVersion = pkg.version;
+    const latestVersion = execSync("npm view @synergenius/flow-weaver version", {
+      timeout: 5e3,
+      stdio: "pipe"
+    }).toString().trim();
+    if (currentVersion === latestVersion) {
+      return {
+        name: "Library version",
+        status: "pass",
+        message: `@synergenius/flow-weaver ${currentVersion} is up to date`
+      };
+    }
+    return {
+      name: "Library version",
+      status: "warn",
+      message: `Library update available: ${currentVersion} \u2192 ${latestVersion}`,
+      fix: "npm update @synergenius/flow-weaver"
+    };
+  } catch {
+    return {
+      name: "Library version",
+      status: "pass",
+      message: "Could not check for updates (registry unreachable)"
+    };
+  }
+}
+function checkTypesNodeInstalled(cwd) {
+  const pkgPath = path.join(cwd, "node_modules", "@types", "node", "package.json");
+  if (fs.existsSync(pkgPath)) {
+    return {
+      name: "@types/node installed",
+      status: "pass",
+      message: "@types/node is installed"
+    };
+  }
+  return {
+    name: "@types/node installed",
+    status: "warn",
+    message: "@types/node is not installed (recommended)",
+    fix: "npm install -D @types/node"
+  };
+}
+function checkTsxAvailable(cwd) {
+  const localBin = path.join(cwd, "node_modules", ".bin", "tsx");
+  if (fs.existsSync(localBin)) {
+    return {
+      name: "tsx available",
+      status: "pass",
+      message: "tsx is available (local)"
+    };
+  }
+  try {
+    execSync("tsx --version", { stdio: "pipe", timeout: 5e3 });
+    return {
+      name: "tsx available",
+      status: "pass",
+      message: "tsx is available (global)"
+    };
+  } catch {
+    return {
+      name: "tsx available",
+      status: "warn",
+      message: "tsx is not installed (recommended for running .ts files)",
+      fix: "npm install -D tsx"
+    };
+  }
+}
+var VALID_FILE_TYPES = ["ts", "tsx", "js", "jsx"];
+function readYaml(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    return { data: load(content) };
+  } catch (e) {
+    return { data: null, error: getErrorMessage(e) };
+  }
+}
+function checkProjectConfig(cwd) {
+  const configPath = path.join(cwd, ".flowweaver", "config.yaml");
+  if (!fs.existsSync(configPath)) {
+    return {
+      name: "Project config",
+      status: "warn",
+      message: ".flowweaver/config.yaml not found",
+      fix: "Create .flowweaver/config.yaml with at least: defaultFileType: ts"
+    };
+  }
+  const { data, error } = readYaml(configPath);
+  if (error || data == null) {
+    return {
+      name: "Project config",
+      status: "fail",
+      message: `Could not parse .flowweaver/config.yaml: ${error}`,
+      fix: "Fix YAML syntax in .flowweaver/config.yaml"
+    };
+  }
+  const config = data;
+  if (config.defaultFileType && !VALID_FILE_TYPES.includes(config.defaultFileType)) {
+    return {
+      name: "Project config",
+      status: "fail",
+      message: `Invalid defaultFileType "${config.defaultFileType}", must be one of: ${VALID_FILE_TYPES.join(", ")}`,
+      fix: `Set defaultFileType to one of: ${VALID_FILE_TYPES.join(", ")}`
+    };
+  }
+  return {
+    name: "Project config",
+    status: "pass",
+    message: `.flowweaver/config.yaml is valid`,
+    details: `defaultFileType: ${config.defaultFileType ?? "not set"}`
+  };
+}
+function checkRunningServices(services = listServices()) {
+  if (!services.length) return { name: "Running services", status: "pass", message: "none" };
+  const here = serverInstallInfo().installPath;
+  const lines = services.map((s) => {
+    const ago = Math.max(0, Math.round((Date.now() - Date.parse(s.lastActivityAt)) / 1e3));
+    const where = s.url ?? s.transport ?? "";
+    const client = s.client ? ` for ${s.client}` : "";
+    const last = s.activity ? `, last ${s.activity} ${ago}s ago` : "";
+    return `${s.kind} (pid ${s.pid}${where ? `, ${where}` : ""}${client}) from ${s.install}${last}`;
+  });
+  const elsewhere = services.filter((s) => s.kind === "mcp-server" && realpathOr(s.install) !== realpathOr(here));
+  return {
+    name: "Running services",
+    status: elsewhere.length ? "warn" : "pass",
+    message: lines.join("; "),
+    ...elsewhere.length ? { fix: `An MCP server runs from ${elsewhere[0].install}, not from here. Restart it from this install if this is the one you are changing.` } : {}
+  };
+}
+function runDoctorChecks(cwd) {
+  const moduleFormat = detectProjectModuleFormat(cwd);
+  const server = serverInstallInfo();
+  const services = listServices();
+  const checks = [
+    checkServerInstall(cwd),
+    checkNodeVersion(),
+    checkTypeScriptVersion(cwd),
+    checkPackageJsonType(cwd),
+    checkTsconfigModule(cwd),
+    checkTsconfigModuleResolution(cwd),
+    checkFlowWeaverInstalled(cwd),
+    checkFlowWeaverVersion(cwd),
+    checkTypesNodeInstalled(cwd),
+    checkTsxAvailable(cwd),
+    checkProjectConfig(cwd),
+    checkRunningServices(services)
+  ];
+  const summary = { pass: 0, warn: 0, fail: 0 };
+  for (const check of checks) {
+    summary[check.status]++;
+  }
+  return {
+    ok: summary.fail === 0,
+    checks,
+    summary,
+    moduleFormat,
+    server,
+    services
+  };
+}
+async function doctorCommand(options = {}) {
+  const cwd = process.cwd();
+  const report = runDoctorChecks(cwd);
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    logger.section("Flow Weaver Doctor");
+    const statusIcon = (s) => s === "pass" ? logger.highlight("pass") : s === "warn" ? "warn" : "\u2717 fail";
+    const rows = report.checks.map((check) => [
+      check.name,
+      check.message,
+      statusIcon(check.status)
+    ]);
+    logger.table(rows);
+    const fixable = report.checks.filter((c) => c.status !== "pass" && c.fix);
+    if (fixable.length > 0) {
+      logger.newline();
+      for (const check of fixable) {
+        logger.log(`  ${logger.dim(check.name + ":")} ${check.fix}`);
+      }
+    }
+    logger.newline();
+    logger.log(`  Running: ${PACKAGE_NAME} ${report.server.version} ${logger.dim(`(${report.server.installPath})`)}`);
+    logger.log(`  Module format: ${report.moduleFormat.format.toUpperCase()} ${logger.dim(`(${report.moduleFormat.details})`)}`);
+    const parts = [];
+    if (report.summary.pass > 0) parts.push(`${report.summary.pass} passed`);
+    if (report.summary.warn > 0) parts.push(`${report.summary.warn} warnings`);
+    if (report.summary.fail > 0) parts.push(`${report.summary.fail} failed`);
+    logger.log(`  ${parts.join(", ")}`);
+    if (report.ok) {
+      logger.newline();
+      logger.success("Environment is ready for flow-weaver!");
+    } else {
+      logger.newline();
+      logger.error("Fix the issues above to continue.");
+    }
+  }
+  if (!report.ok) {
+    throw new Error("Doctor found issues that need to be fixed");
+  }
+}
+
+export {
+  stripJsonComments,
+  detectProjectModuleFormat,
+  serverInstallInfo,
+  checkServerInstall,
+  checkNodeVersion,
+  checkTypeScriptVersion,
+  checkPackageJsonType,
+  checkTsconfigModule,
+  checkTsconfigModuleResolution,
+  checkFlowWeaverInstalled,
+  checkTypesNodeInstalled,
+  checkTsxAvailable,
+  checkProjectConfig,
+  runDoctorChecks,
+  doctorCommand
+};

package/dist/cli/flow-weaver-chunk-UNFS3NQP.mjs

@@ -0,0 +1,34 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+
+// src/cli/utils/json-option.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function readJsonObjectOption(inline, file, flag) {
+  if (inline) {
+    let value2;
+    try {
+      value2 = JSON.parse(inline);
+    } catch {
+      throw new Error(`Invalid JSON in --${flag}: ${inline}`);
+    }
+    if (!isObject(value2)) throw new Error(`--${flag} must be a JSON object, like {"name": "value"}`);
+    return value2;
+  }
+  if (!file) return void 0;
+  const resolved = path.resolve(file);
+  if (!fs.existsSync(resolved)) throw new Error(`${flag[0].toUpperCase()}${flag.slice(1)} file not found: ${resolved}`);
+  let value;
+  try {
+    value = JSON.parse(fs.readFileSync(resolved, "utf8"));
+  } catch {
+    throw new Error(`Failed to parse ${flag} file: ${file}`);
+  }
+  if (!isObject(value)) throw new Error(`--${flag}-file must hold a JSON object, like {"name": "value"}`);
+  return value;
+}
+
+export {
+  readJsonObjectOption
+};