comze 0.3.1 → 0.3.2

package/dist/cli.mjs

@@ -7395,7 +7395,7 @@ 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 = {
@@ -7570,23 +7570,27 @@ function getCacheDir() {
   }
   return path.join(process.env.XDG_CACHE_HOME || path.join(home, ".cache"), "comze");
 }
-async function getCacheEntry(key) {
+async function getCacheEntry(key, expectedVersion) {
   try {
     const cacheDir = getCacheDir();
     const filePath = path.join(cacheDir, `${key}.json`);
     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 data = {
+      version,
       timestamp: Date.now(),
       value,
       lastModified: meta.lastModified,
@@ -7595,37 +7599,131 @@ 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 });
+      await setCache(key, entry.value, version, {
+        lastModified: entry.lastModified,
+        etag: entry.etag
+      });
     }
   } 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;
     }
   }
+  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;
+        await setCache(cacheKey, data, CACHE_VERSION, { lastModified });
+      }
+    } else {
       return null;
-    const data = await response.json();
+    }
     const versions = data.packages?.[packageName] ?? [];
     if (versions.length === 0)
       return null;
@@ -7653,21 +7751,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 +7805,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);
     });
@@ -7964,6 +8079,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 +8090,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 +8139,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) {
@@ -8057,7 +8187,7 @@ async function selectPackages(packages) {
 // package.json
 var package_default = {
   name: "comze",
-  version: "0.3.1",
+  version: "0.3.2",
   description: "A taze-like CLI for updating composer.json dependencies",
   author: "qoqn",
   license: "MIT",
@@ -8133,7 +8263,8 @@ async function run(options) {
   console.log(import_picocolors2.default.gray(`  Checking ${Object.keys(filteredPackages).length} packages...`));
   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 +8299,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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comze",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "A taze-like CLI for updating composer.json dependencies",
   "author": "qoqn",
   "license": "MIT",