@maz-ui/mcp 5.2.0 → 5.3.0

package/dist/cli.mjs

@@ -1,14 +1,8 @@
 import 'node:buffer';
 import 'node:path';
 import 'node:util';
-export { H as HELP, m as main, r as runCli, j as runInit, k as runReview } from './shared/mcp.D3_Fk0U3.mjs';
-import 'node:child_process';
-import 'node:process';
-import 'tty';
-import 'node:tty';
-import 'fs';
-import 'path';
-import 'url';
-import 'node:crypto';
+export { H as HELP, m as main, r as runCli, j as runInit, k as runReview } from './shared/mcp.CXId5vdl.mjs';
 import 'node:fs';
 import 'node:url';
+import 'node:crypto';
+import 'node:process';

package/dist/index.d.mts

@@ -373,6 +373,15 @@ interface SetupAgentsOptions {
     tool?: AgentsTool;
     /** Rules of the tool, required with another `tool` than maz-ui. Default: the maz-ui agent docs of `docsDir` */
     agentDocs?: AgentDocs;
+    /**
+     * Scope of the Claude Code rule, written as a `paths:` frontmatter so that Claude Code only loads it
+     * when it reads or edits a matching file, instead of at every session:
+     * - `'auto'` (default): the files of the workspaces whose `package.json` depends on one of `tool.packages`
+     *   (e.g. `apps/pwa/**\/*.vue`), else the files of the project. No scope when the tool declares no `packages`
+     * - `'all'`: no scope, the rule is always loaded
+     * - globs, relative to `rootDir`: used as is
+     */
+    paths?: 'auto' | 'all' | string[];
 }
 interface McpServerCommand {
     command: string;
@@ -393,6 +402,8 @@ interface SetupAgentsResult {
     mcpServer: McpServerCommand;
     /** `false` when the server runs through `npx -y` because the project does not install the MCP package */
     localMcpServer: boolean;
+    /** Globs the Claude Code rule is scoped to (`paths:` frontmatter). `undefined`: the rule is always loaded, or not written */
+    claudeRulePaths?: string[];
 }
 /**
  * A tool whose AI agents are configured by `setupAgents`: maz-ui by default,
@@ -409,8 +420,29 @@ interface AgentsTool {
     mcpArgs?: string[];
     /** What generates the rules, written in their header (markdown, e.g. `` `npx relizy mcp init` ``) */
     generatedBy: string;
-    /** Line written under the title of the rules. Default: `> <name> <version> is installed: these rules match this version.` */
-    versionNote?: (version: string) => string;
+    /** Marker of the generated content, written in its header and used to recognize the files the tool owns. Default `Managed by <name>` */
+    marker?: string;
+    /**
+     * Line written under the title of the rules, `false` to write none.
+     * Default: `> <name> <version> is installed: these rules match this version.`
+     */
+    versionNote?: ((version: string) => string) | false;
+    /**
+     * Packages (or bins) of former MCP servers of the tool: an entry of the MCP config files that references one of
+     * them, when the tool has no entry yet, is replaced by the entry of the tool. Default: none
+     */
+    legacyMcpPackages?: string[];
+    /**
+     * Packages whose presence in the `dependencies`, `devDependencies`, `peerDependencies` or `optionalDependencies`
+     * of a `package.json` ties the files of its project to the tool (e.g. `['maz-ui', '@maz-ui/themes']`). Used by
+     * the `'auto'` scope of the Claude Code rule. Default: none, the rule is always loaded
+     */
+    packages?: string[];
+    /**
+     * Files of a project the rule applies to, relative to its folder. Default `['**\/*']` (the whole project).
+     * With `packages`, applied to each workspace that depends on one of them
+     */
+    ruleGlobs?: string[];
 }
 interface AgentDocs {
     directory: string;

package/dist/index.d.ts

@@ -373,6 +373,15 @@ interface SetupAgentsOptions {
     tool?: AgentsTool;
     /** Rules of the tool, required with another `tool` than maz-ui. Default: the maz-ui agent docs of `docsDir` */
     agentDocs?: AgentDocs;
+    /**
+     * Scope of the Claude Code rule, written as a `paths:` frontmatter so that Claude Code only loads it
+     * when it reads or edits a matching file, instead of at every session:
+     * - `'auto'` (default): the files of the workspaces whose `package.json` depends on one of `tool.packages`
+     *   (e.g. `apps/pwa/**\/*.vue`), else the files of the project. No scope when the tool declares no `packages`
+     * - `'all'`: no scope, the rule is always loaded
+     * - globs, relative to `rootDir`: used as is
+     */
+    paths?: 'auto' | 'all' | string[];
 }
 interface McpServerCommand {
     command: string;
@@ -393,6 +402,8 @@ interface SetupAgentsResult {
     mcpServer: McpServerCommand;
     /** `false` when the server runs through `npx -y` because the project does not install the MCP package */
     localMcpServer: boolean;
+    /** Globs the Claude Code rule is scoped to (`paths:` frontmatter). `undefined`: the rule is always loaded, or not written */
+    claudeRulePaths?: string[];
 }
 /**
  * A tool whose AI agents are configured by `setupAgents`: maz-ui by default,
@@ -409,8 +420,29 @@ interface AgentsTool {
     mcpArgs?: string[];
     /** What generates the rules, written in their header (markdown, e.g. `` `npx relizy mcp init` ``) */
     generatedBy: string;
-    /** Line written under the title of the rules. Default: `> <name> <version> is installed: these rules match this version.` */
-    versionNote?: (version: string) => string;
+    /** Marker of the generated content, written in its header and used to recognize the files the tool owns. Default `Managed by <name>` */
+    marker?: string;
+    /**
+     * Line written under the title of the rules, `false` to write none.
+     * Default: `> <name> <version> is installed: these rules match this version.`
+     */
+    versionNote?: ((version: string) => string) | false;
+    /**
+     * Packages (or bins) of former MCP servers of the tool: an entry of the MCP config files that references one of
+     * them, when the tool has no entry yet, is replaced by the entry of the tool. Default: none
+     */
+    legacyMcpPackages?: string[];
+    /**
+     * Packages whose presence in the `dependencies`, `devDependencies`, `peerDependencies` or `optionalDependencies`
+     * of a `package.json` ties the files of its project to the tool (e.g. `['maz-ui', '@maz-ui/themes']`). Used by
+     * the `'auto'` scope of the Claude Code rule. Default: none, the rule is always loaded
+     */
+    packages?: string[];
+    /**
+     * Files of a project the rule applies to, relative to its folder. Default `['**\/*']` (the whole project).
+     * With `packages`, applied to each workspace that depends on one of them
+     */
+    ruleGlobs?: string[];
 }
 interface AgentDocs {
     directory: string;

package/dist/index.mjs

@@ -1,18 +1,15 @@
-export { D as DocSearch, K as Knowledge, T as TOOLS, b as buildInstructions, c as createContext, a as createMazUiMcpServer, f as findProjectMazUi, l as loadKnowledge, m as main, r as runCli, s as searchIcons, d as setupAgents, e as startStdioServer } from './shared/mcp.D3_Fk0U3.mjs';
+export { D as DocSearch, K as Knowledge, T as TOOLS, b as buildInstructions, c as createContext, a as createMazUiMcpServer, f as findProjectMazUi, l as loadKnowledge, m as main, r as runCli, s as searchIcons, d as setupAgents, e as startStdioServer } from './shared/mcp.CXId5vdl.mjs';
 export { countBySeverity, filterBySeverity, formatFindings, reviewCode } from './chunks/index.mjs';
 export { reviewFiles } from './chunks/files.mjs';
 import 'node:buffer';
 import 'node:path';
 import 'node:util';
-import 'node:child_process';
+import 'node:fs';
+import 'node:url';
+import 'node:crypto';
 import 'node:process';
-import 'tty';
-import 'node:tty';
+import './shared/mcp.ByQS-5Nc.mjs';
 import 'fs';
 import 'path';
 import 'url';
-import 'node:crypto';
-import 'node:fs';
-import 'node:url';
-import './shared/mcp.Ccxm-Aoc.mjs';
 import 'module';

package/dist/shared/{mcp.Ccxm-Aoc.mjs → mcp.ByQS-5Nc.mjs}

@@ -3,7 +3,7 @@ import { statSync, stat, realpathSync, realpath, readdirSync, readdir } from 'fs
 import { sep, basename, dirname, resolve, normalize, relative, posix, isAbsolute } from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
-import { g as getDefaultExportFromCjs } from './mcp.D3_Fk0U3.mjs';
+import { g as getDefaultExportFromCjs } from './mcp.CXId5vdl.mjs';
 
 //#region rolldown:runtime
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -902,7 +902,7 @@ function requireScan () {
 	  const opts = options || {};
 
 	  const length = input.length - 1;
-	  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+	  const scanToEnd = opts.parts === true || opts.tokens === true || opts.scanToEnd === true;
 	  const slashes = [];
 	  const tokens = [];
 	  const parts = [];
@@ -1036,15 +1036,21 @@ function requireScan () {
 	        }
 
 	        if (scanToEnd === true) {
+	          let parens = 0;
+
 	          while (eos() !== true && (code = advance())) {
 	            if (code === CHAR_BACKWARD_SLASH) {
 	              backslashes = token.backslashes = true;
-	              code = advance();
+	              advance();
+	              continue;
+	            }
+
+	            if (code === CHAR_LEFT_PARENTHESES) {
+	              parens++;
 	              continue;
 	            }
 
-	            if (code === CHAR_RIGHT_PARENTHESES) {
-	              isGlob = token.isGlob = true;
+	            if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
 	              finished = true;
 	              break;
 	            }
@@ -1109,14 +1115,21 @@ function requireScan () {
 	      isGlob = token.isGlob = true;
 
 	      if (scanToEnd === true) {
+	        let parens = 1;
+
 	        while (eos() !== true && (code = advance())) {
-	          if (code === CHAR_LEFT_PARENTHESES) {
+	          if (code === CHAR_BACKWARD_SLASH) {
 	            backslashes = token.backslashes = true;
-	            code = advance();
+	            advance();
+	            continue;
+	          }
+
+	          if (code === CHAR_LEFT_PARENTHESES) {
+	            parens++;
 	            continue;
 	          }
 
-	          if (code === CHAR_RIGHT_PARENTHESES) {
+	          if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
 	            finished = true;
 	            break;
 	          }
@@ -1203,7 +1216,7 @@ function requireScan () {
 	    let prevIndex;
 
 	    for (let idx = 0; idx < slashes.length; idx++) {
-	      const n = prevIndex ? prevIndex + 1 : start;
+	      const n = prevIndex !== undefined ? prevIndex + 1 : start;
 	      const i = slashes[idx];
 	      const value = input.slice(n, i);
 	      if (opts.tokens) {
@@ -1216,21 +1229,20 @@ function requireScan () {
 	        depth(tokens[idx]);
 	        state.maxDepth += tokens[idx].depth;
 	      }
-	      if (idx !== 0 || value !== '') {
+	      if (i >= start) {
 	        parts.push(value);
+	        prevIndex = i;
 	      }
-	      prevIndex = i;
 	    }
 
-	    if (prevIndex && prevIndex + 1 < input.length) {
-	      const value = input.slice(prevIndex + 1);
-	      parts.push(value);
+	    const n = prevIndex !== undefined ? prevIndex + 1 : start;
+	    const value = input.slice(n);
+	    parts.push(value);
 
-	      if (opts.tokens) {
-	        tokens[tokens.length - 1].value = value;
-	        depth(tokens[tokens.length - 1]);
-	        state.maxDepth += tokens[tokens.length - 1].depth;
-	      }
+	    if (opts.tokens && prevIndex && prevIndex + 1 < input.length) {
+	      tokens[tokens.length - 1].value = value;
+	      depth(tokens[tokens.length - 1]);
+	      state.maxDepth += tokens[tokens.length - 1].depth;
 	    }
 
 	    state.slashes = slashes;
@@ -1481,7 +1493,15 @@ function requireParse () {
 	  }
 	};
 
-	const getStarExtglobSequenceOutput = pattern => {
+	const buildCharClassStar = chars => {
+	  const source = chars.length === 1
+	    ? utils.escapeRegex(chars[0])
+	    : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`;
+
+	  return `${source}*`;
+	};
+
+	const getStarExtglobSequenceChars = pattern => {
 	  let index = 0;
 	  const chars = [];
 
@@ -1510,11 +1530,7 @@ function requireParse () {
 	    return;
 	  }
 
-	  const source = chars.length === 1
-	    ? utils.escapeRegex(chars[0])
-	    : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`;
-
-	  return `${source}*`;
+	  return chars;
 	};
 
 	const repeatedExtglobRecursion = pattern => {
@@ -1553,17 +1569,43 @@ function requireParse () {
 	    }
 	  }
 
+	  // A repeated extglob is "risky" (prone to catastrophic backtracking) when a
+	  // branch is itself a `*(...)` sequence, since that nests an unbounded quantifier
+	  // inside the outer `+(...)`/`*(...)`. When *every* branch reduces to single
+	  // characters we can emit one flat, ReDoS-safe character class that preserves the
+	  // meaning of ALL branches (e.g. `+(*(a)|*(b))` -> `[ab]*`), rather than dropping
+	  // every branch but the first.
+	  const safeChars = [];
+	  let sawStarSequence = false;
+	  let combinable = true;
+
 	  for (const branch of branches) {
-	    const safeOutput = getStarExtglobSequenceOutput(branch);
-	    if (safeOutput) {
-	      return { risky: true, safeOutput };
+	    const chars = getStarExtglobSequenceChars(branch);
+	    if (chars) {
+	      sawStarSequence = true;
+	      safeChars.push(...chars);
+	      continue;
 	    }
 
+	    const literal = normalizeSimpleBranch(branch);
+	    if (literal && literal.length === 1) {
+	      safeChars.push(literal);
+	      continue;
+	    }
+
+	    combinable = false;
+
 	    if (repeatedExtglobRecursion(branch) > max) {
 	      return { risky: true };
 	    }
 	  }
 
+	  if (sawStarSequence) {
+	    return combinable
+	      ? { risky: true, safeOutput: buildCharClassStar([...new Set(safeChars)]) }
+	      : { risky: true };
+	  }
+
 	  return { risky: false };
 	};
 
@@ -2396,6 +2438,15 @@ function requireParse () {
 	        consume('/**', 3);
 	      }
 
+	      // A globstar followed only by balanced closing parens is at the logical end of patterns like
+	      // `test(/utils/**)` and `test?(/utils/**)`. Treat it as EOS so the trailing `/**` can match its
+	      // parent path, except in negated extglobs where that would change the exclusion semantics.
+	      const isEnd = eos() || (
+	        state.parens > 0
+	        && rest === ')'.repeat(state.parens)
+	        && !extglobs.some(extglob => extglob.type === 'negate')
+	      );
+
 	      if (prior.type === 'bos' && eos()) {
 	        prev.type = 'globstar';
 	        prev.value += value;
@@ -2406,7 +2457,7 @@ function requireParse () {
 	        continue;
 	      }
 
-	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && isEnd) {
 	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
 	        prior.output = `(?:${prior.output}`;
 
@@ -2665,6 +2716,18 @@ function requirePicomatch$1 () {
 	 * const isMatch = picomatch('*.!(*a)');
 	 * console.log(isMatch('a.a')); //=> false
 	 * console.log(isMatch('a.b')); //=> true
+	 *
+	 * // For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection.
+	 * const picomatch = require('picomatch/posix');
+	 * // the same API, defaulting to posix paths
+	 * const isMatch = picomatch('a/*');
+	 * console.log(isMatch('a\\b')); //=> false
+	 * console.log(isMatch('a/b')); //=> true
+	 *
+	 * // you can still configure the matcher function to accept windows paths
+	 * const isMatch = picomatch('a/*', { options: windows });
+	 * console.log(isMatch('a\\b')); //=> true
+	 * console.log(isMatch('a/b')); //=> true
 	 * ```
 	 * @name picomatch
 	 * @param {String|Array} `globs` One or more glob patterns.
@@ -2802,9 +2865,9 @@ function requirePicomatch$1 () {
 	 * @api public
 	 */
 
-	picomatch.matchBase = (input, glob, options) => {
+	picomatch.matchBase = (input, glob, options, posix = options && options.windows) => {
 	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-	  return regex.test(utils.basename(input));
+	  return regex.test(utils.basename(input, { windows: posix }));
 	};
 
 	/**