comze 0.3.1 → 0.4.0

package/README.md

@@ -47,6 +47,9 @@ comze --dry-run
 
 # Exclude packages
 comze --exclude vendor/package
+
+# Exclude multiple packages
+comze --exclude vendor/package-a,vendor/package-b
 ```
 
 ## Options
@@ -59,9 +62,28 @@ comze --exclude vendor/package
 | `--major`           | Include major updates (default: false)  |
 | `--minor`           | Include minor updates (default: true)   |
 | `--patch`           | Include patch updates (default: true)   |
-| `--exclude <pkgs>`  | Exclude packages (comma-separated)      |
+| `--exclude <pkgs>`  | Exclude packages (comma-separated, merged with `extra.comze.exclude`) |
 | `--dry-run`         | Preview changes without writing         |
 
+## Persistent Excludes
+
+For packages that should always be ignored, store them in `composer.json` under `extra.comze.exclude`:
+
+```json
+{
+  "extra": {
+    "comze": {
+      "exclude": [
+        "vendor/package-a",
+        "vendor/package-b"
+      ]
+    }
+  }
+}
+```
+
+`comze` merges this list with `--exclude`, so the flag remains useful for one-off runs while the file keeps repository-wide defaults.
+
 ## Composer Stability
 
 comze reads `minimum-stability` and `prefer-stable` from your `composer.json`:

package/dist/cli.mjs

@@ -4,15 +4,29 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -2095,7 +2109,7 @@ var require_clear = __commonJS((exports, module) => {
         if (it)
           o = it;
         var i = 0;
-        var F = function F() {};
+        var F = function F2() {};
         return { s: F, n: function n() {
           if (i >= o.length)
             return { done: true };
@@ -2310,13 +2324,13 @@ var require_prompt = __commonJS((exports, module) => {
   var readline = __require("readline");
   var _require = require_util();
   var action = _require.action;
-  var EventEmitter2 = __require("events");
+  var EventEmitter = __require("events");
   var _require2 = require_src();
   var beep = _require2.beep;
   var cursor = _require2.cursor;
   var color = require_kleur();
 
-  class Prompt extends EventEmitter2 {
+  class Prompt extends EventEmitter {
     constructor(opts = {}) {
       super();
       this.firstRender = true;
@@ -4427,7 +4441,7 @@ var require_dist = __commonJS((exports, module) => {
         if (it)
           o = it;
         var i = 0;
-        var F = function F() {};
+        var F = function F2() {};
         return { s: F, n: function n() {
           if (i >= o.length)
             return { done: true };
@@ -4530,7 +4544,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return question2.format ? yield question2.format(answer2, answers) : answer2;
         });
-        return function getFormattedAnswer(_x, _x2) {
+        return function getFormattedAnswer2(_x, _x2) {
           return _ref.apply(this, arguments);
         };
       }();
@@ -4818,11 +4832,11 @@ var require_util2 = __commonJS((exports, module) => {
 var require_prompt2 = __commonJS((exports, module) => {
   var readline = __require("readline");
   var { action } = require_util2();
-  var EventEmitter2 = __require("events");
+  var EventEmitter = __require("events");
   var { beep, cursor } = require_src();
   var color = require_kleur();
 
-  class Prompt extends EventEmitter2 {
+  class Prompt extends EventEmitter {
     constructor(opts = {}) {
       super();
       this.firstRender = true;
@@ -6788,8 +6802,7 @@ var require_prompts3 = __commonJS((exports, module) => {
   module.exports = isNodeLT("8.6.0") ? require_dist() : require_lib();
 });
 
-// node_modules/cac/dist/index.mjs
-import { EventEmitter } from "events";
+// node_modules/cac/dist/index.js
 function toArr(any) {
   return any == null ? [] : Array.isArray(any) ? any : [any];
 }
@@ -6797,7 +6810,7 @@ function toVal(out, key, val, opts) {
   var x, old = out[key], nxt = ~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : ~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
   out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
 }
-function mri2(args, opts) {
+function lib_default(args, opts) {
   args = args || [];
   opts = opts || {};
   var k, arr, arg, name, val, out = { _: [] };
@@ -6808,14 +6821,12 @@ function mri2(args, opts) {
   opts.alias = opts.alias || {};
   opts.string = toArr(opts.string);
   opts.boolean = toArr(opts.boolean);
-  if (alibi) {
+  if (alibi)
     for (k in opts.alias) {
       arr = opts.alias[k] = toArr(opts.alias[k]);
-      for (i = 0;i < arr.length; i++) {
+      for (i = 0;i < arr.length; i++)
         (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
-      }
     }
-  }
   for (i = opts.boolean.length;i-- > 0; ) {
     arr = opts.alias[opts.boolean[i]] || [];
     for (j = arr.length;j-- > 0; )
@@ -6826,18 +6837,16 @@ function mri2(args, opts) {
     for (j = arr.length;j-- > 0; )
       opts.string.push(arr[j]);
   }
-  if (defaults) {
+  if (defaults)
     for (k in opts.default) {
       name = typeof opts.default[k];
       arr = opts.alias[k] = opts.alias[k] || [];
       if (opts[name] !== undefined) {
         opts[name].push(k);
-        for (i = 0;i < arr.length; i++) {
+        for (i = 0;i < arr.length; i++)
           opts[name].push(arr[i]);
-        }
       }
     }
-  }
   const keys = strict ? Object.keys(opts.alias) : [];
   for (i = 0;i < len; i++) {
     arg = args[i];
@@ -6845,25 +6854,22 @@ function mri2(args, opts) {
       out._ = out._.concat(args.slice(++i));
       break;
     }
-    for (j = 0;j < arg.length; j++) {
+    for (j = 0;j < arg.length; j++)
       if (arg.charCodeAt(j) !== 45)
         break;
-    }
-    if (j === 0) {
+    if (j === 0)
       out._.push(arg);
-    } else if (arg.substring(j, j + 3) === "no-") {
+    else if (arg.substring(j, j + 3) === "no-") {
       name = arg.substring(j + 3);
-      if (strict && !~keys.indexOf(name)) {
+      if (strict && !~keys.indexOf(name))
         return opts.unknown(arg);
-      }
       out[name] = false;
     } else {
-      for (idx = j + 1;idx < arg.length; idx++) {
+      for (idx = j + 1;idx < arg.length; idx++)
         if (arg.charCodeAt(idx) === 61)
           break;
-      }
       name = arg.substring(j, idx);
-      val = arg.substring(++idx) || (i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i]);
+      val = arg.substring(++idx) || i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
       arr = j === 2 ? [name] : name;
       for (idx = 0;idx < arr.length; idx++) {
         name = arr[idx];
@@ -6874,24 +6880,22 @@ function mri2(args, opts) {
     }
   }
   if (defaults) {
-    for (k in opts.default) {
-      if (out[k] === undefined) {
+    for (k in opts.default)
+      if (out[k] === undefined)
         out[k] = opts.default[k];
-      }
-    }
   }
-  if (alibi) {
+  if (alibi)
     for (k in out) {
       arr = opts.alias[k] || [];
-      while (arr.length > 0) {
+      while (arr.length > 0)
         out[arr.shift()] = out[k];
-      }
     }
-  }
   return out;
 }
-var removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
-var findAllBrackets = (v) => {
+function removeBrackets(v) {
+  return v.replace(/[<[].+/, "").trim();
+}
+function findAllBrackets(v) {
   const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
   const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
   const res = [];
@@ -6909,98 +6913,101 @@ var findAllBrackets = (v) => {
     };
   };
   let angledMatch;
-  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
+  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v))
     res.push(parse(angledMatch));
-  }
   let squareMatch;
-  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
+  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v))
     res.push(parse(squareMatch));
-  }
   return res;
-};
-var getMriOptions = (options) => {
-  const result = { alias: {}, boolean: [] };
+}
+function getMriOptions(options) {
+  const result = {
+    alias: {},
+    boolean: []
+  };
   for (const [index, option] of options.entries()) {
-    if (option.names.length > 1) {
+    if (option.names.length > 1)
       result.alias[option.names[0]] = option.names.slice(1);
-    }
-    if (option.isBoolean) {
+    if (option.isBoolean)
       if (option.negated) {
-        const hasStringTypeOption = options.some((o, i) => {
+        if (!options.some((o, i) => {
           return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
-        });
-        if (!hasStringTypeOption) {
+        }))
           result.boolean.push(option.names[0]);
-        }
-      } else {
+      } else
         result.boolean.push(option.names[0]);
-      }
-    }
   }
   return result;
-};
-var findLongest = (arr) => {
+}
+function findLongest(arr) {
   return arr.sort((a, b) => {
     return a.length > b.length ? -1 : 1;
   })[0];
-};
-var padRight = (str, length) => {
+}
+function padRight(str, length) {
   return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
-};
-var camelcase = (input) => {
-  return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+}
+function camelcase(input) {
+  return input.replaceAll(/([a-z])-([a-z])/g, (_, p1, p2) => {
     return p1 + p2.toUpperCase();
   });
-};
-var setDotProp = (obj, keys, val) => {
-  let i = 0;
-  let length = keys.length;
-  let t = obj;
-  let x;
-  for (;i < length; ++i) {
-    x = t[keys[i]];
-    t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+}
+function setDotProp(obj, keys, val) {
+  let current = obj;
+  for (let i = 0;i < keys.length; i++) {
+    const key = keys[i];
+    if (i === keys.length - 1) {
+      current[key] = val;
+      return;
+    }
+    if (current[key] == null) {
+      const nextKeyIsArrayIndex = +keys[i + 1] > -1;
+      current[key] = nextKeyIsArrayIndex ? [] : {};
+    }
+    current = current[key];
   }
-};
-var setByType = (obj, transforms) => {
+}
+function setByType(obj, transforms) {
   for (const key of Object.keys(transforms)) {
     const transform = transforms[key];
     if (transform.shouldTransform) {
-      obj[key] = Array.prototype.concat.call([], obj[key]);
-      if (typeof transform.transformFunction === "function") {
+      obj[key] = [obj[key]].flat();
+      if (typeof transform.transformFunction === "function")
         obj[key] = obj[key].map(transform.transformFunction);
-      }
     }
   }
-};
-var getFileName = (input) => {
-  const m = /([^\\\/]+)$/.exec(input);
+}
+function getFileName(input) {
+  const m = /([^\\/]+)$/.exec(input);
   return m ? m[1] : "";
-};
-var camelcaseOptionName = (name) => {
+}
+function camelcaseOptionName(name) {
   return name.split(".").map((v, i) => {
     return i === 0 ? camelcase(v) : v;
   }).join(".");
-};
-
-class CACError extends Error {
+}
+var CACError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = this.constructor.name;
-    if (typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, this.constructor);
-    } else {
+    this.name = "CACError";
+    if (typeof Error.captureStackTrace !== "function")
       this.stack = new Error(message).stack;
-    }
   }
-}
-
-class Option {
+};
+var Option = class {
+  rawName;
+  description;
+  name;
+  names;
+  isBoolean;
+  required;
+  config;
+  negated;
   constructor(rawName, description, config) {
     this.rawName = rawName;
     this.description = description;
     this.config = Object.assign({}, config);
-    rawName = rawName.replace(/\.\*/g, "");
+    rawName = rawName.replaceAll(".*", "");
     this.negated = false;
     this.names = removeBrackets(rawName).split(",").map((v) => {
       let name = v.trim().replace(/^-{1,2}/, "");
@@ -7010,23 +7017,48 @@ class Option {
       }
       return camelcaseOptionName(name);
     }).sort((a, b) => a.length > b.length ? 1 : -1);
-    this.name = this.names[this.names.length - 1];
-    if (this.negated && this.config.default == null) {
+    this.name = this.names.at(-1);
+    if (this.negated && this.config.default == null)
       this.config.default = true;
-    }
-    if (rawName.includes("<")) {
+    if (rawName.includes("<"))
       this.required = true;
-    } else if (rawName.includes("[")) {
+    else if (rawName.includes("["))
       this.required = false;
-    } else {
+    else
       this.isBoolean = true;
-    }
   }
-}
-var processArgs = process.argv;
-var platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
-
-class Command {
+};
+var runtimeProcessArgs;
+var runtimeInfo;
+if (typeof process !== "undefined") {
+  let runtimeName;
+  if (typeof Deno !== "undefined" && typeof Deno.version?.deno === "string")
+    runtimeName = "deno";
+  else if (typeof Bun !== "undefined" && typeof Bun.version === "string")
+    runtimeName = "bun";
+  else
+    runtimeName = "node";
+  runtimeInfo = `${process.platform}-${process.arch} ${runtimeName}-${process.version}`;
+  runtimeProcessArgs = process.argv;
+} else if (typeof navigator === "undefined")
+  runtimeInfo = `unknown`;
+else
+  runtimeInfo = `${navigator.platform} ${navigator.userAgent}`;
+var Command = class {
+  rawName;
+  description;
+  config;
+  cli;
+  options;
+  aliasNames;
+  name;
+  args;
+  commandAction;
+  usageText;
+  versionNumber;
+  examples;
+  helpCallback;
+  globalCommand;
   constructor(rawName, description, config = {}, cli) {
     this.rawName = rawName;
     this.description = description;
@@ -7089,22 +7121,13 @@ class Command {
   }
   outputHelp() {
     const { name, commands } = this.cli;
-    const {
-      versionNumber,
-      options: globalOptions,
-      helpCallback
-    } = this.cli.globalCommand;
-    let sections = [
-      {
-        body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
-      }
-    ];
+    const { versionNumber, options: globalOptions, helpCallback } = this.cli.globalCommand;
+    let sections = [{ body: `${name}${versionNumber ? `/${versionNumber}` : ""}` }];
     sections.push({
       title: "Usage",
       body: `  $ ${name} ${this.usageText || this.rawName}`
     });
-    const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
-    if (showCommands) {
+    if ((this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0) {
       const longestCommandName = findLongest(commands.map((command) => command.rawName));
       sections.push({
         title: "Commands",
@@ -7112,17 +7135,15 @@ class Command {
           return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
         }).join(`
 `)
-      });
-      sections.push({
+      }, {
         title: `For more info, run any command with the \`--help\` flag`,
         body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join(`
 `)
       });
     }
     let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
-    if (!this.isGlobalCommand && !this.isDefaultCommand) {
+    if (!this.isGlobalCommand && !this.isDefaultCommand)
       options = options.filter((option) => option.name !== "version");
-    }
     if (options.length > 0) {
       const longestOptionName = findLongest(options.map((option) => option.rawName));
       sections.push({
@@ -7133,22 +7154,19 @@ class Command {
 `)
       });
     }
-    if (this.examples.length > 0) {
+    if (this.examples.length > 0)
       sections.push({
         title: "Examples",
         body: this.examples.map((example) => {
-          if (typeof example === "function") {
+          if (typeof example === "function")
             return example(name);
-          }
           return example;
         }).join(`
 `)
       });
-    }
-    if (helpCallback) {
+    if (helpCallback)
       sections = helpCallback(sections) || sections;
-    }
-    console.log(sections.map((section) => {
+    console.info(sections.map((section) => {
       return section.title ? `${section.title}:
 ${section.body}` : section.body;
     }).join(`
@@ -7158,24 +7176,20 @@ ${section.body}` : section.body;
   outputVersion() {
     const { name } = this.cli;
     const { versionNumber } = this.cli.globalCommand;
-    if (versionNumber) {
-      console.log(`${name}/${versionNumber} ${platformInfo}`);
-    }
+    if (versionNumber)
+      console.info(`${name}/${versionNumber} ${runtimeInfo}`);
   }
   checkRequiredArgs() {
     const minimalArgsCount = this.args.filter((arg) => arg.required).length;
-    if (this.cli.args.length < minimalArgsCount) {
+    if (this.cli.args.length < minimalArgsCount)
       throw new CACError(`missing required args for command \`${this.rawName}\``);
-    }
   }
   checkUnknownOptions() {
     const { options, globalCommand } = this.cli;
     if (!this.config.allowUnknownOptions) {
-      for (const name of Object.keys(options)) {
-        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
+      for (const name of Object.keys(options))
+        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name))
           throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
-        }
-      }
     }
   }
   checkOptionValue() {
@@ -7185,22 +7199,33 @@ ${section.body}` : section.body;
       const value = parsedOptions[option.name.split(".")[0]];
       if (option.required) {
         const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
-        if (value === true || value === false && !hasNegated) {
+        if (value === true || value === false && !hasNegated)
           throw new CACError(`option \`${option.rawName}\` value is missing`);
-        }
       }
     }
   }
-}
-
-class GlobalCommand extends Command {
+  checkUnusedArgs() {
+    const maximumArgsCount = this.args.some((arg) => arg.variadic) ? Infinity : this.args.length;
+    if (maximumArgsCount < this.cli.args.length)
+      throw new CACError(`Unused args: ${this.cli.args.slice(maximumArgsCount).map((arg) => `\`${arg}\``).join(", ")}`);
+  }
+};
+var GlobalCommand = class extends Command {
   constructor(cli) {
     super("@@global@@", "", {}, cli);
   }
-}
-var __assign = Object.assign;
-
-class CAC extends EventEmitter {
+};
+var CAC = class extends EventTarget {
+  name;
+  commands;
+  globalCommand;
+  matchedCommand;
+  matchedCommandName;
+  rawArgs;
+  args;
+  options;
+  showHelpOnExit;
+  showVersionOnExit;
   constructor(name = "") {
     super();
     this.name = name;
@@ -7241,11 +7266,10 @@ class CAC extends EventEmitter {
     return this;
   }
   outputHelp() {
-    if (this.matchedCommand) {
+    if (this.matchedCommand)
       this.matchedCommand.outputHelp();
-    } else {
+    else
       this.globalCommand.outputHelp();
-    }
   }
   outputVersion() {
     this.globalCommand.outputVersion();
@@ -7253,47 +7277,47 @@ class CAC extends EventEmitter {
   setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
     this.args = args;
     this.options = options;
-    if (matchedCommand) {
+    if (matchedCommand)
       this.matchedCommand = matchedCommand;
-    }
-    if (matchedCommandName) {
+    if (matchedCommandName)
       this.matchedCommandName = matchedCommandName;
-    }
     return this;
   }
   unsetMatchedCommand() {
     this.matchedCommand = undefined;
     this.matchedCommandName = undefined;
   }
-  parse(argv = processArgs, {
-    run = true
-  } = {}) {
+  parse(argv, { run = true } = {}) {
+    if (!argv) {
+      if (!runtimeProcessArgs)
+        throw new Error("No argv provided and runtime process argv is not available.");
+      argv = runtimeProcessArgs;
+    }
     this.rawArgs = argv;
-    if (!this.name) {
+    if (!this.name)
       this.name = argv[1] ? getFileName(argv[1]) : "cli";
-    }
     let shouldParse = true;
     for (const command of this.commands) {
       const parsed = this.mri(argv.slice(2), command);
       const commandName = parsed.args[0];
       if (command.isMatched(commandName)) {
         shouldParse = false;
-        const parsedInfo = __assign(__assign({}, parsed), {
+        const parsedInfo = {
+          ...parsed,
           args: parsed.args.slice(1)
-        });
+        };
         this.setParsedInfo(parsedInfo, command, commandName);
-        this.emit(`command:${commandName}`, command);
+        this.dispatchEvent(new CustomEvent(`command:${commandName}`, { detail: command }));
       }
     }
     if (shouldParse) {
-      for (const command of this.commands) {
-        if (command.name === "") {
+      for (const command of this.commands)
+        if (command.isDefaultCommand) {
           shouldParse = false;
           const parsed = this.mri(argv.slice(2), command);
           this.setParsedInfo(parsed, command);
-          this.emit(`command:!`, command);
+          this.dispatchEvent(new CustomEvent("command:!", { detail: command }));
         }
-      }
     }
     if (shouldParse) {
       const parsed = this.mri(argv.slice(2));
@@ -7309,60 +7333,51 @@ class CAC extends EventEmitter {
       run = false;
       this.unsetMatchedCommand();
     }
-    const parsedArgv = { args: this.args, options: this.options };
-    if (run) {
+    const parsedArgv = {
+      args: this.args,
+      options: this.options
+    };
+    if (run)
       this.runMatchedCommand();
-    }
-    if (!this.matchedCommand && this.args[0]) {
-      this.emit("command:*");
-    }
+    if (!this.matchedCommand && this.args[0])
+      this.dispatchEvent(new CustomEvent("command:*", { detail: this.args[0] }));
     return parsedArgv;
   }
   mri(argv, command) {
-    const cliOptions = [
-      ...this.globalCommand.options,
-      ...command ? command.options : []
-    ];
+    const cliOptions = [...this.globalCommand.options, ...command ? command.options : []];
     const mriOptions = getMriOptions(cliOptions);
     let argsAfterDoubleDashes = [];
     const doubleDashesIndex = argv.indexOf("--");
-    if (doubleDashesIndex > -1) {
+    if (doubleDashesIndex !== -1) {
       argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
       argv = argv.slice(0, doubleDashesIndex);
     }
-    let parsed = mri2(argv, mriOptions);
+    let parsed = lib_default(argv, mriOptions);
     parsed = Object.keys(parsed).reduce((res, name) => {
-      return __assign(__assign({}, res), {
+      return {
+        ...res,
         [camelcaseOptionName(name)]: parsed[name]
-      });
+      };
     }, { _: [] });
     const args = parsed._;
-    const options = {
-      "--": argsAfterDoubleDashes
-    };
+    const options = { "--": argsAfterDoubleDashes };
     const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
-    let transforms = Object.create(null);
+    const transforms = Object.create(null);
     for (const cliOption of cliOptions) {
-      if (!ignoreDefault && cliOption.config.default !== undefined) {
-        for (const name of cliOption.names) {
+      if (!ignoreDefault && cliOption.config.default !== undefined)
+        for (const name of cliOption.names)
           options[name] = cliOption.config.default;
-        }
-      }
-      if (Array.isArray(cliOption.config.type)) {
-        if (transforms[cliOption.name] === undefined) {
-          transforms[cliOption.name] = Object.create(null);
-          transforms[cliOption.name]["shouldTransform"] = true;
-          transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
-        }
+      if (Array.isArray(cliOption.config.type) && transforms[cliOption.name] === undefined) {
+        transforms[cliOption.name] = Object.create(null);
+        transforms[cliOption.name].shouldTransform = true;
+        transforms[cliOption.name].transformFunction = cliOption.config.type[0];
       }
     }
-    for (const key of Object.keys(parsed)) {
+    for (const key of Object.keys(parsed))
       if (key !== "_") {
-        const keys = key.split(".");
-        setDotProp(options, keys, parsed[key]);
+        setDotProp(options, key.split("."), parsed[key]);
         setByType(options, transforms);
       }
-    }
     return {
       args,
       options
@@ -7375,27 +7390,26 @@ class CAC extends EventEmitter {
     command.checkUnknownOptions();
     command.checkOptionValue();
     command.checkRequiredArgs();
+    command.checkUnusedArgs();
     const actionArgs = [];
     command.args.forEach((arg, index) => {
-      if (arg.variadic) {
+      if (arg.variadic)
         actionArgs.push(args.slice(index));
-      } else {
+      else
         actionArgs.push(args[index]);
-      }
     });
     actionArgs.push(options);
     return command.commandAction.apply(this, actionArgs);
   }
-}
+};
 var cac = (name = "") => new CAC(name);
-var dist_default = cac;
 
 // src/index.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
 import { resolve } from "path";
 
 // src/fetcher.ts
-var import_semver2 = __toESM(require_semver2(), 1);
+var import_semver3 = __toESM(require_semver2(), 1);
 
 // src/types.ts
 var STABILITY_ORDER = {
@@ -7546,7 +7560,8 @@ function formatNewVersion(originalConstraint, newVersion) {
     return `${startPart} - ${cleaned}`;
   }
   if (parsed.type === "range") {
-    return `^${cleaned}`;
+    const updatedConstraint = originalConstraint.replace(/([><!=]+\s*)v?\d+(?:\.\d+)*(?:-[\w.]+)?/i, `$1${cleaned}`);
+    return updatedConstraint || originalConstraint;
   }
   return `${parsed.prefix}${cleaned}`;
 }
@@ -7570,23 +7585,29 @@ function getCacheDir() {
   }
   return path.join(process.env.XDG_CACHE_HOME || path.join(home, ".cache"), "comze");
 }
-async function getCacheEntry(key) {
+function getCacheFilePath(key) {
+  return path.join(getCacheDir(), `${key}.json`);
+}
+async function getCacheEntry(key, expectedVersion) {
   try {
-    const cacheDir = getCacheDir();
-    const filePath = path.join(cacheDir, `${key}.json`);
+    const filePath = getCacheFilePath(key);
     const content = await fs.readFile(filePath, "utf-8");
     const data = JSON.parse(content);
+    if (data.version !== expectedVersion) {
+      return null;
+    }
     return data;
   } catch {
     return null;
   }
 }
-async function setCache(key, value, meta = {}) {
+async function setCache(key, value, version, meta = {}) {
   try {
     const cacheDir = getCacheDir();
     await fs.mkdir(cacheDir, { recursive: true });
-    const filePath = path.join(cacheDir, `${key}.json`);
+    const filePath = getCacheFilePath(key);
     const data = {
+      version,
       timestamp: Date.now(),
       value,
       lastModified: meta.lastModified,
@@ -7595,37 +7616,133 @@ async function setCache(key, value, meta = {}) {
     await fs.writeFile(filePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
-async function touchCache(key) {
+async function touchCache(key, version) {
   try {
-    const entry = await getCacheEntry(key);
+    const entry = await getCacheEntry(key, version);
     if (entry) {
-      await setCache(key, entry.value, { lastModified: entry.lastModified, etag: entry.etag });
+      const now = new Date;
+      await fs.utimes(getCacheFilePath(key), now, now);
     }
   } catch {}
 }
 
+// src/utils/php.ts
+var import_semver2 = __toESM(require_semver2(), 1);
+function normalizeComposerConstraint(constraint) {
+  if (!constraint)
+    return "*";
+  let normalized = constraint.trim();
+  normalized = normalized.replace(/\|\|/g, "<<<OR>>>");
+  normalized = normalized.replace(/\|/g, "<<<OR>>>");
+  normalized = normalized.replace(/<<<OR>>>/g, " || ");
+  normalized = normalized.replace(/\s*\|\|\s*/g, " || ");
+  normalized = normalized.replace(/,\s*/g, " ");
+  normalized = normalized.replace(/@(dev|alpha|beta|rc|stable)/gi, "");
+  if (normalized === "*" || normalized.startsWith("ext-")) {
+    return "*";
+  }
+  return normalized;
+}
+function extractMinVersion(constraint) {
+  const normalized = normalizeComposerConstraint(constraint);
+  if (normalized === "*")
+    return null;
+  const orParts = normalized.split(/\s*\|\|\s*/);
+  let minVersion = null;
+  for (const part of orParts) {
+    const coerced = import_semver2.default.coerce(part.trim());
+    if (coerced) {
+      if (!minVersion || import_semver2.default.lt(coerced.version, minVersion)) {
+        minVersion = coerced.version;
+      }
+    }
+  }
+  return minVersion;
+}
+function extractMaxVersion(constraint) {
+  const normalized = normalizeComposerConstraint(constraint);
+  if (normalized === "*")
+    return null;
+  const upperBoundMatch = normalized.match(/<(=?)\s*(\d+(?:\.\d+)*)/);
+  if (upperBoundMatch) {
+    const coerced = import_semver2.default.coerce(upperBoundMatch[2]);
+    return coerced ? coerced.version : null;
+  }
+  const caretMatch = normalized.match(/\^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (caretMatch) {
+    const major = parseInt(caretMatch[1], 10);
+    return `${major + 1}.0.0`;
+  }
+  return null;
+}
+function checkPhpCompatibility(projectPhp, packagePhp) {
+  if (!packagePhp || packagePhp === "*")
+    return { satisfied: true };
+  if (!projectPhp)
+    return { satisfied: true };
+  const projectMin = extractMinVersion(projectPhp);
+  if (!projectMin)
+    return { satisfied: true };
+  const packageNorm = normalizeComposerConstraint(packagePhp);
+  const packageParts = packageNorm.split(/\s*\|\|\s*/).filter((p) => p.trim());
+  for (const part of packageParts) {
+    const partMax = extractMaxVersion(part);
+    if (partMax && import_semver2.default.gte(projectMin, partMax))
+      continue;
+    try {
+      const range = import_semver2.default.validRange(part.trim());
+      if (range && import_semver2.default.satisfies(projectMin, range))
+        return { satisfied: true };
+    } catch {}
+    const partMin = extractMinVersion(part);
+    if (partMin) {
+      const partMajor = import_semver2.default.major(partMin);
+      const projectMajor = import_semver2.default.major(projectMin);
+      if (part.trim().startsWith("^")) {
+        if (projectMajor === partMajor && import_semver2.default.gte(projectMin, partMin)) {
+          return { satisfied: true };
+        }
+      } else if (import_semver2.default.gte(projectMin, partMin) && !partMax) {
+        return { satisfied: true };
+      }
+    }
+  }
+  return { satisfied: false, reason: `requires php ${packagePhp}` };
+}
+
 // src/fetcher.ts
 var PACKAGIST_API = "https://repo.packagist.org/p2";
-async function fetchPackage(packageName, minStability = "stable", preferStable = true, currentVersion, allowMajor = true, noCache = false) {
+var CACHE_VERSION = 1;
+async function fetchPackage(packageName, minStability = "stable", preferStable = true, currentVersion, allowMajor = true, noCache = false, projectPhp) {
   const cacheKey = packageName.replace("/", "_");
   let cachedEntry = null;
   const headers = {};
   if (!noCache) {
-    cachedEntry = await getCacheEntry(cacheKey);
+    cachedEntry = await getCacheEntry(cacheKey, CACHE_VERSION);
     if (cachedEntry?.lastModified) {
       headers["If-Modified-Since"] = cachedEntry.lastModified;
     }
+    if (cachedEntry?.etag) {
+      headers["If-None-Match"] = cachedEntry.etag;
+    }
   }
+  let data;
   try {
     const url = `${PACKAGIST_API}/${packageName}.json`;
     const response = await fetch(url, { headers });
     if (response.status === 304 && cachedEntry) {
-      await touchCache(cacheKey);
-      return cachedEntry.value;
-    }
-    if (!response.ok)
+      await touchCache(cacheKey, CACHE_VERSION);
+      data = cachedEntry.value;
+    } else if (response.ok) {
+      data = await response.json();
+      if (!noCache) {
+        const lastModified = response.headers.get("Last-Modified") || undefined;
+        const etag = response.headers.get("ETag") || undefined;
+        await setCache(cacheKey, data, CACHE_VERSION, { lastModified, etag });
+      }
+    } else {
       return null;
-    const data = await response.json();
+    }
     const versions = data.packages?.[packageName] ?? [];
     if (versions.length === 0)
       return null;
@@ -7653,21 +7770,39 @@ async function fetchPackage(packageName, minStability = "stable", preferStable =
     }
     if (!selectedVersion)
       return null;
+    let phpIncompatible = false;
+    let skippedVersion;
+    if (projectPhp && selectedVersion.require?.php) {
+      const phpCheck = checkPhpCompatibility(projectPhp, selectedVersion.require.php);
+      if (!phpCheck.satisfied) {
+        phpIncompatible = true;
+        skippedVersion = selectedVersion.version;
+        const versionsToCheck = preferStable ? eligibleVersions.filter((v) => getVersionStability(v.version) === "stable") : eligibleVersions;
+        const compatibleVersion = versionsToCheck.find((v) => {
+          if (!v.require?.php)
+            return true;
+          return checkPhpCompatibility(projectPhp, v.require.php).satisfied;
+        });
+        if (compatibleVersion && compatibleVersion !== selectedVersion) {
+          selectedVersion = compatibleVersion;
+        }
+      }
+    }
     const phpRequirement = selectedVersion.require?.php;
     let majorDetected;
     if (currentVersion) {
       const currentNorm = normalizeVersion(currentVersion);
       const selectedNorm = normalizeVersion(selectedVersion.version);
       if (currentNorm && selectedNorm) {
-        const currentMajor = import_semver2.default.major(currentNorm);
-        const selectedMajor = import_semver2.default.major(selectedNorm);
+        const currentMajor = import_semver3.default.major(currentNorm);
+        const selectedMajor = import_semver3.default.major(selectedNorm);
         if (selectedMajor > currentMajor) {
           majorDetected = selectedVersion.version;
           if (!allowMajor) {
             const versionsToCheck = preferStable ? eligibleVersions.filter((v) => getVersionStability(v.version) === "stable") : eligibleVersions;
             const sameMajorVersion = versionsToCheck.find((v) => {
               const norm = normalizeVersion(v.version);
-              return norm && import_semver2.default.major(norm) === currentMajor;
+              return norm && import_semver3.default.major(norm) === currentMajor;
             });
             if (sameMajorVersion) {
               selectedVersion = sameMajorVersion;
@@ -7689,25 +7824,24 @@ async function fetchPackage(packageName, minStability = "stable", preferStable =
       phpRequirement: selectedVersion.require?.php ?? phpRequirement,
       majorVersion: majorDetected,
       deprecated: deprecatedInfo.deprecated,
-      replacement: deprecatedInfo.replacement
+      replacement: deprecatedInfo.replacement,
+      phpIncompatible: phpIncompatible || undefined,
+      skippedVersion,
+      require: selectedVersion.require
     };
-    if (!noCache) {
-      const lastModified = response.headers.get("Last-Modified") || undefined;
-      await setCache(cacheKey, result, { lastModified });
-    }
     return result;
   } catch {
     return null;
   }
 }
-async function fetchAllPackages(packages, minStability = "stable", preferStable = true, allowMajor = true, noCache = false) {
+async function fetchAllPackages(packages, minStability = "stable", preferStable = true, allowMajor = true, noCache = false, projectPhp) {
   const results = new Map;
   const entries = Object.entries(packages);
   const CONCURRENCY = 5;
   for (let i = 0;i < entries.length; i += CONCURRENCY) {
     const batch = entries.slice(i, i + CONCURRENCY);
     const promises = batch.map(async ([name, version]) => {
-      const result = await fetchPackage(name, minStability, preferStable, version, allowMajor, noCache);
+      const result = await fetchPackage(name, minStability, preferStable, version, allowMajor, noCache, projectPhp);
       if (result)
         results.set(name, result);
     });
@@ -7717,9 +7851,10 @@ async function fetchAllPackages(packages, minStability = "stable", preferStable
 }
 
 // src/writer.ts
-import { readFile, writeFile } from "fs/promises";
+import { readFile, rename, rm, writeFile } from "fs/promises";
 import { existsSync } from "fs";
 import { spawn } from "child_process";
+import { basename, dirname, join } from "path";
 
 // node_modules/detect-indent/index.js
 var INDENT_REGEX = /^(?:( )+|\t+)/;
@@ -7859,12 +7994,17 @@ async function writeComposerJson(path2, updates, dryRun = false) {
     console.log("");
     return true;
   }
+  const tempPath = join(dirname(path2), `.${basename(path2)}.${process.pid}.${Date.now()}.tmp`);
   try {
     const newContent = JSON.stringify(content, null, indent) + `
 `;
-    await writeFile(path2, newContent, "utf-8");
+    await writeFile(tempPath, newContent, "utf-8");
+    await rename(tempPath, path2);
     return true;
   } catch {
+    try {
+      await rm(tempPath, { force: true });
+    } catch {}
     return false;
   }
 }
@@ -7964,6 +8104,9 @@ function renderTable(packages) {
     if (pkg.phpRequirement) {
       extra += import_picocolors.default.gray(`  php ${pkg.phpRequirement}`);
     }
+    if (pkg.phpIncompatible && pkg.skippedVersion) {
+      extra += import_picocolors.default.yellow(`  ${pkg.skippedVersion} skipped (php)`);
+    }
     if (pkg.deprecated) {
       extra += import_picocolors.default.red("  deprecated");
       if (pkg.replacement) {
@@ -7972,6 +8115,15 @@ function renderTable(packages) {
     }
     console.log(`  ${name}  ${oldVer}  ${arrow}  ${coloredNewVer}  ${diffLabel}  ${age}${extra}`);
   }
+  const skippedPackages = packages.filter((p) => p.phpIncompatible && p.skippedVersion);
+  if (skippedPackages.length > 0) {
+    console.log(import_picocolors.default.yellow(`
+  Some versions skipped due to PHP constraints:`));
+    for (const pkg of skippedPackages) {
+      console.log(`    ${import_picocolors.default.bold(pkg.name)} ${pkg.skippedVersion} requires higher PHP version`);
+    }
+    console.log(import_picocolors.default.gray("    Update the php constraint in composer.json to use these versions."));
+  }
   console.log("");
 }
 function renderHeader(version) {
@@ -8012,6 +8164,9 @@ function formatPackageChoice(pkg) {
   if (pkg.phpRequirement) {
     extra += import_picocolors.default.gray(` php ${pkg.phpRequirement}`);
   }
+  if (pkg.phpIncompatible && pkg.skippedVersion) {
+    extra += import_picocolors.default.yellow(` ${pkg.skippedVersion} skipped`);
+  }
   if (pkg.deprecated) {
     extra += import_picocolors.default.red(" deprecated");
     if (pkg.replacement) {
@@ -8054,10 +8209,40 @@ async function selectPackages(packages) {
   const selectedNames = new Set(response.selected);
   return packages.filter((pkg) => selectedNames.has(pkg.name));
 }
+
+// src/config.ts
+function normalizeExcludeList(excludes) {
+  return [...new Set(excludes.map((value) => value.trim().toLowerCase()).filter(Boolean))];
+}
+function getComposerExcludeList(composer) {
+  const excludes = composer.extra?.comze?.exclude;
+  if (!Array.isArray(excludes))
+    return [];
+  const validExcludes = excludes.filter((value) => typeof value === "string");
+  return normalizeExcludeList(validExcludes);
+}
+function mergeExcludeLists(fileExcludes, cliExcludes) {
+  return normalizeExcludeList([...fileExcludes, ...cliExcludes]);
+}
+function filterComposerPackages(allPackages, excludes) {
+  const excludeSet = new Set(normalizeExcludeList(excludes));
+  const filteredPackages = {};
+  const ignoredPackages = [];
+  for (const [name, version] of Object.entries(allPackages)) {
+    if (name === "php" || name.startsWith("ext-"))
+      continue;
+    if (excludeSet.has(name.toLowerCase())) {
+      ignoredPackages.push(name);
+      continue;
+    }
+    filteredPackages[name] = version;
+  }
+  return { filteredPackages, ignoredPackages };
+}
 // package.json
 var package_default = {
   name: "comze",
-  version: "0.3.1",
+  version: "0.4.0",
   description: "A taze-like CLI for updating composer.json dependencies",
   author: "qoqn",
   license: "MIT",
@@ -8096,14 +8281,14 @@ var package_default = {
     "@types/bun": "latest",
     "@types/prompts": "^2.4.9",
     "@types/semver": "^7.7.1",
-    typescript: "^5"
+    typescript: "^6.0.2"
   },
   dependencies: {
-    cac: "^6.7.14",
+    cac: "^7.0.0",
     "detect-indent": "^7.0.2",
     picocolors: "^1.1.1",
     prompts: "^2.4.2",
-    semver: "^7.7.3"
+    semver: "^7.7.4"
   }
 };
 
@@ -8117,23 +8302,22 @@ async function run(options) {
     process.exit(1);
   }
   const minStability = composer.content["minimum-stability"] ?? "stable";
-  const preferStable = composer.content["prefer-stable"] ?? true;
+  const preferStable = composer.content["prefer-stable"] === true;
   const allPackages = {
     ...composer.content.require,
     ...composer.content["require-dev"]
   };
-  const filteredPackages = {};
-  for (const [name, version] of Object.entries(allPackages)) {
-    if (name === "php" || name.startsWith("ext-"))
-      continue;
-    if (options.exclude.includes(name))
-      continue;
-    filteredPackages[name] = version;
-  }
+  const fileExcludes = getComposerExcludeList(composer.content);
+  const excludes = mergeExcludeLists(fileExcludes, options.exclude);
+  const { filteredPackages, ignoredPackages } = filterComposerPackages(allPackages, excludes);
   console.log(import_picocolors2.default.gray(`  Checking ${Object.keys(filteredPackages).length} packages...`));
+  if (ignoredPackages.length > 0) {
+    console.log(import_picocolors2.default.gray(`  Ignoring ${ignoredPackages.length} package${ignoredPackages.length === 1 ? "" : "s"} from exclude list...`));
+  }
   console.log(import_picocolors2.default.gray(`  Stability: ${minStability}${preferStable ? " (prefer-stable)" : ""}
 `));
-  const results = await fetchAllPackages(filteredPackages, minStability, preferStable, options.major, options.noCache);
+  const projectPhp = allPackages["php"];
+  const results = await fetchAllPackages(filteredPackages, minStability, preferStable, options.major, options.noCache, projectPhp);
   const updates = [];
   const deprecatedPackages = [];
   for (const [name, currentVersion] of Object.entries(filteredPackages)) {
@@ -8168,7 +8352,9 @@ async function run(options) {
       majorAvailable,
       phpRequirement: result.phpRequirement,
       deprecated: result.deprecated,
-      replacement: result.replacement
+      replacement: result.replacement,
+      phpIncompatible: result.phpIncompatible,
+      skippedVersion: result.skippedVersion
     });
   }
   const order = { major: 0, minor: 1, patch: 2 };
@@ -8188,7 +8374,11 @@ async function run(options) {
   }
   if (options.write || options.install) {
     const success = await writeComposerJson(composerPath, selectedUpdates, options.dryRun);
-    if (success && !options.dryRun) {
+    if (!success) {
+      console.error(import_picocolors2.default.red("  ✗ Failed to update composer.json"));
+      process.exit(1);
+    }
+    if (!options.dryRun) {
       console.log(import_picocolors2.default.green("  ✓ Updated composer.json"));
       if (options.write && !options.install) {
         console.log(import_picocolors2.default.gray(`
@@ -8220,10 +8410,10 @@ async function run(options) {
 }
 
 // src/cli.ts
-var cli = dist_default("comze");
+var cli = cac("comze");
 cli.option("-w, --write", "Write changes to composer.json", { default: false }).option("-i, --install", "Write changes and run composer update", {
   default: false
-}).option("-I, --interactive", "Select updates manually", { default: false }).option("--major", "Include major updates", { default: false }).option("--minor", "Include minor updates", { default: true }).option("--patch", "Include patch updates", { default: true }).option("--exclude <packages>", "Exclude packages (comma-separated)", {
+}).option("-I, --interactive", "Select updates manually", { default: false }).option("--major", "Include major updates", { default: false }).option("--minor", "Include minor updates", { default: true }).option("--patch", "Include patch updates", { default: true }).option("--exclude <packages>", "Exclude packages (comma-separated, merged with composer.json extra.comze.exclude)", {
   default: ""
 }).option("--dry-run", "Run without making changes", { default: false }).option("--no-cache", "Bypass cache and force fetch from network", { default: false });
 cli.help();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comze",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "A taze-like CLI for updating composer.json dependencies",
   "author": "qoqn",
   "license": "MIT",
@@ -39,13 +39,13 @@
     "@types/bun": "latest",
     "@types/prompts": "^2.4.9",
     "@types/semver": "^7.7.1",
-    "typescript": "^5"
+    "typescript": "^6.0.2"
   },
   "dependencies": {
-    "cac": "^6.7.14",
+    "cac": "^7.0.0",
     "detect-indent": "^7.0.2",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2",
-    "semver": "^7.7.3"
+    "semver": "^7.7.4"
   }
 }