@maz-ui/node 5.2.0 → 5.3.0

package/dist/shared/node.rmAtZA9U.mjs

@@ -0,0 +1,635 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync, rmSync, readdirSync } from 'node:fs';
+import { join, dirname, basename, relative, sep, posix } from 'node:path';
+import { parse, applyEdits, modify } from 'jsonc-parser';
+
+const AGENT_TARGETS = [
+  "claude",
+  "agents-md",
+  "cursor",
+  "vscode"
+];
+const MANAGED_MARKER = "Managed by maz-ui";
+const AGENTS_MD_BEGIN = "<!-- BEGIN:maz-ui -->";
+const AGENTS_MD_END = "<!-- END:maz-ui -->";
+const MCP_SERVER_NAME = "maz-ui";
+const DEFAULT_MCP_SERVER = {
+  command: "npx",
+  args: ["-y", "@maz-ui/mcp@latest"]
+};
+const MAZ_UI_AGENTS_TOOL = {
+  name: "maz-ui",
+  mcpPackage: "@maz-ui/mcp",
+  mcpBin: "maz-ui-mcp",
+  generatedBy: "`npx @maz-ui/mcp init` (or the `mazUi.agents` Nuxt option)",
+  versionNote: (version) => `> maz-ui ${version} is installed: these rules and the docs in \`node_modules/maz-ui/docs\` match this version.`,
+  packages: [
+    "maz-ui",
+    "@maz-ui/nuxt",
+    "@maz-ui/themes",
+    "@maz-ui/icons",
+    "@maz-ui/utils",
+    "@maz-ui/translations"
+  ],
+  ruleGlobs: ["**/*.{vue,ts,tsx,css,scss}"]
+};
+function escapeRegExp(value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const toolSetups = /* @__PURE__ */ new WeakMap();
+function resolveTool(tool) {
+  let setup = toolSetups.get(tool);
+  if (!setup) {
+    const marker = tool.marker ?? `Managed by ${tool.name}`;
+    setup = {
+      tool,
+      marker,
+      agentsMdBegin: `<!-- BEGIN:${tool.name} -->`,
+      agentsMdEnd: `<!-- END:${tool.name} -->`,
+      ruleFile: `.claude/rules/${tool.name}.md`,
+      managedHeader: new RegExp(`<!-- ${escapeRegExp(marker)}[^\\n]*?-->`),
+      managedVersion: new RegExp(`${escapeRegExp(marker)} (\\d[^\\s:]*)`)
+    };
+    toolSetups.set(tool, setup);
+  }
+  return setup;
+}
+function readPackageJson(rootDir) {
+  try {
+    return JSON.parse(readFileSync(join(rootDir, "package.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function installsMcpPackage(rootDir, tool = MAZ_UI_AGENTS_TOOL) {
+  const pkg = readPackageJson(rootDir);
+  return ["dependencies", "devDependencies", "optionalDependencies"].some((field) => pkg?.[field]?.[tool.mcpPackage] !== void 0);
+}
+function detectPackageManager(rootDir) {
+  const declared = String(readPackageJson(rootDir)?.packageManager ?? "").split("@")[0];
+  if (["pnpm", "yarn", "bun", "npm"].includes(declared))
+    return declared;
+  const lockfiles = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"]
+  ];
+  return lockfiles.find(([file]) => existsSync(join(rootDir, file)))?.[1] ?? "npm";
+}
+function localMcpCommands(tool) {
+  const bin = [
+    tool.mcpBin,
+    ...tool.mcpArgs ?? []
+  ];
+  return {
+    pnpm: {
+      command: "pnpm",
+      args: ["exec", ...bin]
+    },
+    yarn: {
+      command: "yarn",
+      args: ["run", ...bin]
+    },
+    bun: {
+      command: "bun",
+      args: ["x", "--no-install", ...bin]
+    },
+    npm: {
+      command: "npx",
+      args: ["--no-install", ...bin]
+    }
+  };
+}
+function mcpServerCommand(rootDir, version = "latest", tool = MAZ_UI_AGENTS_TOOL) {
+  return installsMcpPackage(rootDir, tool) ? localMcpCommands(tool)[detectPackageManager(rootDir)] : {
+    command: "npx",
+    args: [
+      "-y",
+      `${tool.mcpPackage}@${version}`,
+      ...tool.mcpArgs ?? []
+    ]
+  };
+}
+function pinnedMcpVersion(server, tool) {
+  const pinned = new RegExp(`^${escapeRegExp(tool.mcpPackage)}@(\\d\\S*)$`);
+  return server.args.map((arg) => pinned.exec(arg)?.[1]).find(Boolean);
+}
+function isGeneratedMcpCommand(server, tool) {
+  const command = [
+    server.command,
+    ...Array.isArray(server.args) ? server.args : []
+  ].join(" ");
+  const args = (tool.mcpArgs ?? []).map((arg) => ` ${escapeRegExp(arg)}`).join("");
+  return new RegExp(`^npx -y ${escapeRegExp(tool.mcpPackage)}(?:@\\S+)?${args}$`).test(command) || Object.values(localMcpCommands(tool)).some((local) => command === [local.command, ...local.args].join(" "));
+}
+const CLAUDE_MEMORY_FILES = ["CLAUDE.md", ".claude/CLAUDE.md", "CLAUDE.local.md"];
+function withVersion(content, version, tool) {
+  if (tool.versionNote === false)
+    return content;
+  const note = tool.versionNote?.(version) ?? `> ${tool.name} ${version} is installed: these rules match this version.`;
+  return content.replace(/^(#{1,2} .+)\n/, (_, title) => `${title}
+
+${note}
+`);
+}
+function checksum(body) {
+  return createHash("sha256").update(body.replaceAll(/\s+/g, "")).digest("hex").slice(0, 12);
+}
+function ruleChecksum(frontmatter, body) {
+  return checksum(frontmatter.replaceAll(/["']/g, "") + body);
+}
+function managedContent(version, body, setup, frontmatter = "") {
+  const recorded = ruleChecksum(frontmatter, body);
+  return `${frontmatter}<!-- ${setup.marker} ${version} (sha256:${recorded}): generated by ${setup.tool.generatedBy}. Do not edit: edited rules are no longer updated. Write your own rules elsewhere. -->
+
+${body}`;
+}
+function isEditedManagedContent(content, tool = MAZ_UI_AGENTS_TOOL) {
+  const header = content === void 0 ? null : resolveTool(tool).managedHeader.exec(content);
+  const recorded = header ? /\(sha256:([\da-f]+)\)/.exec(header[0])?.[1] : void 0;
+  if (header === null || recorded === void 0)
+    return false;
+  const before = content.slice(0, header.index);
+  const after = content.slice(header.index + header[0].length);
+  return recorded !== checksum(after) && recorded !== ruleChecksum(before, after);
+}
+function detectAgentTargets(rootDir) {
+  const has = (path) => existsSync(join(rootDir, path));
+  const targets = /* @__PURE__ */ new Set();
+  if (has(".claude") || CLAUDE_MEMORY_FILES.some(has) || has(".mcp.json"))
+    targets.add("claude");
+  if (has(".cursor") || has(".cursorrules"))
+    targets.add("cursor");
+  if (has(".vscode/mcp.json") || has(".github/copilot-instructions.md") || has(".github/instructions"))
+    targets.add("vscode");
+  if (has("AGENTS.md") || targets.has("cursor") || targets.has("vscode") || has(".codex") || has(".windsurf") || has(".devin") || has(".windsurfrules") || has("GEMINI.md"))
+    targets.add("agents-md");
+  return AGENT_TARGETS.filter((target) => targets.has(target));
+}
+function findInstalledPackage(fromDir, name) {
+  let directory = fromDir;
+  for (; ; ) {
+    const candidate = join(directory, "node_modules", name);
+    if (existsSync(join(candidate, "package.json")))
+      return candidate;
+    const parent = dirname(directory);
+    if (parent === directory)
+      return void 0;
+    directory = parent;
+  }
+}
+function readPackageVersion(packageDir) {
+  const file = join(packageDir, "package.json");
+  return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")).version : void 0;
+}
+const DEFAULT_WORKSPACES = ["apps/*", "packages/*"];
+const MAX_GLOBSTAR_DEPTH = 3;
+function readWorkspacePatterns(rootDir) {
+  const patterns = readDeclaredWorkspacePatterns(rootDir).filter((pattern) => !pattern.startsWith("!"));
+  return patterns.length > 0 ? patterns : DEFAULT_WORKSPACES;
+}
+function readDeclaredWorkspacePatterns(rootDir) {
+  const pnpmWorkspace = join(rootDir, "pnpm-workspace.yaml");
+  const workspaces = readPackageJson(rootDir)?.workspaces;
+  const declared = existsSync(pnpmWorkspace) ? readPnpmWorkspacePackages(readFileSync(pnpmWorkspace, "utf8")) : (Array.isArray(workspaces) ? workspaces : workspaces?.packages) ?? [];
+  return declared.map((pattern) => pattern.replace(/^(!?)\.\//, "$1").replace(/\/$/, ""));
+}
+function readPnpmWorkspacePackages(content) {
+  const patterns = [];
+  let inPackages = false;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    if (line === line.trimStart())
+      inPackages = trimmed === "packages:";
+    else if (inPackages && trimmed.startsWith("-"))
+      patterns.push(trimmed.slice(1).split("#")[0].trim().replaceAll(/^["']|["']$/g, ""));
+  }
+  return patterns;
+}
+function globToRegExp(pattern) {
+  const source = pattern.split("/").map((segment) => segment === "**" ? ".*" : segment.replaceAll(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("*", "[^/]*").replaceAll("?", "[^/]")).join("/");
+  return new RegExp(`^${source.replaceAll("/.*", "(?:/.*)?")}$`);
+}
+function findWorkspaceDirs(rootDir) {
+  const folders = /* @__PURE__ */ new Set();
+  for (const pattern of readWorkspacePatterns(rootDir)) {
+    const segments = pattern.split("/");
+    const firstGlob = segments.findIndex((segment) => /[*?[{]/.test(segment));
+    const base = (firstGlob === -1 ? segments : segments.slice(0, firstGlob)).join("/");
+    const depth = firstGlob === -1 ? 0 : segments.includes("**") ? MAX_GLOBSTAR_DEPTH : segments.length - firstGlob;
+    const matcher = globToRegExp(pattern);
+    const visit = (folder, remaining) => {
+      if (!existsSync(join(rootDir, folder)))
+        return;
+      if (folder && folder !== "." && matcher.test(folder))
+        folders.add(join(rootDir, folder));
+      if (remaining === 0)
+        return;
+      for (const entry of readdirSync(join(rootDir, folder), { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+          visit(folder ? `${folder}/${entry.name}` : entry.name, remaining - 1);
+        }
+      }
+    };
+    visit(base, depth);
+  }
+  return [...folders];
+}
+function findProjectPackage(rootDir, name) {
+  return [
+    rootDir,
+    ...findWorkspaceDirs(rootDir)
+  ].map((base) => join(base, "node_modules", name)).find((candidate) => existsSync(join(candidate, "package.json"))) ?? findInstalledPackage(rootDir, name);
+}
+function readAgentDocs(rootDir, docsDir) {
+  let directory = docsDir;
+  if (!directory) {
+    const packageDir = findProjectPackage(rootDir, "maz-ui");
+    if (!packageDir)
+      throw new Error(`maz-ui is not installed in ${rootDir}: install it first (\`npm install maz-ui\`).`);
+    directory = join(packageDir, "docs");
+  }
+  const manifestFile = join(directory, "manifest.json");
+  const claudeRuleFile = join(directory, "agents/claude-rule.md");
+  const agentsMdFile = join(directory, "agents/agents-md.md");
+  if (!existsSync(manifestFile) || !existsSync(claudeRuleFile) || !existsSync(agentsMdFile)) {
+    throw new Error(`The installed maz-ui does not ship the agent docs (${directory}): upgrade maz-ui to the latest version.`);
+  }
+  const packageVersion = readPackageVersion(dirname(directory));
+  return {
+    directory,
+    version: packageVersion ?? JSON.parse(readFileSync(manifestFile, "utf8")).version,
+    claudeRule: readFileSync(claudeRuleFile, "utf8").trim(),
+    agentsMdSection: readFileSync(agentsMdFile, "utf8").trim()
+  };
+}
+function writeFileAtomic(path, content) {
+  const temporary = join(dirname(path), `.${basename(path)}.${process.pid}.${Date.now()}.tmp`);
+  mkdirSync(dirname(path), { recursive: true });
+  try {
+    writeFileSync(temporary, content);
+    renameSync(temporary, path);
+  } catch (error) {
+    rmSync(temporary, { force: true });
+    throw error;
+  }
+}
+function parseVersion(version) {
+  const [core, ...prerelease] = version.replace(/^v/, "").split("+")[0].split("-");
+  return {
+    core: core.split(".").map((part) => Number.parseInt(part, 10) || 0),
+    prerelease: prerelease.join("-").split(".").filter(Boolean)
+  };
+}
+function comparePrereleaseIdentifiers(a, b) {
+  const isNumeric = (value) => /^\d+$/.test(value);
+  if (isNumeric(a) !== isNumeric(b)) {
+    return isNumeric(a) ? -1 : 1;
+  }
+  return isNumeric(a) ? Number(a) - Number(b) : a.localeCompare(b);
+}
+function compareVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  for (let index = 0; index < 3; index++) {
+    const difference = (left.core[index] ?? 0) - (right.core[index] ?? 0);
+    if (difference !== 0)
+      return difference;
+  }
+  if (left.prerelease.length === 0 || right.prerelease.length === 0)
+    return right.prerelease.length - left.prerelease.length;
+  for (let index = 0; index < Math.min(left.prerelease.length, right.prerelease.length); index++) {
+    const difference = comparePrereleaseIdentifiers(left.prerelease[index], right.prerelease[index]);
+    if (difference !== 0)
+      return difference;
+  }
+  return left.prerelease.length - right.prerelease.length;
+}
+function readManagedVersion(content, tool = MAZ_UI_AGENTS_TOOL) {
+  return content ? resolveTool(tool).managedVersion.exec(content)?.[1] : void 0;
+}
+function newerManagedVersion(content, version, tool) {
+  const written = readManagedVersion(content, tool);
+  return written && version && compareVersions(written, version) > 0 ? written : void 0;
+}
+function newerVersionReason(written, version, tool) {
+  return `written by ${tool.name} ${written}, newer than the installed ${version}: left untouched`;
+}
+class ChangeSet {
+  constructor(rootDir, dryRun) {
+    this.rootDir = rootDir;
+    this.dryRun = dryRun;
+  }
+  changes = [];
+  absolute(file) {
+    return join(this.rootDir, file);
+  }
+  read(file) {
+    const path = this.absolute(file);
+    return existsSync(path) ? readFileSync(path, "utf8") : void 0;
+  }
+  write(file, content, current, reason) {
+    if (current === content) {
+      this.changes.push({ file, action: "unchanged" });
+      return;
+    }
+    this.changes.push({
+      file,
+      action: current === void 0 ? "create" : "update",
+      ...reason ? { reason } : {}
+    });
+    if (!this.dryRun)
+      writeFileAtomic(this.absolute(file), content);
+  }
+  delete(file) {
+    this.changes.push({ file, action: "remove" });
+    if (!this.dryRun)
+      rmSync(this.absolute(file), { force: true });
+  }
+  skip(file, reason) {
+    this.changes.push({ file, action: "skip", reason });
+  }
+  unchanged(file, reason) {
+    this.changes.push({ file, action: "unchanged", reason });
+  }
+}
+function isOwned(content, setup) {
+  return content === void 0 || content.includes(setup.marker);
+}
+function syncOwnedFile(changes, file, content, version, setup) {
+  const { tool } = setup;
+  const current = changes.read(file);
+  if (!isOwned(current, setup)) {
+    changes.skip(file, `file exists and was not generated by ${tool.name}: left untouched`);
+    return;
+  }
+  const newer = content === void 0 ? void 0 : newerManagedVersion(current, version, tool);
+  if (newer) {
+    changes.skip(file, newerVersionReason(newer, version, tool));
+    return;
+  }
+  if (content !== void 0 && isEditedManagedContent(current, tool)) {
+    changes.skip(file, `edited since it was generated: left untouched, delete it to get the rules of ${tool.name} ${version}`);
+    return;
+  }
+  if (content === void 0) {
+    if (current !== void 0)
+      changes.delete(file);
+    return;
+  }
+  changes.write(file, content, current);
+}
+function syncAgentsMd(changes, section, version, setup) {
+  const { tool, agentsMdBegin, agentsMdEnd } = setup;
+  const file = "AGENTS.md";
+  const current = changes.read(file);
+  const begin = current?.indexOf(agentsMdBegin) ?? -1;
+  const end = current?.indexOf(agentsMdEnd) ?? -1;
+  const hasBlock = begin !== -1 && end > begin;
+  if (section === void 0) {
+    if (!current || !hasBlock)
+      return;
+    const remaining = `${current.slice(0, begin)}${current.slice(end + agentsMdEnd.length)}`.replace(/\n{3,}/g, "\n\n").trim();
+    if (remaining)
+      changes.write(file, `${remaining}
+`, current);
+    else
+      changes.delete(file);
+    return;
+  }
+  const block = hasBlock ? current?.slice(begin + agentsMdBegin.length, end) : void 0;
+  const newer = newerManagedVersion(block, version, tool);
+  if (newer) {
+    changes.skip(file, newerVersionReason(newer, version, tool));
+    return;
+  }
+  if (isEditedManagedContent(block, tool)) {
+    changes.skip(file, `the ${tool.name} section was edited since it was generated: left untouched, delete the section to get the rules of ${tool.name} ${version}`);
+    return;
+  }
+  const wrapped = `${agentsMdBegin}
+
+${section}
+
+${agentsMdEnd}`;
+  if (!current) {
+    changes.write(file, `${wrapped}
+`, current);
+  } else if (hasBlock) {
+    changes.write(file, `${current.slice(0, begin)}${wrapped}${current.slice(end + agentsMdEnd.length)}`, current);
+  } else {
+    changes.write(file, `${current.trimEnd()}
+
+${wrapped}
+`, current);
+  }
+}
+const MCP_FILES = {
+  claude: { file: ".mcp.json", rootKey: "mcpServers", withType: true },
+  cursor: { file: ".cursor/mcp.json", rootKey: "mcpServers", withType: false },
+  vscode: { file: ".vscode/mcp.json", rootKey: "servers", withType: true }
+};
+function referencesToolMcp(server, tool) {
+  const serialized = JSON.stringify(server);
+  const args = isJsonObject(server) && Array.isArray(server.args) ? server.args : [];
+  return (serialized.includes(tool.mcpPackage) || serialized.includes(tool.mcpBin)) && (tool.mcpArgs ?? []).every((arg) => args.includes(arg));
+}
+function findLegacyPackage(server, tool) {
+  const serialized = JSON.stringify(server);
+  return tool.legacyMcpPackages?.find((name) => serialized.includes(name));
+}
+function detectFormatting(content) {
+  const indent = /^( +|\t)"/m.exec(content)?.[1] ?? "  ";
+  return {
+    insertSpaces: !indent.includes("	"),
+    tabSize: indent.includes("	") ? 1 : indent.length,
+    eol: content.includes("\r\n") ? "\r\n" : "\n"
+  };
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function updateMcpCommand(changes, config, [key, entry], server, tool) {
+  const current = entry;
+  const label = [server.command, ...server.args].join(" ");
+  if (current.command === server.command && JSON.stringify(current.args) === JSON.stringify(server.args)) {
+    changes.unchanged(config.file, `${tool.name} MCP server already registered as "${key}"`);
+    return;
+  }
+  if (!isGeneratedMcpCommand(current, tool)) {
+    changes.unchanged(config.file, `"${key}" runs a custom command: left untouched`);
+    return;
+  }
+  const pinned = pinnedMcpVersion(current, tool);
+  const wanted = pinnedMcpVersion(server, tool);
+  const isLocal = !server.args.includes("-y");
+  if (pinned && !isLocal && (!wanted || compareVersions(pinned, wanted) >= 0)) {
+    changes.unchanged(config.file, `"${key}" runs ${tool.mcpPackage} ${pinned}`);
+    return;
+  }
+  const file = changes.read(config.file);
+  const formatting = detectFormatting(file);
+  let content = applyEdits(file, modify(file, [config.rootKey, key, "command"], server.command, { formattingOptions: formatting }));
+  content = applyEdits(content, modify(content, [config.rootKey, key, "args"], server.args, { formattingOptions: formatting }));
+  changes.write(config.file, content, file, `"${key}" now runs ${label}`);
+}
+function syncMcpConfig(changes, config, server, remove, tool) {
+  const current = changes.read(config.file);
+  const errors = [];
+  const parsed = current === void 0 ? {} : parse(current, errors, { allowTrailingComma: true });
+  if (errors.length > 0 || !isJsonObject(parsed) || parsed[config.rootKey] !== void 0 && !isJsonObject(parsed[config.rootKey])) {
+    changes.skip(config.file, "invalid JSON: left untouched");
+    return;
+  }
+  const servers = parsed[config.rootKey] ?? {};
+  const existing = Object.entries(servers).find(([, value2]) => referencesToolMcp(value2, tool));
+  const base = current ?? "{}\n";
+  const formatting = detectFormatting(base);
+  if (remove) {
+    if (existing?.[0] === tool.name) {
+      const content2 = applyEdits(base, modify(base, [config.rootKey, tool.name], void 0, { formattingOptions: formatting }));
+      const remaining = parse(content2);
+      const isEmpty = Object.keys(remaining).length === 1 && Object.keys(remaining[config.rootKey]).length === 0;
+      if (isEmpty)
+        changes.delete(config.file);
+      else
+        changes.write(config.file, content2, current);
+    }
+    return;
+  }
+  if (existing) {
+    updateMcpCommand(changes, config, existing, server, tool);
+    return;
+  }
+  const legacy = Object.entries(servers).map(([key, entry]) => [
+    key,
+    findLegacyPackage(entry, tool)
+  ]).find(([, name]) => name !== void 0);
+  if (legacy) {
+    const [key, name] = legacy;
+    const migrated = applyEdits(base, modify(base, [config.rootKey, key], config.withType ? { type: "stdio", ...server } : { ...server }, { formattingOptions: formatting }));
+    changes.write(config.file, migrated.endsWith("\n") ? migrated : `${migrated}
+`, current, `"${key}" migrated from ${name} to ${tool.mcpPackage}`);
+    return;
+  }
+  if (servers[tool.name] !== void 0) {
+    changes.skip(config.file, `a "${tool.name}" server already exists with another command: left untouched`);
+    return;
+  }
+  const value = config.withType ? { type: "stdio", ...server } : { ...server };
+  const content = applyEdits(base, modify(base, [config.rootKey, tool.name], value, { formattingOptions: formatting }));
+  changes.write(config.file, content.endsWith("\n") ? content : `${content}
+`, current);
+}
+const DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function dependsOnAny(folder, packages) {
+  const pkg = readPackageJson(folder);
+  return DEPENDENCY_FIELDS.some((field) => packages.some((name) => pkg?.[field]?.[name] !== void 0));
+}
+function findWorkspacesUsing(rootDir, packages) {
+  const excluded = readDeclaredWorkspacePatterns(rootDir).filter((pattern) => pattern.startsWith("!")).map((pattern) => globToRegExp(`${pattern.slice(1)}/**`));
+  const folders = [
+    rootDir,
+    ...findWorkspaceDirs(rootDir)
+  ].map((folder) => relative(rootDir, folder).split(sep).join("/")).filter((folder) => !excluded.some((matcher) => matcher.test(folder)));
+  return folders.filter((folder) => dependsOnAny(join(rootDir, folder), packages));
+}
+function isUnscopedGlob(glob) {
+  return ["**", "**/*", "*", "/**", "/**/*"].includes(glob.trim());
+}
+function resolveRulePaths(rootDir, tool, option = "auto") {
+  if (option === "all")
+    return void 0;
+  const explicit = Array.isArray(option) ? option.map((glob) => glob.trim()).filter(Boolean) : [];
+  const globs = Array.isArray(option) ? explicit : autoRulePaths(rootDir, tool);
+  return globs.length === 0 || globs.some(isUnscopedGlob) ? void 0 : [
+    ...new Set(globs)
+  ];
+}
+const MAX_EXPANDED_PATTERNS = 1e3;
+function expandedPatternCount(glob) {
+  const groups = glob.replaceAll(/\\./g, "").matchAll(/\{([^{}]*)\}/g);
+  return [...groups].reduce((count, [, alternatives]) => count * alternatives.split(",").length, 1);
+}
+function escapeGlobFolder(folder) {
+  return folder.replaceAll(/[[\]{}()*?!]/g, String.raw`\$&`);
+}
+function autoRulePaths(rootDir, tool) {
+  if (!tool.packages || tool.packages.length === 0)
+    return [];
+  const files = tool.ruleGlobs ?? ["**/*"];
+  const folders = findWorkspacesUsing(rootDir, tool.packages);
+  const globsOf = (scopedFolders) => scopedFolders.flatMap((folder) => files.map((glob) => posix.join(escapeGlobFolder(folder), glob)));
+  const scoped = globsOf(folders.includes("") || folders.length === 0 ? [""] : folders);
+  return scoped.reduce((total, glob) => total + expandedPatternCount(glob), 0) > MAX_EXPANDED_PATTERNS ? globsOf([""]) : scoped;
+}
+function claudeFrontmatter(globs) {
+  if (!globs || globs.length === 0)
+    return "";
+  const items = globs.map((glob) => [
+    "  -",
+    JSON.stringify(glob)
+  ].join(" ")).join("\n");
+  return `---
+paths:
+${items}
+---
+
+`;
+}
+function syncRules(changes, rootDir, targets, docs, setup, paths) {
+  const version = docs?.version ?? "";
+  const hasClaudeMemory = CLAUDE_MEMORY_FILES.some((file) => existsSync(join(rootDir, file)));
+  const claudeReadsAgentsMd = targets.includes("agents-md") && !hasClaudeMemory;
+  if (targets.includes("claude")) {
+    const rule = docs && !claudeReadsAgentsMd ? `${managedContent(version, withVersion(docs.claudeRule, version, setup.tool), setup, claudeFrontmatter(paths))}
+` : void 0;
+    syncOwnedFile(changes, setup.ruleFile, rule, version, setup);
+  }
+  if (targets.includes("agents-md")) {
+    syncAgentsMd(changes, docs ? managedContent(version, withVersion(docs.agentsMdSection, version, setup.tool), setup) : void 0, version, setup);
+  }
+}
+function resolveAgentDocs(options, tool) {
+  if (options.agentDocs)
+    return options.agentDocs;
+  if (tool !== MAZ_UI_AGENTS_TOOL)
+    throw new Error(`setupAgents needs the rules of ${tool.name}: pass them with the agentDocs option.`);
+  return readAgentDocs(options.rootDir, options.docsDir);
+}
+function setupAgents(options) {
+  const { rootDir, rules = true, mcp = true, dryRun = false, remove = false, tool = MAZ_UI_AGENTS_TOOL } = options;
+  const setup = resolveTool(tool);
+  const targets = options.targets ?? detectAgentTargets(rootDir);
+  const docs = remove || !rules ? void 0 : resolveAgentDocs(options, tool);
+  const version = docs?.version ?? "";
+  const changes = new ChangeSet(rootDir, dryRun);
+  const server = options.mcpServer ?? mcpServerCommand(rootDir, options.mcpVersion, tool);
+  const claudeRulePaths = docs && targets.includes("claude") ? resolveRulePaths(rootDir, tool, options.paths) : void 0;
+  if (rules || remove)
+    syncRules(changes, rootDir, targets, docs, setup, claudeRulePaths);
+  if (mcp || remove) {
+    for (const target of ["claude", "cursor", "vscode"]) {
+      if (targets.includes(target))
+        syncMcpConfig(changes, MCP_FILES[target], server, remove, tool);
+    }
+  }
+  return {
+    targets,
+    version,
+    changes: changes.changes,
+    mcpServer: server,
+    localMcpServer: !server.args.includes("-y"),
+    claudeRulePaths
+  };
+}
+
+export { AGENTS_MD_BEGIN as A, DEFAULT_MCP_SERVER as D, MANAGED_MARKER as M, AGENTS_MD_END as a, AGENT_TARGETS as b, MAZ_UI_AGENTS_TOOL as c, MCP_SERVER_NAME as d, compareVersions as e, detectAgentTargets as f, detectPackageManager as g, findInstalledPackage as h, findProjectPackage as i, findWorkspaceDirs as j, findWorkspacesUsing as k, installsMcpPackage as l, isEditedManagedContent as m, mcpServerCommand as n, readManagedVersion as o, readPackageVersion as p, readWorkspacePatterns as q, readAgentDocs as r, resolveRulePaths as s, setupAgents as t, writeFileAtomic as w };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@maz-ui/node",
   "type": "module",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "Node utilities for Maz-UI library",
   "author": "Louis Mazel <me@loicmazuel.com>",
   "license": "MIT",
@@ -29,6 +29,12 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
+    },
+    "./agents": {
+      "monorepo:dev": "./src/agents.ts",
+      "types": "./dist/agents.d.ts",
+      "import": "./dist/agents.mjs",
+      "default": "./dist/agents.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -39,7 +45,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=22.12.0"
+    "node": "^22.23.4 || ^24.22.1 || >=26.12.1"
   },
   "dependencies": {
     "colorette": "^2.0.20",
@@ -48,14 +54,14 @@
     "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
-    "@types/node": "^22.20.5",
-    "@vitest/coverage-v8": "^5.0.5",
+    "@types/node": "^26.6.6",
+    "@vitest/coverage-v8": "^5.1.0",
     "cross-env": "^10.1.0",
-    "eslint": "^10.13.0",
+    "eslint": "^10.14.0",
     "tsx": "^4.23.15",
     "typescript": "^6.0.3",
     "unbuild": "^3.6.1",
-    "vitest": "5.0.5"
+    "vitest": "5.1.0"
   },
   "lint-staged": {
     "*.{js,jsx,ts,tsx,mjs,mts,cjs,md,yml,json}": [