comze 0.1.0 → 0.3.0

package/README.md

@@ -10,6 +10,7 @@ A [taze](https://github.com/antfu/taze)-like CLI for updating `composer.json` de
 - 🎯 Respects `minimum-stability` and `prefer-stable`
 - 🚫 Major updates hidden by default
 - ✍️ Interactive selection mode
+- ⚠️ Detects deprecated packages
 
 ## Installation
 
@@ -50,16 +51,16 @@ comze --exclude vendor/package
 
 ## Options
 
-| Flag | Description |
-|------|-------------|
-| `-w, --write` | Write changes to `composer.json` |
-| `-i, --install` | Write changes and run `composer update` |
-| `-I, --interactive` | Select updates manually |
-| `--major` | Include major updates (default: false) |
-| `--minor` | Include minor updates (default: true) |
-| `--patch` | Include patch updates (default: true) |
-| `--exclude <pkgs>` | Exclude packages (comma-separated) |
-| `--dry-run` | Preview changes without writing |
+| Flag                | Description                             |
+| ------------------- | --------------------------------------- |
+| `-w, --write`       | Write changes to `composer.json`        |
+| `-i, --install`     | Write changes and run `composer update` |
+| `-I, --interactive` | Select updates manually                 |
+| `--major`           | Include major updates (default: false)  |
+| `--minor`           | Include minor updates (default: true)   |
+| `--patch`           | Include patch updates (default: true)   |
+| `--exclude <pkgs>`  | Exclude packages (comma-separated)      |
+| `--dry-run`         | Preview changes without writing         |
 
 ## Composer Stability
 
@@ -76,15 +77,15 @@ comze reads `minimum-stability` and `prefer-stable` from your `composer.json`:
 
 All Composer version constraints are supported:
 
-| Type | Example |
-|------|---------|
-| Exact | `1.0.2` |
-| Caret | `^1.2.3` |
-| Tilde | `~1.2` |
-| Wildcard | `1.0.*` |
-| Range | `>=1.0 <2.0` |
-| Hyphenated | `1.0 - 2.0` |
-| Dev | `dev-main`, `1.x-dev` |
+| Type       | Example               |
+| ---------- | --------------------- |
+| Exact      | `1.0.2`               |
+| Caret      | `^1.2.3`              |
+| Tilde      | `~1.2`                |
+| Wildcard   | `1.0.*`               |
+| Range      | `>=1.0 <2.0`          |
+| Hyphenated | `1.0 - 2.0`           |
+| Dev        | `dev-main`, `1.x-dev` |
 
 ## Development
 

package/bin/comze.mjs

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import '../dist/cli.mjs';
+import "../dist/cli.mjs";

package/dist/cli.mjs

@@ -7394,6 +7394,9 @@ var dist_default = cac;
 var import_picocolors2 = __toESM(require_picocolors(), 1);
 import { resolve } from "path";
 
+// src/fetcher.ts
+var import_semver2 = __toESM(require_semver2(), 1);
+
 // src/types.ts
 var STABILITY_ORDER = {
   dev: 0,
@@ -7419,11 +7422,23 @@ function parseConstraint(constraint) {
   }
   if (original.startsWith("^")) {
     const version = original.slice(1);
-    return { type: "caret", prefix: "^", baseVersion: normalizeVersionString(version), original, isDev: hasDevSuffix(version) };
+    return {
+      type: "caret",
+      prefix: "^",
+      baseVersion: normalizeVersionString(version),
+      original,
+      isDev: hasDevSuffix(version)
+    };
   }
   if (original.startsWith("~")) {
     const version = original.slice(1);
-    return { type: "tilde", prefix: "~", baseVersion: normalizeVersionString(version), original, isDev: hasDevSuffix(version) };
+    return {
+      type: "tilde",
+      prefix: "~",
+      baseVersion: normalizeVersionString(version),
+      original,
+      isDev: hasDevSuffix(version)
+    };
   }
   if (original.includes("*")) {
     const basePart = (original.split("*")[0] ?? "").replace(/\.$/, "");
@@ -7431,16 +7446,34 @@ function parseConstraint(constraint) {
   }
   if (original.includes(" - ")) {
     const startVersion = (original.split(" - ")[0] ?? "").trim();
-    return { type: "hyphen", prefix: "", baseVersion: normalizeVersionString(startVersion), original, isDev: false };
+    return {
+      type: "hyphen",
+      prefix: "",
+      baseVersion: normalizeVersionString(startVersion),
+      original,
+      isDev: false
+    };
   }
   const rangeMatch = original.match(/^([><!=]+)/);
   if (rangeMatch) {
     const versionMatch = original.match(/([><!=]+)\s*(\d+(?:\.\d+)*(?:-[\w.]+)?)/);
     const version = versionMatch?.[2] ?? original.replace(/[><!=]+/g, "");
     const prefix = rangeMatch[1] ?? ">=";
-    return { type: "range", prefix, baseVersion: normalizeVersionString(version), original, isDev: hasDevSuffix(version) };
+    return {
+      type: "range",
+      prefix,
+      baseVersion: normalizeVersionString(version),
+      original,
+      isDev: hasDevSuffix(version)
+    };
   }
-  return { type: "exact", prefix: "", baseVersion: normalizeVersionString(original), original, isDev: hasDevSuffix(original) };
+  return {
+    type: "exact",
+    prefix: "",
+    baseVersion: normalizeVersionString(original),
+    original,
+    isDev: hasDevSuffix(original)
+  };
 }
 function hasDevSuffix(version) {
   const lower = version.toLowerCase();
@@ -7518,9 +7551,98 @@ function formatNewVersion(originalConstraint, newVersion) {
   return `${parsed.prefix}${cleaned}`;
 }
 
+// src/cache.ts
+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();
+  const overrideDir = process.env.COMZE_CACHE_DIR?.trim();
+  if (overrideDir) {
+    return overrideDir;
+  }
+  if (platform === "win32") {
+    return path.join(process.env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "comze", "Cache");
+  }
+  if (platform === "darwin") {
+    return path.join(home, "Library", "Caches", "comze");
+  }
+  return path.join(process.env.XDG_CACHE_HOME || path.join(home, ".cache"), "comze");
+}
+async function getCache(key) {
+  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(() => {});
+      return null;
+    }
+    return data.value;
+  } catch {
+    return null;
+  }
+}
+async function setCache(key, value) {
+  try {
+    const cacheDir = getCacheDir();
+    await fs.mkdir(cacheDir, { recursive: true });
+    const filePath = path.join(cacheDir, `${key}.json`);
+    const data = {
+      timestamp: Date.now(),
+      value
+    };
+    await fs.writeFile(filePath, JSON.stringify(data), "utf-8");
+  } catch {}
+}
+
 // src/fetcher.ts
 var PACKAGIST_API = "https://repo.packagist.org/p2";
-async function fetchPackage(packageName, minStability = "stable", preferStable = true) {
+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;
+  }
+  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 {};
+  }
+}
+async function fetchPackage(packageName, minStability = "stable", preferStable = true, currentVersion, allowMajor = true, noCache = false) {
+  const cacheKey = packageName.replace("/", "_");
+  if (!noCache) {
+    const cached = await getCache(cacheKey);
+    if (cached)
+      return cached;
+  }
   try {
     const url = `${PACKAGIST_API}/${packageName}.json`;
     const response = await fetch(url);
@@ -7542,31 +7664,66 @@ async function fetchPackage(packageName, minStability = "stable", preferStable =
         return null;
       return { latestVersion: first.version, releaseTime: first.time };
     }
+    let selectedVersion = null;
     if (preferStable) {
       const stableVersions = eligibleVersions.filter((v) => getVersionStability(v.version) === "stable");
       if (stableVersions.length > 0) {
-        const latest2 = stableVersions[0];
-        if (!latest2)
-          return null;
-        return { latestVersion: latest2.version, releaseTime: latest2.time };
+        selectedVersion = stableVersions[0] ?? null;
       }
     }
-    const latest = eligibleVersions[0];
-    if (!latest)
+    if (!selectedVersion) {
+      selectedVersion = eligibleVersions[0] ?? null;
+    }
+    if (!selectedVersion)
       return null;
-    return { latestVersion: latest.version, releaseTime: latest.time };
+    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);
+        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;
+            });
+            if (sameMajorVersion) {
+              selectedVersion = sameMajorVersion;
+            }
+          }
+        }
+      }
+    }
+    const deprecatedInfo = await fetchDeprecatedInfo(packageName, noCache);
+    const result = {
+      latestVersion: selectedVersion.version,
+      releaseTime: selectedVersion.time,
+      phpRequirement: selectedVersion.require?.php ?? phpRequirement,
+      majorVersion: majorDetected,
+      deprecated: deprecatedInfo.deprecated,
+      replacement: deprecatedInfo.replacement
+    };
+    if (!noCache) {
+      await setCache(cacheKey, result);
+    }
+    return result;
   } catch {
     return null;
   }
 }
-async function fetchAllPackages(packages, minStability = "stable", preferStable = true) {
+async function fetchAllPackages(packages, minStability = "stable", preferStable = true, allowMajor = true, noCache = false) {
   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]) => {
-      const result = await fetchPackage(name, minStability, preferStable);
+    const promises = batch.map(async ([name, version]) => {
+      const result = await fetchPackage(name, minStability, preferStable, version, allowMajor, noCache);
       if (result)
         results.set(name, result);
     });
@@ -7681,11 +7838,11 @@ function detectIndent(string) {
 }
 
 // src/writer.ts
-async function readComposerJson(path) {
-  if (!existsSync(path))
+async function readComposerJson(path2) {
+  if (!existsSync(path2))
     return null;
   try {
-    const raw = await readFile(path, "utf-8");
+    const raw = await readFile(path2, "utf-8");
     const indent = detectIndent(raw).indent || "    ";
     const content = JSON.parse(raw);
     return { content, raw, indent };
@@ -7693,8 +7850,8 @@ async function readComposerJson(path) {
     return null;
   }
 }
-async function writeComposerJson(path, updates, dryRun = false) {
-  const result = await readComposerJson(path);
+async function writeComposerJson(path2, updates, dryRun = false) {
+  const result = await readComposerJson(path2);
   if (!result)
     return false;
   const { content, indent } = result;
@@ -7721,7 +7878,7 @@ async function writeComposerJson(path, updates, dryRun = false) {
   try {
     const newContent = JSON.stringify(content, null, indent) + `
 `;
-    await writeFile(path, newContent, "utf-8");
+    await writeFile(path2, newContent, "utf-8");
     return true;
   } catch {
     return false;
@@ -7764,9 +7921,25 @@ function formatAge(isoDate) {
   }
   return "now";
 }
+function getAgeMonths(isoDate) {
+  const date = new Date(isoDate);
+  const now = new Date;
+  const diffMs = now.getTime() - date.getTime();
+  const msPerMonth = 30 * 24 * 60 * 60 * 1000;
+  return Math.floor(diffMs / msPerMonth);
+}
 
 // src/ui/render.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
+function colorAge(age, ageMonths) {
+  if (ageMonths < 3) {
+    return import_picocolors.default.green(age.padStart(6));
+  } else if (ageMonths < 12) {
+    return import_picocolors.default.yellow(age.padStart(6));
+  } else {
+    return import_picocolors.default.red(age.padStart(6));
+  }
+}
 function renderTable(packages) {
   if (packages.length === 0) {
     console.log(import_picocolors.default.green(`
@@ -7783,7 +7956,7 @@ function renderTable(packages) {
     const oldVer = pkg.currentVersion.padStart(oldWidth);
     const arrow = "→";
     const newVer = pkg.latestVersion.padEnd(newWidth);
-    const age = import_picocolors.default.gray(pkg.age.padStart(6));
+    const age = colorAge(pkg.age, pkg.ageMonths);
     let diffLabel;
     let coloredNewVer;
     switch (pkg.diffType) {
@@ -7800,7 +7973,20 @@ function renderTable(packages) {
         coloredNewVer = import_picocolors.default.green(newVer);
         break;
     }
-    console.log(`  ${name}  ${oldVer}  ${arrow}  ${coloredNewVer}  ${diffLabel}  ${age}`);
+    let extra = "";
+    if (pkg.majorAvailable) {
+      extra += import_picocolors.default.magenta(`  ${pkg.majorAvailable} available`);
+    }
+    if (pkg.phpRequirement) {
+      extra += import_picocolors.default.gray(`  php ${pkg.phpRequirement}`);
+    }
+    if (pkg.deprecated) {
+      extra += import_picocolors.default.red("  deprecated");
+      if (pkg.replacement) {
+        extra += import_picocolors.default.yellow(` → ${pkg.replacement}`);
+      }
+    }
+    console.log(`  ${name}  ${oldVer}  ${arrow}  ${coloredNewVer}  ${diffLabel}  ${age}${extra}`);
   }
   console.log("");
 }
@@ -7834,7 +8020,31 @@ function formatPackageChoice(pkg) {
       coloredNewVer = import_picocolors.default.green(pkg.latestVersion);
       break;
   }
-  return `${import_picocolors.default.bold(pkg.name)} ${pkg.currentVersion} ${arrow} ${coloredNewVer} ${diffLabel} ${import_picocolors.default.gray(pkg.age)}`;
+  const age = colorAge(pkg.age, pkg.ageMonths);
+  let extra = "";
+  if (pkg.majorAvailable) {
+    extra += import_picocolors.default.magenta(` ${pkg.majorAvailable} available`);
+  }
+  if (pkg.phpRequirement) {
+    extra += import_picocolors.default.gray(` php ${pkg.phpRequirement}`);
+  }
+  if (pkg.deprecated) {
+    extra += import_picocolors.default.red(" deprecated");
+    if (pkg.replacement) {
+      extra += import_picocolors.default.yellow(` → ${pkg.replacement}`);
+    }
+  }
+  return `${import_picocolors.default.bold(pkg.name)} ${pkg.currentVersion} ${arrow} ${coloredNewVer} ${diffLabel} ${age}${extra}`;
+}
+function renderDeprecated(packages) {
+  if (packages.length === 0)
+    return;
+  console.log(import_picocolors.default.yellow("  Deprecated packages detected:"));
+  for (const pkg of packages) {
+    const replacement = pkg.replacement ? import_picocolors.default.yellow(` → ${pkg.replacement}`) : "";
+    console.log(`  ${import_picocolors.default.red("!")} ${import_picocolors.default.bold(pkg.name)} ${import_picocolors.default.gray(pkg.currentVersion)}${replacement}`);
+  }
+  console.log("");
 }
 
 // src/interactive.ts
@@ -7860,11 +8070,62 @@ async function selectPackages(packages) {
   const selectedNames = new Set(response.selected);
   return packages.filter((pkg) => selectedNames.has(pkg.name));
 }
+// package.json
+var package_default = {
+  name: "comze",
+  version: "0.3.0",
+  description: "A taze-like CLI for updating composer.json dependencies",
+  author: "qoqn",
+  license: "MIT",
+  keywords: [
+    "composer",
+    "php",
+    "dependencies",
+    "update",
+    "cli",
+    "taze"
+  ],
+  type: "module",
+  main: "./dist/cli.mjs",
+  module: "./dist/cli.mjs",
+  bin: {
+    comze: "bin/comze.mjs"
+  },
+  files: [
+    "dist",
+    "bin"
+  ],
+  scripts: {
+    dev: "bun run src/cli.ts",
+    build: "bun build src/cli.ts --outfile dist/cli.mjs --target node",
+    prepublishOnly: "bun run build",
+    test: "bun test"
+  },
+  engines: {
+    node: ">=18"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/qoqn/comze.git"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/prompts": "^2.4.9",
+    "@types/semver": "^7.7.1",
+    typescript: "^5"
+  },
+  dependencies: {
+    cac: "^6.7.14",
+    "detect-indent": "^7.0.2",
+    picocolors: "^1.1.1",
+    prompts: "^2.4.2",
+    semver: "^7.7.3"
+  }
+};
 
 // src/index.ts
-var VERSION = "0.1.0";
 async function run(options) {
-  renderHeader(VERSION);
+  renderHeader(package_default.version);
   const composerPath = resolve(process.cwd(), "composer.json");
   const composer = await readComposerJson(composerPath);
   if (!composer) {
@@ -7888,12 +8149,20 @@ 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);
+  const results = await fetchAllPackages(filteredPackages, minStability, preferStable, options.major, options.noCache);
   const updates = [];
+  const deprecatedPackages = [];
   for (const [name, currentVersion] of Object.entries(filteredPackages)) {
     const result = results.get(name);
     if (!result)
       continue;
+    if (result.deprecated) {
+      deprecatedPackages.push({
+        name,
+        currentVersion,
+        replacement: result.replacement
+      });
+    }
     const diffType = getDiffType(currentVersion, result.latestVersion);
     if (!diffType)
       continue;
@@ -7903,18 +8172,25 @@ async function run(options) {
       continue;
     if (diffType === "patch" && !options.patch)
       continue;
+    const majorAvailable = !options.major && result.majorVersion ? result.majorVersion : undefined;
     updates.push({
       name,
       currentVersion,
       latestVersion: result.latestVersion,
       diffType,
       releaseTime: result.releaseTime,
-      age: formatAge(result.releaseTime)
+      age: formatAge(result.releaseTime),
+      ageMonths: getAgeMonths(result.releaseTime),
+      majorAvailable,
+      phpRequirement: result.phpRequirement,
+      deprecated: result.deprecated,
+      replacement: result.replacement
     });
   }
   const order = { major: 0, minor: 1, patch: 2 };
   updates.sort((a, b) => order[a.diffType] - order[b.diffType]);
   renderTable(updates);
+  renderDeprecated(deprecatedPackages);
   if (updates.length === 0)
     return;
   let selectedUpdates = updates;
@@ -7929,8 +8205,14 @@ async function run(options) {
   if (options.write || options.install) {
     const success = await writeComposerJson(composerPath, selectedUpdates, options.dryRun);
     if (success && !options.dryRun) {
-      console.log(import_picocolors2.default.green(`  ✓ Updated composer.json
+      console.log(import_picocolors2.default.green("  ✓ Updated composer.json"));
+      if (options.write && !options.install) {
+        console.log(import_picocolors2.default.gray(`
+  Run "composer update" to install the new versions
 `));
+      } else {
+        console.log("");
+      }
     }
   }
   if (options.install && !options.dryRun) {
@@ -7955,9 +8237,13 @@ async function run(options) {
 
 // src/cli.ts
 var cli = dist_default("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)", { default: "" }).option("--dry-run", "Run without making changes", { default: false });
+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)", {
+  default: ""
+}).option("--dry-run", "Run without making changes", { default: false }).option("--no-cache", "Bypass cache and force fetch from network", { default: false });
 cli.help();
-cli.version("0.1.0");
+cli.version(package_default.version);
 cli.command("", "Check for updates in composer.json").action(async (cliOptions) => {
   const options = {
     write: cliOptions.write || cliOptions.install,
@@ -7967,7 +8253,8 @@ cli.command("", "Check for updates in composer.json").action(async (cliOptions)
     minor: cliOptions.minor,
     patch: cliOptions.patch,
     exclude: cliOptions.exclude ? cliOptions.exclude.split(",").map((s) => s.trim()) : [],
-    dryRun: cliOptions.dryRun
+    dryRun: cliOptions.dryRun,
+    noCache: cliOptions.noCache
   };
   await run(options);
 });

package/package.json

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