comze 0.3.0 → 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 = {
@@ -7555,7 +7555,6 @@ function formatNewVersion(originalConstraint, newVersion) {
 import fs from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
-var CACHE_TTL = 30 * 60 * 1000;
 function getCacheDir() {
   const home = os.homedir();
   const platform = os.platform();
@@ -7571,84 +7570,160 @@ function getCacheDir() {
   }
   return path.join(process.env.XDG_CACHE_HOME || path.join(home, ".cache"), "comze");
 }
-async function getCache(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 (Date.now() - data.timestamp > CACHE_TTL) {
-      fs.unlink(filePath).catch(() => {});
+    if (data.version !== expectedVersion) {
       return null;
     }
-    return data.value;
+    return data;
   } catch {
     return null;
   }
 }
-async function setCache(key, value) {
+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
+      value,
+      lastModified: meta.lastModified,
+      etag: meta.etag
     };
     await fs.writeFile(filePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
+async function touchCache(key, version) {
+  try {
+    const entry = await getCacheEntry(key, version);
+    if (entry) {
+      await setCache(key, entry.value, version, {
+        lastModified: entry.lastModified,
+        etag: entry.etag
+      });
+    }
+  } catch {}
+}
 
-// src/fetcher.ts
-var PACKAGIST_API = "https://repo.packagist.org/p2";
-var PACKAGIST_PACKAGE_API = "https://packagist.org/packages";
-async function fetchDeprecatedInfo(packageName, noCache = false) {
-  const cacheKey = `${packageName.replace("/", "_")}_deprecated`;
-  if (!noCache) {
-    const cached = await getCache(cacheKey);
-    if (cached)
-      return cached;
+// 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;
+      }
+    }
   }
-  try {
-    const url = `${PACKAGIST_PACKAGE_API}/${packageName}.json`;
-    const response = await fetch(url);
-    if (!response.ok)
-      return {};
-    const data = await response.json();
-    const abandoned = data.package?.abandoned;
-    if (!abandoned) {
-      const result2 = {};
-      if (!noCache)
-        await setCache(cacheKey, result2);
-      return result2;
-    }
-    if (typeof abandoned === "string") {
-      const result2 = { deprecated: true, replacement: abandoned };
-      if (!noCache)
-        await setCache(cacheKey, result2);
-      return result2;
-    }
-    const result = { deprecated: true };
-    if (!noCache)
-      await setCache(cacheKey, result);
-    return result;
-  } catch {
-    return {};
+  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}` };
 }
-async function fetchPackage(packageName, minStability = "stable", preferStable = true, currentVersion, allowMajor = true, noCache = false) {
+
+// src/fetcher.ts
+var PACKAGIST_API = "https://repo.packagist.org/p2";
+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) {
-    const cached = await getCache(cacheKey);
-    if (cached)
-      return cached;
+    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);
-    if (!response.ok)
+    const response = await fetch(url, { headers });
+    if (response.status === 304 && cachedEntry) {
+      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;
@@ -7676,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;
@@ -7699,31 +7792,37 @@ async function fetchPackage(packageName, minStability = "stable", preferStable =
         }
       }
     }
-    const deprecatedInfo = await fetchDeprecatedInfo(packageName, noCache);
+    const deprecatedInfo = {};
+    if (typeof selectedVersion.abandoned === "string") {
+      deprecatedInfo.deprecated = true;
+      deprecatedInfo.replacement = selectedVersion.abandoned;
+    } else if (selectedVersion.abandoned) {
+      deprecatedInfo.deprecated = true;
+    }
     const result = {
       latestVersion: selectedVersion.version,
       releaseTime: selectedVersion.time,
       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) {
-      await setCache(cacheKey, result);
-    }
     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);
     });
@@ -7980,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) {
@@ -7988,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) {
@@ -8028,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) {
@@ -8073,7 +8187,7 @@ async function selectPackages(packages) {
 // package.json
 var package_default = {
   name: "comze",
-  version: "0.3.0",
+  version: "0.3.2",
   description: "A taze-like CLI for updating composer.json dependencies",
   author: "qoqn",
   license: "MIT",
@@ -8149,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)) {
@@ -8184,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.0",
+  "version": "0.3.2",
   "description": "A taze-like CLI for updating composer.json dependencies",
   "author": "qoqn",
   "license": "MIT",