@oh-my-pi/pi-utils 17.2.7 → 17.2.9

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [17.2.9] - 2026-08-05
+
+### Added
+
+- Added a public `compareVersions` utility (`@oh-my-pi/pi-utils`) that compares two version strings with SemVer-2.0 prerelease ordering, build-metadata stripping, and numeric segment comparison without float overflow; never throws.
+
+### Fixed
+
+- Honor the current process `PATH` when caching executable lookups, preventing stale tool paths after environment reloads.
+- Parsed account-cap reset windows such as “Your limit will reset in 13 minutes” so credential backoff honors the provider's full reset duration.
+
 ## [17.2.6] - 2026-08-03
 
 ### Added

package/dist/types/index.d.ts

@@ -34,5 +34,6 @@ export * from "./tab-spacing.js";
 export * from "./temp.js";
 export * from "./tls-fetch.js";
 export * from "./type-guards.js";
+export * from "./version.js";
 export * from "./which.js";
 export declare function structuredCloneJSON<T>(value: T): T;

package/dist/types/version.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Compare two version strings.
+ *
+ * Canonical comparator that supersedes the historical in-repo copies
+ * (update-cli, hackage scraper, release scripts):
+ * - inputs are trimmed and at most one leading `v`/`V` is stripped
+ * - dot-separated segments are compared numerically, missing trailing
+ *   segments count as 0, so `1.2` === `1.2.0` and any segment count works
+ * - a SemVer-2.0 prerelease suffix sorts before the plain release
+ *   (`1.0.0-beta` < `1.0.0`); prerelease identifiers follow SemVer order
+ *   (numeric < alphanumeric, numeric compared by value, alphanumeric
+ *   compared lexically, longer sets of equal fields win)
+ * - SemVer build metadata begins at the first `+` and does not participate
+ *   in precedence; it is stripped before core/prerelease parsing
+ * - malformed numeric segments compare as 0 (`1.2.x` === `1.2.0`)
+ * - never throws; returns only -1 | 0 | 1
+ */
+export declare function compareVersions(a: string, b: string): number;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-utils",
-	"version": "17.2.7",
+	"version": "17.2.9",
 	"description": "Shared utilities for pi packages",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -31,7 +31,7 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "17.2.7",
+		"@oh-my-pi/pi-natives": "17.2.9",
 		"handlebars": "^4.7.9",
 		"winston": "^3.19.0",
 		"winston-daily-rotate-file": "5.0.0"

package/src/fetch-retry.ts

@@ -10,6 +10,8 @@ const RETRY_DELAY_FIELD_PATTERN = /"retryDelay":\s*"([0-9.]+)(ms|s)"/i;
 // "try again in 5 min" / "try again in ~158 min." / "try again in 2h" /
 // "try again in 90 minutes" / "try again in 1 hour"
 const TRY_AGAIN_PATTERN = /try again in\s+~?\s*([0-9.]+)\s*(ms|sec|s|minutes?|mins?|m|hours?|hrs?|h)\b/i;
+// "Your limit will reset in 13 minutes" / "reset in 13 minutes" / "will reset in 2h"
+const WILL_RESET_IN_PATTERN = /(?:will\s+)?reset in\s+~?\s*([0-9.]+)\s*(ms|sec|s|minutes?|mins?|m|hours?|hrs?|h)\b/i;
 
 /**
  * Server-suggested retry delay extraction. Merges the patterns historically used
@@ -83,7 +85,11 @@ export function extractRetryHint(source: Response | Headers | null | undefined,
 			if (totalMs > 0) return totalMs;
 		}
 	}
-	for (const pattern of [PLEASE_RETRY_PATTERN, RETRY_DELAY_FIELD_PATTERN, TRY_AGAIN_PATTERN]) {
+	// Account-reset hints ("will reset in …") take precedence over short
+	// retry hints ("please retry in 5s"): a body carrying both must honour the
+	// longer account window, not the shorter generic one. QUOTA_RESET_PATTERN
+	// ("reset after …") above already runs first and stays first.
+	for (const pattern of [WILL_RESET_IN_PATTERN, PLEASE_RETRY_PATTERN, RETRY_DELAY_FIELD_PATTERN, TRY_AGAIN_PATTERN]) {
 		const match = pattern.exec(body);
 		if (match?.[1]) {
 			const value = Number.parseFloat(match[1]);

package/src/frontmatter.ts

@@ -71,7 +71,7 @@ export class FrontmatterError extends Error {
 		this.name = "FrontmatterError";
 	}
 
-	toString(): string {
+	override toString(): string {
 		// Format the error with stack and detail, including the error message, stack, and source if present
 		const details: string[] = [this.message];
 		if (this.source !== undefined) {

package/src/index.ts

@@ -34,6 +34,7 @@ export * from "./tab-spacing";
 export * from "./temp";
 export * from "./tls-fetch";
 export * from "./type-guards";
+export * from "./version";
 export * from "./which";
 
 function isPlainObject(val: object): val is Record<string, unknown> {

package/src/version.ts

@@ -0,0 +1,99 @@
+const DIGITS = /^\d+$/;
+
+/**
+ * Compare two version strings.
+ *
+ * Canonical comparator that supersedes the historical in-repo copies
+ * (update-cli, hackage scraper, release scripts):
+ * - inputs are trimmed and at most one leading `v`/`V` is stripped
+ * - dot-separated segments are compared numerically, missing trailing
+ *   segments count as 0, so `1.2` === `1.2.0` and any segment count works
+ * - a SemVer-2.0 prerelease suffix sorts before the plain release
+ *   (`1.0.0-beta` < `1.0.0`); prerelease identifiers follow SemVer order
+ *   (numeric < alphanumeric, numeric compared by value, alphanumeric
+ *   compared lexically, longer sets of equal fields win)
+ * - SemVer build metadata begins at the first `+` and does not participate
+ *   in precedence; it is stripped before core/prerelease parsing
+ * - malformed numeric segments compare as 0 (`1.2.x` === `1.2.0`)
+ * - never throws; returns only -1 | 0 | 1
+ */
+export function compareVersions(a: string, b: string): number {
+	const pa = parseVersion(a);
+	const pb = parseVersion(b);
+
+	const core = compareNumericParts(pa.core, pb.core);
+	if (core !== 0) return core;
+
+	return comparePrerelease(pa.prerelease, pb.prerelease);
+}
+
+interface ParsedVersion {
+	core: string[];
+	prerelease: string[] | null;
+}
+
+function parseVersion(version: string): ParsedVersion {
+	const trimmed = version.trim();
+	const stripped = trimmed.startsWith("v") || trimmed.startsWith("V") ? trimmed.slice(1) : trimmed;
+	const plusIndex = stripped.indexOf("+");
+	const withoutBuild = plusIndex === -1 ? stripped : stripped.slice(0, plusIndex);
+	const dashIndex = withoutBuild.indexOf("-");
+	if (dashIndex === -1) {
+		return { core: withoutBuild.split("."), prerelease: null };
+	}
+	return {
+		core: withoutBuild.slice(0, dashIndex).split("."),
+		prerelease: withoutBuild.slice(dashIndex + 1).split("."),
+	};
+}
+
+/** Compare dot-separated numeric segments; missing/malformed segments count as 0. */
+function compareNumericParts(a: string[], b: string[]): number {
+	const length = Math.max(a.length, b.length);
+	for (let i = 0; i < length; i++) {
+		// Missing or malformed segments compare as 0.
+		const sa = a[i];
+		const sb = b[i];
+		const result = compareDigits(
+			sa !== undefined && DIGITS.test(sa) ? sa : "0",
+			sb !== undefined && DIGITS.test(sb) ? sb : "0",
+		);
+		if (result !== 0) return result;
+	}
+	return 0;
+}
+
+/** Exact integer comparison of digit strings, avoiding float overflow. */
+function compareDigits(a: string, b: string): number {
+	const na = a.replace(/^0+/, "") || "0";
+	const nb = b.replace(/^0+/, "") || "0";
+	if (na.length !== nb.length) return na.length < nb.length ? -1 : 1;
+	if (na < nb) return -1;
+	if (na > nb) return 1;
+	return 0;
+}
+
+/** SemVer-2.0 prerelease ordering; null means a plain release, which wins. */
+function comparePrerelease(a: string[] | null, b: string[] | null): number {
+	if (a === null || b === null) {
+		return a === b ? 0 : a === null ? 1 : -1;
+	}
+	const length = Math.max(a.length, b.length);
+	for (let i = 0; i < length; i++) {
+		const ia = a[i];
+		const ib = b[i];
+		if (ia === undefined) return -1;
+		if (ib === undefined) return 1;
+		const aNumeric = DIGITS.test(ia);
+		const bNumeric = DIGITS.test(ib);
+		if (aNumeric && bNumeric) {
+			const result = compareDigits(ia, ib);
+			if (result !== 0) return result;
+		} else if (aNumeric !== bNumeric) {
+			return aNumeric ? -1 : 1;
+		} else if (ia !== ib) {
+			return ia < ib ? -1 : 1;
+		}
+	}
+	return 0;
+}

package/src/which.ts

@@ -183,8 +183,8 @@ export interface WhichOptions extends Bun.WhichOptions {
 
 // Darwin-specific "which" shim: consult Xcode/CLT toolchain directories after $PATH.
 // Uses cached directory listings instead of per-command existsSync or xcrun subprocesses.
-function darwinWhich(command: string, _options?: Bun.WhichOptions): string | null {
-	const regular = Bun.which(command);
+function darwinWhich(command: string, options?: Bun.WhichOptions): string | null {
+	const regular = Bun.which(command, options);
 	if (regular) return regular;
 	if (isXcodeBin(command)) {
 		return getMacosToolPaths().get(command) ?? null;
@@ -214,17 +214,19 @@ function cacheKey(command: string, options?: Bun.WhichOptions): CacheKey {
  */
 export function $which(command: string, options?: WhichOptions): string | null {
 	const cachePolicy = options?.cache ?? WhichCachePolicy.Cached;
+	const lookupOptions =
+		options?.PATH !== undefined || process.env.PATH === undefined ? options : { ...options, PATH: process.env.PATH };
 	let key: CacheKey | undefined;
 
 	if (cachePolicy !== WhichCachePolicy.Bypass) {
-		key = cacheKey(command, options);
+		key = cacheKey(command, lookupOptions);
 		if (cachePolicy !== WhichCachePolicy.Fresh) {
 			const cached = toolCache.get(key);
 			if (cached !== undefined) return cached;
 		}
 	}
 
-	const result = whichFresh(command, options);
+	const result = whichFresh(command, lookupOptions);
 	if (key != null && cachePolicy !== WhichCachePolicy.ReadOnly) {
 		toolCache.set(key, result);
 	}