comze 0.2.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

@@ -7422,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(/\.$/, "");
@@ -7434,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();
@@ -7521,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, currentVersion, allowMajor = 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);
@@ -7580,24 +7699,31 @@ async function fetchPackage(packageName, minStability = "stable", preferStable =
         }
       }
     }
-    return {
+    const deprecatedInfo = await fetchDeprecatedInfo(packageName, noCache);
+    const result = {
       latestVersion: selectedVersion.version,
       releaseTime: selectedVersion.time,
       phpRequirement: selectedVersion.require?.php ?? phpRequirement,
-      majorVersion: majorDetected
+      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, allowMajor = 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, version]) => {
-      const result = await fetchPackage(name, minStability, preferStable, version, allowMajor);
+      const result = await fetchPackage(name, minStability, preferStable, version, allowMajor, noCache);
       if (result)
         results.set(name, result);
     });
@@ -7712,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 };
@@ -7724,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;
@@ -7752,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;
@@ -7854,6 +7980,12 @@ function renderTable(packages) {
     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("");
@@ -7896,8 +8028,24 @@ function formatPackageChoice(pkg) {
   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
 var import_prompts = __toESM(require_prompts3(), 1);
@@ -7922,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) {
@@ -7950,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, options.major);
+  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;
@@ -7975,12 +8182,15 @@ async function run(options) {
       age: formatAge(result.releaseTime),
       ageMonths: getAgeMonths(result.releaseTime),
       majorAvailable,
-      phpRequirement: result.phpRequirement
+      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;
@@ -8027,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,
@@ -8039,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.2.0",
+  "version": "0.3.0",
   "description": "A taze-like CLI for updating composer.json dependencies",
   "author": "qoqn",
   "license": "MIT",