@askrjs/cli 0.0.2

package/dist/update-DyW1na5V.js

@@ -0,0 +1,1140 @@
+import { t as isDirectExecution } from "./is-direct-execution-Cdlr-ZUl.js";
+import { createRequire } from "node:module";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { parseDocument } from "yaml";
+import { minimatch } from "minimatch";
+import semver from "semver";
+import { applyEdits, modify, parse } from "jsonc-parser";
+//#region src/update/range.ts
+const FULL_VERSION = String.raw`\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?`;
+const PARTIAL_VERSION = String.raw`\d+(?:\.\d+){0,2}`;
+function analyzeAtomicRange(specification) {
+	const value = specification.trim();
+	if (/^(?:\*|x|X)$/.test(value)) return {
+		shape: null,
+		tracking: true,
+		reason: "wildcard range tracks the selected tag"
+	};
+	if (new RegExp(`^${FULL_VERSION}$`).test(value) && semver.valid(value)) return {
+		shape: { kind: "exact" },
+		tracking: false,
+		reason: ""
+	};
+	const operator = value.match(new RegExp(`^([~^])\\s*(${FULL_VERSION}|${PARTIAL_VERSION})$`));
+	if (operator && semver.validRange(value)) return {
+		shape: {
+			kind: "operator",
+			operator: operator[1]
+		},
+		tracking: false,
+		reason: ""
+	};
+	const bounded = value.match(/^((?:>=|>)\s*\d+(?:\.\d+){0,2})\s+(?:<|<=)\s*\d+(?:\.\d+){0,2}$/);
+	if (bounded && semver.validRange(value)) return {
+		shape: {
+			kind: "bounded",
+			lower: bounded[1].replace(/\s+/g, "")
+		},
+		tracking: false,
+		reason: ""
+	};
+	const xRange = value.match(/^(\d+|[xX*])(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?$/);
+	if (xRange && semver.validRange(value)) {
+		const parts = xRange.slice(1).filter((part) => part !== void 0);
+		return {
+			shape: {
+				kind: "x",
+				parts,
+				wildcard: parts.find((part) => /^[xX*]$/.test(part)) ?? null
+			},
+			tracking: false,
+			reason: ""
+		};
+	}
+	return {
+		shape: null,
+		tracking: false,
+		reason: "unsupported complex semver range"
+	};
+}
+function analyzeRange(specification) {
+	const clauses = specification.split("||").map((clause) => clause.trim());
+	if (clauses.length === 1) return analyzeAtomicRange(specification);
+	if (clauses.some((clause) => clause.length === 0)) return {
+		shape: null,
+		tracking: false,
+		reason: "unsupported complex semver range"
+	};
+	const analyzed = clauses.map(analyzeAtomicRange);
+	if (analyzed.some((entry) => !entry.shape || entry.shape.kind === "union" || entry.tracking)) return {
+		shape: null,
+		tracking: false,
+		reason: "unsupported complex semver union"
+	};
+	const minimums = clauses.map((clause) => semver.minVersion(clause));
+	if (minimums.some((version) => version === null)) return {
+		shape: null,
+		tracking: false,
+		reason: "unsupported complex semver union"
+	};
+	let highestIndex = 0;
+	for (let index = 1; index < minimums.length; index += 1) if (semver.gt(minimums[index], minimums[highestIndex])) highestIndex = index;
+	return {
+		shape: {
+			kind: "union",
+			clauses: analyzed.map((entry) => entry.shape),
+			sourceClauses: clauses,
+			highestIndex
+		},
+		tracking: false,
+		reason: ""
+	};
+}
+function isBreakingChange(allowedVersion, targetVersion) {
+	const allowed = new semver.SemVer(allowedVersion);
+	const target = new semver.SemVer(targetVersion);
+	if (allowed.major !== target.major) return true;
+	return allowed.major === 0 && allowed.minor !== target.minor;
+}
+function nextBreakingBoundary(version) {
+	const parsed = new semver.SemVer(version);
+	return parsed.major === 0 ? `0.${parsed.minor + 1}.0` : `${parsed.major + 1}.0.0`;
+}
+function rewriteXRange(shape, target) {
+	const parsed = new semver.SemVer(target);
+	const count = shape.parts.length;
+	if (shape.wildcard) {
+		const wildcardIndex = shape.parts.findIndex((part) => /^[xX*]$/.test(part));
+		if (wildcardIndex === 0) return shape.wildcard;
+		if (wildcardIndex === 1) return `${parsed.major}.${shape.wildcard}`;
+		return `${parsed.major}.${parsed.minor}.${shape.wildcard}`;
+	}
+	if (count === 1) return String(parsed.major);
+	return `${parsed.major}.${parsed.minor}`;
+}
+function rewriteAtomic(shape, target, forcedBreaking) {
+	if (shape.kind === "exact") return target;
+	if (shape.kind === "operator") return `${shape.operator}${target}`;
+	if (shape.kind === "x") return rewriteXRange(shape, target);
+	const boundary = nextBreakingBoundary(target);
+	return forcedBreaking ? `>=${target} <${boundary}` : `${shape.lower} <${boundary}`;
+}
+function rewriteRange(shape, target, forcedBreaking) {
+	if (shape.kind !== "union") return rewriteAtomic(shape, target, forcedBreaking);
+	const highestShape = shape.clauses[shape.highestIndex];
+	if (forcedBreaking) return rewriteAtomic(highestShape, target, true);
+	const rewritten = [...shape.sourceClauses];
+	rewritten[shape.highestIndex] = rewriteAtomic(highestShape, target, false);
+	return rewritten.join(" || ");
+}
+//#endregion
+//#region src/update/npm-adapters.ts
+const require = createRequire(import.meta.url);
+const npmPackageArg = require("npm-package-arg");
+const mapDeclaredWorkspaces = require("@npmcli/map-workspaces");
+const npmRegistryFetch = require("npm-registry-fetch");
+const NpmConfig = require("@npmcli/config");
+const npmConfigDefinitions = require("@npmcli/config/lib/definitions");
+//#endregion
+//#region src/update/types.ts
+const DEPENDENCY_SECTIONS = [
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"peerDependencies"
+];
+//#endregion
+//#region src/update/discovery.ts
+async function isFile(filePath) {
+	return (await fs.stat(filePath).catch(() => null))?.isFile() ?? false;
+}
+async function readManifest(manifestPath) {
+	let source;
+	try {
+		source = await fs.readFile(manifestPath, "utf8");
+	} catch {
+		throw new Error(`Unable to read manifest: ${manifestPath}`);
+	}
+	try {
+		const value = JSON.parse(source.replace(/^\uFEFF/, ""));
+		if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
+		return value;
+	} catch {
+		throw new Error(`Malformed package manifest: ${manifestPath}`);
+	}
+}
+function packageWorkspacePatterns(manifest) {
+	if (!("workspaces" in manifest)) return null;
+	const declaration = manifest.workspaces;
+	const patterns = Array.isArray(declaration) ? declaration : declaration && typeof declaration === "object" && !Array.isArray(declaration) ? declaration.packages : null;
+	if (!Array.isArray(patterns) || patterns.some((pattern) => typeof pattern !== "string")) throw new Error("Invalid package.json workspaces declaration; expected an array of paths.");
+	return patterns;
+}
+async function pnpmWorkspacePatterns(root) {
+	const workspacePath = path.join(root, "pnpm-workspace.yaml");
+	if (!await isFile(workspacePath)) return null;
+	const document = parseDocument(await fs.readFile(workspacePath, "utf8"), { prettyErrors: false });
+	if (document.errors.length > 0) throw new Error(`Malformed pnpm workspace declaration: ${workspacePath}`);
+	const value = document.toJS();
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid pnpm workspace declaration; expected a mapping with packages.");
+	const packages = value.packages;
+	if (!Array.isArray(packages) || packages.some((pattern) => typeof pattern !== "string")) throw new Error("Invalid pnpm workspace declaration; expected packages to be an array.");
+	return packages;
+}
+async function findProjectRoot(start) {
+	const resolved = path.resolve(start);
+	if (!(await fs.stat(resolved).catch(() => null))?.isDirectory()) throw new Error(`Working directory does not exist: ${resolved}`);
+	let directory = resolved;
+	let nearestManifestDirectory = null;
+	while (true) {
+		const manifestPath = path.join(directory, "package.json");
+		const hasManifest = await isFile(manifestPath);
+		if (hasManifest) {
+			const manifest = await readManifest(manifestPath);
+			nearestManifestDirectory ??= directory;
+			if (packageWorkspacePatterns(manifest) !== null) return directory;
+		}
+		if (await isFile(path.join(directory, "pnpm-workspace.yaml"))) {
+			if (!hasManifest) throw new Error(`Workspace root is missing package.json: ${directory}`);
+			await pnpmWorkspacePatterns(directory);
+			return directory;
+		}
+		const parent = path.dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+	if (nearestManifestDirectory) return nearestManifestDirectory;
+	throw new Error(`No package.json found from ${resolved}.`);
+}
+function parsePolicy(manifest) {
+	const empty = {
+		ignore: [],
+		tags: {}
+	};
+	if (!("askr" in manifest)) return empty;
+	if (!manifest.askr || typeof manifest.askr !== "object" || Array.isArray(manifest.askr)) throw new Error("Invalid askr update configuration in the workspace root.");
+	const update = manifest.askr.update;
+	if (update === void 0) return empty;
+	if (!update || typeof update !== "object" || Array.isArray(update)) throw new Error("Invalid askr.update configuration in the workspace root.");
+	const config = update;
+	const ignore = config.ignore ?? [];
+	const tags = config.tags ?? {};
+	if (!Array.isArray(ignore) || ignore.some((entry) => typeof entry !== "string")) throw new Error("Invalid askr.update.ignore configuration; expected an array of patterns.");
+	if (!tags || typeof tags !== "object" || Array.isArray(tags) || Object.entries(tags).some(([name, tag]) => !name || typeof tag !== "string" || !tag)) throw new Error("Invalid askr.update.tags configuration; expected package-to-tag strings.");
+	return {
+		ignore,
+		tags
+	};
+}
+function relativeManifestPath(root, manifestPath) {
+	return path.relative(root, manifestPath).split(path.sep).join("/") || "package.json";
+}
+function workspaceName(manifest, fallback) {
+	return typeof manifest.name === "string" && manifest.name.trim() ? manifest.name : fallback;
+}
+async function discoverWorkspaces(root) {
+	const rootManifestPath = path.join(root, "package.json");
+	const rootManifest = await readManifest(rootManifestPath);
+	const policy = parsePolicy(rootManifest);
+	const packagePatterns = packageWorkspacePatterns(rootManifest) ?? [];
+	const pnpmPatterns = await pnpmWorkspacePatterns(root) ?? [];
+	const patterns = [...packagePatterns, ...pnpmPatterns];
+	const mapped = patterns.length > 0 ? await mapDeclaredWorkspaces({
+		cwd: root,
+		pkg: { workspaces: patterns }
+	}) : /* @__PURE__ */ new Map();
+	const rootName = workspaceName(rootManifest, "(root)");
+	if (mapped.has(rootName)) throw new Error(`Duplicate workspace name '${rootName}' includes the workspace root.`);
+	const workspaces = [{
+		name: rootName,
+		directory: root,
+		manifestPath: rootManifestPath,
+		relativeManifestPath: "package.json",
+		manifest: rootManifest,
+		isRoot: true
+	}];
+	for (const [mappedName, directory] of mapped) {
+		const manifestPath = path.join(directory, "package.json");
+		const manifest = await readManifest(manifestPath);
+		workspaces.push({
+			name: workspaceName(manifest, mappedName),
+			directory,
+			manifestPath,
+			relativeManifestPath: relativeManifestPath(root, manifestPath),
+			manifest,
+			isRoot: false
+		});
+	}
+	workspaces.sort((left, right) => {
+		if (left.isRoot !== right.isRoot) return left.isRoot ? -1 : 1;
+		return left.name.localeCompare(right.name) || left.manifestPath.localeCompare(right.manifestPath);
+	});
+	return {
+		policy,
+		rootManifest,
+		workspaces
+	};
+}
+function matchesAny(value, patterns) {
+	return patterns.some((pattern) => minimatch(value, pattern, { dot: true }));
+}
+function classifySpecification(packageName, specification, directory, localNames) {
+	if (localNames.has(packageName)) return {
+		kind: "local",
+		registryManaged: false,
+		reason: "dependency resolves to a discovered workspace"
+	};
+	if (/^workspace:/i.test(specification)) return {
+		kind: "local",
+		registryManaged: false,
+		reason: "workspace protocol is not registry-managed"
+	};
+	if (/^link:/i.test(specification)) return {
+		kind: "local",
+		registryManaged: false,
+		reason: "link protocol is not registry-managed"
+	};
+	let parsed;
+	try {
+		parsed = npmPackageArg.resolve(packageName, specification, directory);
+	} catch {
+		return {
+			kind: "manual",
+			registryManaged: false,
+			reason: "unsupported dependency specification"
+		};
+	}
+	if ([
+		"directory",
+		"file",
+		"git",
+		"remote"
+	].includes(parsed.type)) return {
+		kind: "local",
+		registryManaged: false,
+		reason: `${parsed.type} specification is not registry-managed`
+	};
+	if (parsed.type === "alias") return {
+		kind: "manual",
+		registryManaged: false,
+		reason: "npm aliases require manual review"
+	};
+	if (parsed.type === "tag") return {
+		kind: "current",
+		registryManaged: true,
+		reason: "tracking tag is not rewritten"
+	};
+	if (parsed.type !== "range" && parsed.type !== "version") return {
+		kind: "manual",
+		registryManaged: false,
+		reason: "unsupported dependency specification"
+	};
+	const analysis = analyzeRange(specification);
+	if (analysis.tracking) return {
+		kind: "current",
+		registryManaged: true,
+		reason: analysis.reason
+	};
+	if (!analysis.shape) return {
+		kind: "manual",
+		registryManaged: false,
+		reason: analysis.reason
+	};
+	return {
+		kind: "fetch",
+		registryManaged: true,
+		reason: ""
+	};
+}
+function collectOccurrences(root, workspaces, localNames, policy, packagePatterns) {
+	const occurrences = [];
+	for (const workspace of workspaces) for (const section of DEPENDENCY_SECTIONS) {
+		const dependencies = workspace.manifest[section];
+		if (dependencies === void 0) continue;
+		if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) throw new Error(`Invalid ${section} in ${workspace.relativeManifestPath}; expected an object.`);
+		for (const [packageName, specification] of Object.entries(dependencies)) {
+			if (typeof specification !== "string") throw new Error(`Invalid ${section}.${packageName} in ${workspace.relativeManifestPath}.`);
+			if (packagePatterns.length > 0 && !matchesAny(packageName, packagePatterns)) continue;
+			if (packagePatterns.length === 0 && matchesAny(packageName, policy.ignore)) continue;
+			occurrences.push({
+				package: packageName,
+				workspace: workspace.name,
+				manifestPath: workspace.manifestPath,
+				relativeManifestPath: relativeManifestPath(root, workspace.manifestPath),
+				section,
+				currentSpecification: specification,
+				...classifySpecification(packageName, specification, workspace.directory, localNames)
+			});
+		}
+	}
+	const sectionOrder = new Map(DEPENDENCY_SECTIONS.map((section, index) => [section, index]));
+	occurrences.sort((left, right) => left.package.localeCompare(right.package) || left.workspace.localeCompare(right.workspace) || left.relativeManifestPath.localeCompare(right.relativeManifestPath) || sectionOrder.get(left.section) - sectionOrder.get(right.section));
+	return occurrences;
+}
+async function discoverProject(options) {
+	const root = await findProjectRoot(options.cwd);
+	const { policy, workspaces } = await discoverWorkspaces(root);
+	const selectedWorkspaces = options.workspacePatterns.length === 0 ? workspaces : workspaces.filter((workspace) => matchesAny(workspace.name, options.workspacePatterns));
+	if (selectedWorkspaces.length === 0) throw new Error("No discovered workspace matches the requested --workspace filters.");
+	const localNames = new Set(workspaces.map((workspace) => workspace.name));
+	return {
+		root,
+		workspaces,
+		selectedWorkspaces,
+		policy,
+		occurrences: collectOccurrences(root, selectedWorkspaces, localNames, policy, options.packagePatterns),
+		contextOccurrences: collectOccurrences(root, selectedWorkspaces, localNames, {
+			ignore: [],
+			tags: policy.tags
+		}, [])
+	};
+}
+//#endregion
+//#region src/update/planner.ts
+const STATUS_PRIORITY = {
+	current: 0,
+	local: 1,
+	safe: 2,
+	breaking: 3,
+	manual: 4,
+	error: 5
+};
+function publishedVersions(packument) {
+	return Object.keys(packument.versions ?? {}).filter((version) => semver.valid(version) !== null).sort(semver.compare);
+}
+function selectedTarget(packument, tag) {
+	const value = packument["dist-tags"]?.[tag];
+	return typeof value === "string" && semver.valid(value) ? value : null;
+}
+function plannedOccurrence(occurrence, packument, failure, selectedTag, force) {
+	const base = {
+		workspace: occurrence.workspace,
+		manifestPath: occurrence.manifestPath,
+		relativeManifestPath: occurrence.relativeManifestPath,
+		section: occurrence.section,
+		currentSpecification: occurrence.currentSpecification,
+		proposedSpecification: null,
+		allowedVersion: null
+	};
+	if (occurrence.kind === "local") return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "local",
+			reason: occurrence.reason
+		}
+	};
+	if (occurrence.kind === "manual") return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "manual",
+			reason: occurrence.reason
+		}
+	};
+	if (failure) return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "error",
+			reason: failure
+		}
+	};
+	if (occurrence.kind === "current") return {
+		targetVersion: packument ? selectedTarget(packument, selectedTag) : null,
+		occurrence: {
+			...base,
+			status: "current",
+			reason: occurrence.reason
+		}
+	};
+	if (!packument) return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "error",
+			reason: "package metadata is unavailable"
+		}
+	};
+	const targetVersion = selectedTarget(packument, selectedTag);
+	if (!targetVersion) return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "error",
+			reason: `dist-tag '${selectedTag}' is not published`
+		}
+	};
+	const versions = publishedVersions(packument);
+	if (!versions.includes(targetVersion)) return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "error",
+			reason: `dist-tag '${selectedTag}' does not identify a published version`
+		}
+	};
+	const allowedVersion = semver.maxSatisfying(versions, occurrence.currentSpecification);
+	if (!allowedVersion) return {
+		targetVersion,
+		occurrence: {
+			...base,
+			status: "manual",
+			reason: "no published version satisfies the current specification"
+		}
+	};
+	if (semver.satisfies(targetVersion, occurrence.currentSpecification) || !semver.gt(targetVersion, allowedVersion)) return {
+		targetVersion,
+		occurrence: {
+			...base,
+			allowedVersion,
+			status: "current",
+			reason: "selected target is already covered by the current specification"
+		}
+	};
+	const analysis = analyzeRange(occurrence.currentSpecification);
+	if (!analysis.shape) return {
+		targetVersion,
+		occurrence: {
+			...base,
+			allowedVersion,
+			status: "manual",
+			reason: analysis.reason
+		}
+	};
+	const breaking = isBreakingChange(allowedVersion, targetVersion);
+	const eligible = !breaking || force;
+	return {
+		targetVersion,
+		occurrence: {
+			...base,
+			allowedVersion,
+			proposedSpecification: eligible ? rewriteRange(analysis.shape, targetVersion, breaking) : null,
+			status: breaking ? "breaking" : "safe",
+			reason: breaking ? eligible ? "breaking update included by --force" : "breaking update requires --upgrade --force" : "compatible update is available"
+		}
+	};
+}
+function occurrenceKey(occurrence, packageName) {
+	return [
+		occurrence.manifestPath,
+		occurrence.section,
+		packageName ?? occurrence.package,
+		occurrence.currentSpecification
+	].join("\0");
+}
+function resolveSpecificationVersion(specification, packument) {
+	const versions = publishedVersions(packument);
+	let parsed;
+	try {
+		parsed = npmPackageArg.resolve("placeholder", specification);
+	} catch {
+		return null;
+	}
+	if (parsed.type === "tag") {
+		const tagged = packument["dist-tags"]?.[parsed.rawSpec];
+		return typeof tagged === "string" && semver.valid(tagged) ? tagged : null;
+	}
+	if (parsed.type === "version") return semver.valid(parsed.rawSpec);
+	if (parsed.type === "range") return semver.maxSatisfying(versions, parsed.rawSpec);
+	return null;
+}
+function versionMetadata(packument, version) {
+	const metadata = packument.versions?.[version];
+	return metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : null;
+}
+function applyPeerCompatibilityGuard(decisions, contextOccurrences, packuments) {
+	const plannedByKey = /* @__PURE__ */ new Map();
+	for (const decision of decisions) for (const occurrence of decision.occurrences) plannedByKey.set(occurrenceKey(occurrence, decision.package), occurrence);
+	const contextByWorkspace = /* @__PURE__ */ new Map();
+	for (const occurrence of contextOccurrences) {
+		const entries = contextByWorkspace.get(occurrence.workspace) ?? [];
+		entries.push(occurrence);
+		contextByWorkspace.set(occurrence.workspace, entries);
+	}
+	for (const [workspace, context] of contextByWorkspace) {
+		const states = context.flatMap((dependency) => {
+			if (!dependency.registryManaged) return [];
+			const packument = packuments.get(dependency.package);
+			if (!packument) return [];
+			const planned = plannedByKey.get(occurrenceKey(dependency));
+			const currentVersion = resolveSpecificationVersion(dependency.currentSpecification, packument);
+			const futureVersion = resolveSpecificationVersion(planned?.proposedSpecification ?? dependency.currentSpecification, packument);
+			return currentVersion && futureVersion ? [{
+				dependency,
+				packument,
+				planned,
+				currentVersion,
+				futureVersion,
+				changed: Boolean(planned?.proposedSpecification)
+			}] : [];
+		});
+		const blockers = /* @__PURE__ */ new Map();
+		for (const provider of states) {
+			const currentPeers = versionMetadata(provider.packument, provider.currentVersion)?.peerDependencies ?? {};
+			const futurePeers = versionMetadata(provider.packument, provider.futureVersion)?.peerDependencies ?? {};
+			const peerNames = /* @__PURE__ */ new Set([...Object.keys(currentPeers), ...Object.keys(futurePeers)]);
+			for (const peerName of peerNames) {
+				const currentRequirement = currentPeers[peerName];
+				const futureRequirement = futurePeers[peerName];
+				if (futureRequirement !== void 0 && typeof futureRequirement !== "string") continue;
+				for (const peer of states.filter((state) => state.dependency.package === peerName)) {
+					const currentAccepted = typeof currentRequirement !== "string" || semver.satisfies(peer.currentVersion, currentRequirement);
+					const futureAccepted = typeof futureRequirement !== "string" || semver.satisfies(peer.futureVersion, futureRequirement);
+					if (!currentAccepted || futureAccepted) continue;
+					const reason = `${provider.dependency.package}@${provider.futureVersion} requires ${peerName}@${futureRequirement}`;
+					if (provider.changed && provider.planned) blockers.set(provider.planned, reason);
+					if (peer.changed && peer.planned) blockers.set(peer.planned, reason);
+				}
+			}
+		}
+		for (const [planned, reason] of blockers) {
+			planned.status = "manual";
+			planned.proposedSpecification = null;
+			planned.reason = reason;
+		}
+	}
+}
+function aggregateStatus(occurrences) {
+	return occurrences.reduce((status, occurrence) => STATUS_PRIORITY[occurrence.status] > STATUS_PRIORITY[status] ? occurrence.status : status, "current");
+}
+function summarize(decisions) {
+	const summary = {
+		packages: decisions.length,
+		occurrences: 0,
+		changedOccurrences: 0,
+		current: 0,
+		safe: 0,
+		breaking: 0,
+		local: 0,
+		manual: 0,
+		error: 0
+	};
+	for (const decision of decisions) {
+		decision.status = aggregateStatus(decision.occurrences);
+		decision.reason = decision.occurrences.find((entry) => entry.status === decision.status)?.reason ?? "";
+		summary[decision.status] += 1;
+		summary.occurrences += decision.occurrences.length;
+		summary.changedOccurrences += decision.occurrences.filter((entry) => entry.proposedSpecification).length;
+	}
+	return summary;
+}
+function planUpdates(options) {
+	const failures = options.failures ?? /* @__PURE__ */ new Map();
+	const tags = options.tags ?? {};
+	const grouped = /* @__PURE__ */ new Map();
+	for (const occurrence of options.occurrences) {
+		const entries = grouped.get(occurrence.package) ?? [];
+		entries.push(occurrence);
+		grouped.set(occurrence.package, entries);
+	}
+	const decisions = [...grouped.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([packageName, occurrences]) => {
+		const selectedTag = options.cliTag ?? tags[packageName] ?? "latest";
+		const planned = occurrences.map((occurrence) => plannedOccurrence(occurrence, options.packuments.get(packageName), failures.get(packageName), selectedTag, options.force ?? false));
+		const targetVersion = planned.find((entry) => entry.targetVersion)?.targetVersion ?? null;
+		const plannedOccurrences = planned.map((entry) => entry.occurrence);
+		const status = aggregateStatus(plannedOccurrences);
+		return {
+			package: packageName,
+			selectedTag,
+			targetVersion,
+			status,
+			reason: plannedOccurrences.find((entry) => entry.status === status)?.reason ?? "",
+			occurrences: plannedOccurrences
+		};
+	});
+	const selectedNames = new Set(grouped.keys());
+	for (const [packageName, failure] of [...failures].sort(([left], [right]) => left.localeCompare(right))) {
+		if (selectedNames.has(packageName)) continue;
+		const context = (options.contextOccurrences ?? []).filter((occurrence) => occurrence.package === packageName).map((occurrence) => ({
+			workspace: occurrence.workspace,
+			manifestPath: occurrence.manifestPath,
+			relativeManifestPath: occurrence.relativeManifestPath,
+			section: occurrence.section,
+			currentSpecification: occurrence.currentSpecification,
+			proposedSpecification: null,
+			allowedVersion: null,
+			status: "error",
+			reason: `peer compatibility lookup failed: ${failure}`
+		}));
+		decisions.push({
+			package: packageName,
+			selectedTag: options.cliTag ?? tags[packageName] ?? "latest",
+			targetVersion: null,
+			status: "error",
+			reason: `peer compatibility lookup failed: ${failure}`,
+			occurrences: context
+		});
+	}
+	decisions.sort((left, right) => left.package.localeCompare(right.package));
+	applyPeerCompatibilityGuard(decisions, options.contextOccurrences ?? options.occurrences, options.packuments);
+	const summary = summarize(decisions);
+	return {
+		decisions,
+		summary,
+		hasErrors: summary.error > 0
+	};
+}
+//#endregion
+//#region src/update/registry.ts
+const ABBREVIATED_PACKUMENT = "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*";
+function npmPathFromExecutable(executable) {
+	let directory = path.dirname(path.resolve(executable));
+	for (let depth = 0; depth < 5; depth += 1) {
+		const manifestPath = path.join(directory, "package.json");
+		if (existsSync(manifestPath)) try {
+			if (createRequire(import.meta.url)(manifestPath).name === "npm") return directory;
+		} catch {}
+		const parent = path.dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+	return null;
+}
+function resolveNpmPath(env) {
+	if (env.npm_execpath) {
+		const fromEnvironment = npmPathFromExecutable(env.npm_execpath);
+		if (fromEnvironment) return fromEnvironment;
+	}
+	const executableDirectory = path.dirname(process.execPath);
+	const installed = (process.platform === "win32" ? [path.join(executableDirectory, "node_modules", "npm")] : [path.resolve(executableDirectory, "..", "lib", "node_modules", "npm")]).find((candidate) => existsSync(path.join(candidate, "package.json")));
+	if (installed) return installed;
+	return path.dirname(createRequire(import.meta.url).resolve("@npmcli/config/package.json"));
+}
+async function loadNpmConfiguration(root, env = process.env) {
+	try {
+		const config = new NpmConfig({
+			argv: [],
+			cwd: root,
+			definitions: npmConfigDefinitions.definitions,
+			env,
+			flatten: npmConfigDefinitions.flatten,
+			npmPath: resolveNpmPath(env),
+			shorthands: npmConfigDefinitions.shorthands
+		});
+		await config.load();
+		if (!config.validate()) throw new Error("Invalid npm configuration");
+		return { ...config.flat };
+	} catch {
+		throw new Error("Unable to load or validate npm configuration.");
+	}
+}
+function sanitizeRegistryError(error) {
+	const value = error && typeof error === "object" ? error : {};
+	if (value.statusCode === 404) return "package was not found in the selected registry";
+	if (value.statusCode === 401 || value.statusCode === 403) return "registry authentication or authorization failed";
+	const code = typeof value.code === "string" ? value.code.toUpperCase() : "";
+	if ([
+		"ETIMEDOUT",
+		"ETIMEOUT",
+		"FETCH_ERROR",
+		"ECONNRESET"
+	].includes(code)) return "registry request timed out or was interrupted";
+	if (/^[A-Z][A-Z0-9_]{1,30}$/.test(code)) return `registry request failed (${code})`;
+	return "registry request failed";
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isPackument(value) {
+	return isRecord(value) && isRecord(value["dist-tags"]) && isRecord(value.versions);
+}
+async function fetchPackuments(packageNames, configuration, fetchJson = npmRegistryFetch.json.bind(npmRegistryFetch)) {
+	const names = [...new Set(packageNames)].sort((left, right) => left.localeCompare(right));
+	const packuments = /* @__PURE__ */ new Map();
+	const failures = /* @__PURE__ */ new Map();
+	let nextIndex = 0;
+	const worker = async () => {
+		while (nextIndex < names.length) {
+			const packageName = names[nextIndex];
+			nextIndex += 1;
+			const spec = npmPackageArg(packageName);
+			try {
+				const result = await fetchJson(`/${spec.escapedName}`, {
+					...configuration,
+					headers: {
+						...configuration.headers,
+						accept: ABBREVIATED_PACKUMENT
+					},
+					offline: false,
+					preferOffline: false,
+					preferOnline: true,
+					spec
+				});
+				if (!isPackument(result)) failures.set(packageName, "registry returned malformed package metadata");
+				else packuments.set(packageName, result);
+			} catch (error) {
+				failures.set(packageName, sanitizeRegistryError(error));
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(8, names.length) }, worker));
+	return {
+		packuments,
+		failures
+	};
+}
+//#endregion
+//#region src/update/writer.ts
+function groupEdits(edits) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const edit of edits) {
+		const entries = grouped.get(edit.manifestPath) ?? [];
+		entries.push(edit);
+		grouped.set(edit.manifestPath, entries);
+	}
+	for (const entries of grouped.values()) entries.sort((left, right) => left.section.localeCompare(right.section) || left.package.localeCompare(right.package));
+	return new Map([...grouped].sort(([left], [right]) => left.localeCompare(right)));
+}
+function renderReplacement(source, edits) {
+	const errors = [];
+	const manifest = parse(source, errors, { allowTrailingComma: true });
+	if (errors.length > 0 || !manifest || typeof manifest !== "object" || Array.isArray(manifest)) throw new Error("Manifest changed to invalid JSON before writing.");
+	let result = source;
+	for (const edit of edits) {
+		const dependencies = manifest[edit.section];
+		if ((dependencies && typeof dependencies === "object" && !Array.isArray(dependencies) ? dependencies[edit.package] : void 0) !== edit.currentSpecification) throw new Error(`Manifest changed before writing: ${edit.manifestPath}`);
+		result = applyEdits(result, modify(result, [edit.section, edit.package], edit.proposedSpecification, {}));
+	}
+	return result;
+}
+async function cleanup(paths) {
+	await Promise.all(paths.map((filePath) => fs.rm(filePath, { force: true }).catch(() => void 0)));
+}
+async function rollback(replaced) {
+	let complete = true;
+	for (const staged of [...replaced].reverse()) {
+		const rollbackPath = path.join(path.dirname(staged.manifestPath), `.${path.basename(staged.manifestPath)}.askr-rollback-${randomUUID()}`);
+		try {
+			await fs.writeFile(rollbackPath, staged.original, {
+				flag: "wx",
+				mode: staged.mode
+			});
+			await fs.rename(rollbackPath, staged.manifestPath);
+		} catch {
+			complete = false;
+			await fs.rm(rollbackPath, { force: true }).catch(() => void 0);
+		}
+	}
+	return complete;
+}
+async function writeManifestEdits(edits, options = {}) {
+	if (edits.length === 0) return 0;
+	const staged = [];
+	const replace = options.replace ?? fs.rename;
+	try {
+		for (const [manifestPath, manifestEdits] of groupEdits(edits)) {
+			const [original, stat] = await Promise.all([fs.readFile(manifestPath), fs.stat(manifestPath)]);
+			const replacement = renderReplacement(original.toString("utf8"), manifestEdits);
+			const temporaryPath = path.join(path.dirname(manifestPath), `.${path.basename(manifestPath)}.askr-update-${randomUUID()}`);
+			await fs.writeFile(temporaryPath, replacement, {
+				flag: "wx",
+				mode: stat.mode
+			});
+			staged.push({
+				manifestPath,
+				original,
+				replacement,
+				temporaryPath,
+				mode: stat.mode
+			});
+		}
+	} catch (error) {
+		await cleanup(staged.map((entry) => entry.temporaryPath));
+		throw error;
+	}
+	const replaced = [];
+	try {
+		for (const manifest of staged) {
+			await replace(manifest.temporaryPath, manifest.manifestPath);
+			replaced.push(manifest);
+		}
+	} catch {
+		const rollbackComplete = await rollback(replaced);
+		await cleanup(staged.map((entry) => entry.temporaryPath));
+		throw new Error(rollbackComplete ? "Manifest replacement failed; completed replacements were rolled back." : "Manifest replacement failed and rollback was incomplete.");
+	}
+	return edits.length;
+}
+//#endregion
+//#region src/bin/update.ts
+function helpText() {
+	return [
+		"askr update - Plan or apply dependency manifest updates",
+		"",
+		"Usage:",
+		"  askr update [packages...] [options]",
+		"",
+		"Options:",
+		"  -u, --upgrade           Apply compatible package.json edits",
+		"  -f, --force             Include breaking updates (requires --upgrade)",
+		"  --cwd <dir>             Resolve a project from another directory",
+		"  --workspace <glob>      Select workspace names (repeatable)",
+		"  --tag <tag>             Use one registry dist-tag for selected packages",
+		"  --json                  Emit one deterministic JSON object on stdout",
+		"  --help, -h              Show this help message",
+		"",
+		"Notes:",
+		"  Package arguments are minimatch patterns and override persistent ignores.",
+		"  The command is dry-run by default and changes package.json files only.",
+		"  Lockfiles, installs, and lifecycle scripts are never touched."
+	].join("\n");
+}
+function optionValue(args, index, option, errors) {
+	if (index + 1 >= args.length || args[index + 1].startsWith("-")) {
+		errors.push(`Missing value for ${option}`);
+		return null;
+	}
+	return args[index + 1];
+}
+function parseArgs(args) {
+	const parsed = {
+		cwd: process.cwd(),
+		force: false,
+		help: false,
+		json: false,
+		packagePatterns: [],
+		upgrade: false,
+		workspacePatterns: [],
+		errors: []
+	};
+	let positionalOnly = false;
+	for (let index = 0; index < args.length; index += 1) {
+		const argument = args[index];
+		if (positionalOnly) parsed.packagePatterns.push(argument);
+		else if (argument === "--") positionalOnly = true;
+		else if (argument === "--help" || argument === "-h") parsed.help = true;
+		else if (argument === "--upgrade" || argument === "-u") parsed.upgrade = true;
+		else if (argument === "--force" || argument === "-f") parsed.force = true;
+		else if (argument === "--json") parsed.json = true;
+		else if (argument === "--cwd") {
+			const value = optionValue(args, index, "--cwd", parsed.errors);
+			if (value !== null) {
+				parsed.cwd = path.resolve(value);
+				index += 1;
+			}
+		} else if (argument.startsWith("--cwd=")) parsed.cwd = path.resolve(argument.slice(6));
+		else if (argument === "--workspace") {
+			const value = optionValue(args, index, "--workspace", parsed.errors);
+			if (value !== null) {
+				parsed.workspacePatterns.push(value);
+				index += 1;
+			}
+		} else if (argument.startsWith("--workspace=")) parsed.workspacePatterns.push(argument.slice(12));
+		else if (argument === "--tag") {
+			const value = optionValue(args, index, "--tag", parsed.errors);
+			if (value !== null) {
+				parsed.tag = value;
+				index += 1;
+			}
+		} else if (argument.startsWith("--tag=")) parsed.tag = argument.slice(6);
+		else if (argument.startsWith("-")) parsed.errors.push(`Unknown option: ${argument}`);
+		else parsed.packagePatterns.push(argument);
+	}
+	if (parsed.force && !parsed.upgrade) parsed.errors.push("--force requires --upgrade");
+	if (parsed.tag !== void 0 && (!parsed.tag || /\s/.test(parsed.tag))) parsed.errors.push("--tag must be a non-empty dist-tag without whitespace");
+	if (parsed.workspacePatterns.some((pattern) => !pattern)) parsed.errors.push("--workspace patterns must not be empty");
+	if (parsed.packagePatterns.some((pattern) => !pattern)) parsed.errors.push("Package patterns must not be empty");
+	return parsed;
+}
+function emptySummary() {
+	return {
+		packages: 0,
+		occurrences: 0,
+		changedOccurrences: 0,
+		current: 0,
+		safe: 0,
+		breaking: 0,
+		local: 0,
+		manual: 0,
+		error: 0
+	};
+}
+function serializableDecision(decision) {
+	return {
+		package: decision.package,
+		selectedTag: decision.selectedTag,
+		targetVersion: decision.targetVersion,
+		status: decision.status,
+		reason: decision.reason,
+		occurrences: decision.occurrences.map((occurrence) => ({
+			workspace: occurrence.workspace,
+			manifest: occurrence.relativeManifestPath,
+			section: occurrence.section,
+			currentSpecification: occurrence.currentSpecification,
+			proposedSpecification: occurrence.proposedSpecification,
+			allowedVersion: occurrence.allowedVersion,
+			status: occurrence.status,
+			reason: occurrence.reason
+		}))
+	};
+}
+function selectedWorkspaceJson(root, workspaces) {
+	return workspaces.map((workspace) => ({
+		name: workspace.name,
+		path: path.relative(root, workspace.directory).split(path.sep).join("/") || ".",
+		manifest: workspace.relativeManifestPath
+	}));
+}
+function emitJson(io, options) {
+	io.log(JSON.stringify({
+		root: options.root,
+		workspaces: options.workspaces,
+		summary: options.summary,
+		decisions: options.decisions.map(serializableDecision),
+		applied: { occurrences: options.applied },
+		errors: options.errors
+	}, null, 2));
+}
+function rangeText(occurrence) {
+	if (occurrence.proposedSpecification) return `${occurrence.currentSpecification} → ${occurrence.proposedSpecification}`;
+	if (occurrence.status === "breaking") return `${occurrence.currentSpecification} (skipped; use -u -f)`;
+	return `${occurrence.currentSpecification} (${occurrence.reason})`;
+}
+function renderTable(rows) {
+	const headings = [
+		"Package",
+		"Allowed",
+		"Latest",
+		"Status",
+		"Range"
+	];
+	const widths = headings.map((heading, column) => Math.max(heading.length, ...rows.map((row) => row[column].length)));
+	return [headings, ...rows].map((row) => row.map((value, column) => column === row.length - 1 ? value : value.padEnd(widths[column])).join("  "));
+}
+function emitHuman(io, decisions, summary, applied, upgrade) {
+	const byWorkspace = /* @__PURE__ */ new Map();
+	for (const decision of decisions) for (const occurrence of decision.occurrences) {
+		if (occurrence.status === "current") continue;
+		const rows = byWorkspace.get(occurrence.workspace) ?? [];
+		rows.push([
+			decision.package,
+			occurrence.allowedVersion ?? "-",
+			decision.targetVersion ?? "-",
+			occurrence.status,
+			rangeText(occurrence)
+		]);
+		byWorkspace.set(occurrence.workspace, rows);
+	}
+	if (byWorkspace.size === 0) io.log("All selected dependencies are current.");
+	else {
+		let first = true;
+		for (const [workspace, rows] of byWorkspace) {
+			if (!first) io.log("");
+			first = false;
+			io.log(workspace);
+			for (const line of renderTable(rows)) io.log(line);
+		}
+	}
+	const counts = [
+		"safe",
+		"breaking",
+		"current",
+		"manual",
+		"local",
+		"error"
+	].filter((status) => summary[status] > 0).map((status) => `${summary[status]} ${status}`).join(", ");
+	io.log("");
+	io.log(`Scanned ${summary.packages} package${summary.packages === 1 ? "" : "s"}${counts ? `: ${counts}` : "."}`);
+	if (upgrade) io.log(`Updated ${applied} manifest occurrence${applied === 1 ? "" : "s"}.`);
+	else if (summary.changedOccurrences > 0) io.log(`Dry run: ${summary.changedOccurrences} manifest occurrence${summary.changedOccurrences === 1 ? "" : "s"} can be updated; rerun with -u to apply.`);
+}
+function collectEdits(decisions) {
+	return decisions.flatMap((decision) => decision.occurrences.flatMap((occurrence) => occurrence.proposedSpecification ? [{
+		manifestPath: occurrence.manifestPath,
+		section: occurrence.section,
+		package: decision.package,
+		currentSpecification: occurrence.currentSpecification,
+		proposedSpecification: occurrence.proposedSpecification
+	}] : []));
+}
+async function defaultRegistry(root, packageNames) {
+	return fetchPackuments(packageNames, await loadNpmConfiguration(root));
+}
+async function runUpdateCli(args, io = console, runtime = {}) {
+	const parsed = parseArgs(args);
+	if (parsed.help && parsed.errors.length === 0) {
+		io.log(helpText());
+		return 0;
+	}
+	if (parsed.errors.length > 0) {
+		for (const error of parsed.errors) io.error(`askr update: ${error}`);
+		if (parsed.json) emitJson(io, {
+			root: null,
+			workspaces: [],
+			summary: emptySummary(),
+			decisions: [],
+			applied: 0,
+			errors: parsed.errors
+		});
+		return 1;
+	}
+	let root = null;
+	let selectedWorkspaces = [];
+	try {
+		const project = await discoverProject({
+			cwd: parsed.cwd,
+			packagePatterns: parsed.packagePatterns,
+			workspacePatterns: parsed.workspacePatterns
+		});
+		root = project.root;
+		selectedWorkspaces = project.selectedWorkspaces;
+		const lookupNames = project.occurrences.some((occurrence) => occurrence.kind === "fetch") ? project.contextOccurrences.filter((occurrence) => occurrence.registryManaged).map((occurrence) => occurrence.package) : [];
+		const registry = runtime.registry ?? defaultRegistry;
+		const results = lookupNames.length > 0 ? await registry(project.root, lookupNames) : {
+			packuments: /* @__PURE__ */ new Map(),
+			failures: /* @__PURE__ */ new Map()
+		};
+		const plan = planUpdates({
+			occurrences: project.occurrences,
+			contextOccurrences: project.contextOccurrences,
+			packuments: results.packuments,
+			failures: results.failures,
+			tags: project.policy.tags,
+			cliTag: parsed.tag,
+			force: parsed.force
+		});
+		let applied = 0;
+		const errors = [];
+		if (!plan.hasErrors && parsed.upgrade) try {
+			applied = await (runtime.writer ?? writeManifestEdits)(collectEdits(plan.decisions));
+		} catch {
+			errors.push("Unable to replace package manifests; completed replacements were rolled back when possible.");
+		}
+		if (plan.hasErrors) errors.push("One or more registry lookups or package plans failed.");
+		if (parsed.json) emitJson(io, {
+			root: project.root,
+			workspaces: selectedWorkspaceJson(project.root, project.selectedWorkspaces),
+			summary: plan.summary,
+			decisions: plan.decisions,
+			applied,
+			errors
+		});
+		else emitHuman(io, plan.decisions, plan.summary, applied, parsed.upgrade);
+		for (const error of errors) io.error(`askr update: ${error}`);
+		return errors.length > 0 ? 1 : 0;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Update failed.";
+		io.error(`askr update: ${message}`);
+		if (parsed.json) emitJson(io, {
+			root,
+			workspaces: root ? selectedWorkspaceJson(root, selectedWorkspaces) : [],
+			summary: emptySummary(),
+			decisions: [],
+			applied: 0,
+			errors: [message]
+		});
+		return 1;
+	}
+}
+async function main() {
+	process.exit(await runUpdateCli(process.argv.slice(2)));
+}
+if (isDirectExecution(import.meta.url)) main();
+//#endregion
+export { runUpdateCli as t };
+
+//# sourceMappingURL=update-DyW1na5V.js.map