foresthouse 1.0.0-dev.16 → 1.0.0-dev.18

package/dist/{react-GNHqx2A-.mjs → react-B2on-FAy.mjs}

@@ -1,10 +1,579 @@
 import { builtinModules } from "node:module";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import ts from "typescript";
-import fs from "node:fs";
 import { ResolverFactory } from "oxc-resolver";
 import { parseSync, visitorKeys } from "oxc-parser";
 import process$1 from "node:process";
+//#region src/utils/to-display-path.ts
+function toDisplayPath(filePath, cwd) {
+	const relativePath = path.relative(cwd, filePath);
+	if (relativePath === "") return ".";
+	const normalizedPath = relativePath.split(path.sep).join("/");
+	return normalizedPath.startsWith("..") ? filePath : normalizedPath;
+}
+//#endregion
+//#region src/analyzers/base.ts
+var BaseAnalyzer = class {
+	constructor(entryFile, options) {
+		this.entryFile = entryFile;
+		this.options = options;
+	}
+	analyze() {
+		return this.doAnalyze();
+	}
+};
+//#endregion
+//#region src/analyzers/deps/index.ts
+const PNPM_WORKSPACE_FILE$1 = "pnpm-workspace.yaml";
+function analyzePackageDependencies(directory) {
+	return new PackageDependencyAnalyzer(directory).analyze();
+}
+var PackageDependencyAnalyzer = class extends BaseAnalyzer {
+	inputPath;
+	constructor(directory) {
+		super(directory, {});
+		this.inputPath = path.resolve(process.cwd(), directory);
+	}
+	doAnalyze() {
+		const rootPackageDir = findNearestPackageDirectory(resolveInputDirectory(this.inputPath));
+		const workspaceRootDir = findWorkspaceRoot(rootPackageDir) ?? rootPackageDir;
+		const workspacePackages = discoverWorkspacePackages(workspaceRootDir);
+		const nodes = /* @__PURE__ */ new Map();
+		visitPackage(rootPackageDir, workspaceRootDir, workspacePackages, nodes);
+		return {
+			repositoryRoot: workspaceRootDir,
+			rootId: rootPackageDir,
+			nodes
+		};
+	}
+};
+function visitPackage(packageDir, repositoryRoot, workspacePackages, nodes) {
+	if (nodes.has(packageDir)) return;
+	const manifest = readPackageManifest(packageDir);
+	const packageName = resolvePackageName(manifest, packageDir);
+	const dependencies = packageDir === repositoryRoot && workspacePackages.size > 0 ? collectRepositoryRootDependencies(manifest, workspacePackages, repositoryRoot) : collectManifestDependencies(manifest, workspacePackages, repositoryRoot);
+	nodes.set(packageDir, {
+		packageDir,
+		packageName,
+		dependencies
+	});
+	dependencies.forEach((dependency) => {
+		if (dependency.kind === "workspace") visitPackage(dependency.target, repositoryRoot, workspacePackages, nodes);
+	});
+}
+function resolveInputDirectory(resolvedPath) {
+	const stats = fs.existsSync(resolvedPath) ? fs.statSync(resolvedPath) : null;
+	if (stats === null) throw new Error(`Directory does not exist: ${resolvedPath}`);
+	if (stats.isDirectory()) return resolvedPath;
+	if (stats.isFile() && path.basename(resolvedPath) === "package.json") return path.dirname(resolvedPath);
+	throw new Error(`Expected a package directory: ${resolvedPath}`);
+}
+function findNearestPackageDirectory(startDirectory) {
+	let currentDirectory = startDirectory;
+	while (true) {
+		const packageJsonPath = path.join(currentDirectory, "package.json");
+		if (fs.existsSync(packageJsonPath)) return currentDirectory;
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
+	}
+	throw new Error(`No package.json found from ${startDirectory}`);
+}
+function findWorkspaceRoot(packageDir) {
+	let currentDirectory = packageDir;
+	while (true) {
+		const packageJsonPath = path.join(currentDirectory, "package.json");
+		if (fs.existsSync(packageJsonPath)) {
+			const manifest = readPackageManifest(currentDirectory);
+			const workspacePatterns = resolveWorkspacePatterns(currentDirectory, manifest);
+			if (workspacePatterns.length > 0 && currentDirectory === packageDir) return currentDirectory;
+			if (workspacePatterns.length > 0 && isWorkspaceMatch(currentDirectory, workspacePatterns, packageDir)) return currentDirectory;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) return;
+		currentDirectory = parentDirectory;
+	}
+}
+function discoverWorkspacePackages(repositoryRoot) {
+	const workspacePatterns = resolveWorkspacePatterns(repositoryRoot, readPackageManifest(repositoryRoot));
+	if (workspacePatterns.length === 0) return /* @__PURE__ */ new Map();
+	const workspacePackageDirs = /* @__PURE__ */ new Set();
+	workspacePatterns.forEach((pattern) => {
+		expandWorkspacePattern(repositoryRoot, pattern).forEach((packageDir) => {
+			workspacePackageDirs.add(packageDir);
+		});
+	});
+	const workspacePackages = /* @__PURE__ */ new Map();
+	Array.from(workspacePackageDirs).sort((left, right) => left.localeCompare(right)).forEach((packageDir) => {
+		const workspaceName = resolvePackageName(readPackageManifest(packageDir), packageDir);
+		if (workspacePackages.has(workspaceName)) throw new Error(`Duplicate workspace package name: ${workspaceName}`);
+		workspacePackages.set(workspaceName, {
+			name: workspaceName,
+			packageDir,
+			label: toDisplayPath(packageDir, repositoryRoot)
+		});
+	});
+	return workspacePackages;
+}
+function collectManifestDependencies(manifest, workspacePackages, repositoryRoot) {
+	const dependencyEntries = Object.entries(manifest.dependencies ?? {});
+	const workspaceDependencies = [];
+	const externalDependencies = [];
+	dependencyEntries.forEach(([dependencyName, specifier]) => {
+		const workspacePackage = workspacePackages.get(dependencyName);
+		if (workspacePackage !== void 0) {
+			workspaceDependencies.push({
+				kind: "workspace",
+				name: dependencyName,
+				specifier,
+				target: workspacePackage.packageDir
+			});
+			return;
+		}
+		externalDependencies.push({
+			kind: "external",
+			name: dependencyName,
+			specifier
+		});
+	});
+	workspaceDependencies.sort((left, right) => {
+		const leftLabel = toDisplayPath(left.target, repositoryRoot);
+		const rightLabel = toDisplayPath(right.target, repositoryRoot);
+		return leftLabel.localeCompare(rightLabel);
+	});
+	externalDependencies.sort((left, right) => left.name.localeCompare(right.name));
+	return [...workspaceDependencies, ...externalDependencies];
+}
+function collectRepositoryRootDependencies(manifest, workspacePackages, _repositoryRoot) {
+	const topLevelWorkspaceDependencies = Array.from(workspacePackages.values()).sort((left, right) => left.label.localeCompare(right.label)).map((workspacePackage) => ({
+		kind: "workspace",
+		name: workspacePackage.name,
+		target: workspacePackage.packageDir
+	}));
+	const externalDependencies = Object.entries(manifest.dependencies ?? {}).filter(([dependencyName]) => !workspacePackages.has(dependencyName)).map(([dependencyName, specifier]) => ({
+		kind: "external",
+		name: dependencyName,
+		specifier
+	})).sort((left, right) => left.name.localeCompare(right.name));
+	return [...topLevelWorkspaceDependencies, ...externalDependencies];
+}
+function readPackageManifest(packageDir) {
+	const packageJsonPath = path.join(packageDir, "package.json");
+	if (!fs.existsSync(packageJsonPath)) throw new Error(`Missing package.json in ${packageDir}`);
+	const manifestText = fs.readFileSync(packageJsonPath, "utf8");
+	try {
+		const parsed = JSON.parse(manifestText);
+		if (!isRecord(parsed)) throw new Error("package.json must contain an object");
+		return parsed;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown JSON parse error";
+		throw new Error(`Failed to read ${packageJsonPath}: ${message}`);
+	}
+}
+function resolvePackageName(manifest, packageDir) {
+	if (typeof manifest.name === "string" && manifest.name.trim().length > 0) return manifest.name;
+	throw new Error(`Package at ${packageDir} is missing a valid name`);
+}
+function getWorkspacePatterns(manifest) {
+	if (Array.isArray(manifest.workspaces)) return manifest.workspaces.filter((pattern) => typeof pattern === "string" && pattern.length > 0);
+	if (isRecord(manifest.workspaces) && Array.isArray(manifest.workspaces.packages)) return manifest.workspaces.packages.filter((pattern) => typeof pattern === "string" && pattern.length > 0);
+	return [];
+}
+function resolveWorkspacePatterns(repositoryRoot, manifest) {
+	const manifestPatterns = getWorkspacePatterns(manifest);
+	if (manifestPatterns.length > 0) return manifestPatterns;
+	return readPnpmWorkspacePatterns(repositoryRoot);
+}
+function readPnpmWorkspacePatterns(repositoryRoot) {
+	const pnpmWorkspacePath = path.join(repositoryRoot, PNPM_WORKSPACE_FILE$1);
+	if (!fs.existsSync(pnpmWorkspacePath)) return [];
+	const lines = fs.readFileSync(pnpmWorkspacePath, "utf8").split(/\r?\n/);
+	const patterns = [];
+	let inPackagesBlock = false;
+	for (const line of lines) {
+		const trimmedLine = line.trim();
+		if (trimmedLine.length === 0 || trimmedLine.startsWith("#")) continue;
+		if (!inPackagesBlock) {
+			if (trimmedLine === "packages:") inPackagesBlock = true;
+			continue;
+		}
+		if (!line.startsWith(" ") && !line.startsWith("	")) break;
+		if (!trimmedLine.startsWith("- ")) continue;
+		const pattern = unquoteWorkspacePattern(trimmedLine.slice(2).trim());
+		if (pattern.length > 0) patterns.push(pattern);
+	}
+	return patterns;
+}
+function unquoteWorkspacePattern(pattern) {
+	if (pattern.startsWith("\"") && pattern.endsWith("\"") || pattern.startsWith("'") && pattern.endsWith("'")) return pattern.slice(1, -1);
+	return pattern;
+}
+function isWorkspaceMatch(repositoryRoot, patterns, packageDir) {
+	return patterns.some((pattern) => expandWorkspacePattern(repositoryRoot, pattern).includes(packageDir));
+}
+function expandWorkspacePattern(repositoryRoot, pattern) {
+	return matchWorkspaceSegments(repositoryRoot, normalizeWorkspacePattern(pattern), 0).filter((packageDir) => fs.existsSync(path.join(packageDir, "package.json")));
+}
+function normalizeWorkspacePattern(pattern) {
+	return pattern.split(/[\\/]+/).filter((segment) => segment.length > 0 && segment !== ".");
+}
+function matchWorkspaceSegments(currentDirectory, segments, index) {
+	if (index >= segments.length) return [currentDirectory];
+	const segment = segments[index];
+	if (segment === void 0) return [currentDirectory];
+	if (segment === "**") {
+		const results = new Set(matchWorkspaceSegments(currentDirectory, segments, index + 1));
+		listSubdirectories(currentDirectory).forEach((subdirectory) => {
+			matchWorkspaceSegments(subdirectory, segments, index).forEach((match) => {
+				results.add(match);
+			});
+		});
+		return [...results];
+	}
+	const matcher = createWorkspaceSegmentMatcher(segment);
+	const results = [];
+	listSubdirectories(currentDirectory).forEach((subdirectory) => {
+		if (!matcher(path.basename(subdirectory))) return;
+		results.push(...matchWorkspaceSegments(subdirectory, segments, index + 1));
+	});
+	return results;
+}
+function listSubdirectories(directory) {
+	return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git").map((entry) => path.join(directory, entry.name));
+}
+function createWorkspaceSegmentMatcher(segment) {
+	if (!segment.includes("*")) return (name) => name === segment;
+	const escapedSegment = escapeRegExp(segment).replaceAll("*", "[^/]*");
+	const pattern = new RegExp(`^${escapedSegment}$`);
+	return (name) => pattern.test(name);
+}
+function escapeRegExp(value) {
+	return value.replaceAll(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/analyzers/deps/diff.ts
+const PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+function analyzePackageDependencyDiff(directory, diff) {
+	const resolvedInputPath = path.resolve(process.cwd(), directory);
+	const repositoryRoot = findGitRepositoryRoot(resolvedInputPath);
+	const inputPathWithinRepository = resolveRepositoryInputPath(resolvedInputPath, repositoryRoot);
+	const comparison = resolveGitDiffComparison(repositoryRoot, diff);
+	const beforeGraph = loadGitTreeGraph(repositoryRoot, comparison.beforeTree, inputPathWithinRepository);
+	const afterGraph = comparison.afterTree === void 0 ? loadWorkingTreeGraph(repositoryRoot, inputPathWithinRepository) : loadGitTreeGraph(repositoryRoot, comparison.afterTree, inputPathWithinRepository);
+	if (beforeGraph === void 0 && afterGraph === void 0) throw new Error(`No package.json found from ${resolvedInputPath}`);
+	return {
+		repositoryRoot,
+		root: diffPackageNode({
+			beforePath: beforeGraph?.rootPath,
+			afterPath: afterGraph?.rootPath,
+			kind: "root"
+		}, beforeGraph, afterGraph, /* @__PURE__ */ new Set())
+	};
+}
+function resolveRepositoryInputPath(resolvedInputPath, repositoryRoot) {
+	const existingPath = findNearestExistingPath(resolvedInputPath);
+	const existingRealPath = fs.realpathSync.native(existingPath);
+	const repositoryRealPath = fs.realpathSync.native(repositoryRoot);
+	const relativeFromExistingPath = path.relative(existingPath, resolvedInputPath);
+	const relativeToRepository = path.relative(repositoryRealPath, existingRealPath);
+	const normalizedPath = path.normalize(path.join(relativeToRepository, relativeFromExistingPath));
+	return normalizedPath === "." ? "" : normalizedPath;
+}
+function findGitRepositoryRoot(resolvedInputPath) {
+	const searchPath = findNearestExistingPath(resolvedInputPath);
+	try {
+		return runGit(searchPath, ["rev-parse", "--show-toplevel"]).trim();
+	} catch (error) {
+		throw new Error(`Git diff mode requires a Git repository: ${getCommandErrorMessage(error)}`);
+	}
+}
+function findNearestExistingPath(resolvedInputPath) {
+	let currentPath = resolvedInputPath;
+	while (!fs.existsSync(currentPath)) {
+		const parentPath = path.dirname(currentPath);
+		if (parentPath === currentPath) return resolvedInputPath;
+		currentPath = parentPath;
+	}
+	if (fs.statSync(currentPath).isFile()) return path.dirname(currentPath);
+	return currentPath;
+}
+function resolveGitDiffComparison(repositoryRoot, diff) {
+	if (diff.includes("...")) {
+		const [baseRef, headRef] = splitDiffRange(diff, "...");
+		try {
+			return {
+				beforeTree: resolveGitTree(repositoryRoot, runGit(repositoryRoot, [
+					"merge-base",
+					baseRef,
+					headRef
+				]).trim()),
+				afterTree: resolveGitTree(repositoryRoot, headRef)
+			};
+		} catch (error) {
+			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+		}
+	}
+	if (diff.includes("..")) {
+		const [beforeRef, afterRef] = splitDiffRange(diff, "..");
+		try {
+			return {
+				beforeTree: resolveGitTree(repositoryRoot, beforeRef),
+				afterTree: resolveGitTree(repositoryRoot, afterRef)
+			};
+		} catch (error) {
+			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+		}
+	}
+	try {
+		return {
+			beforeTree: resolveGitTree(repositoryRoot, diff),
+			afterTree: void 0
+		};
+	} catch (error) {
+		throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+	}
+}
+function splitDiffRange(diff, separator) {
+	const [left, right, ...extra] = diff.split(separator);
+	if (left === void 0 || right === void 0 || left.length === 0 || right.length === 0 || extra.length > 0) throw new Error(`Invalid Git diff spec \`${diff}\``);
+	return [left, right];
+}
+function resolveGitTree(repositoryRoot, reference) {
+	return runGit(repositoryRoot, [
+		"rev-parse",
+		"--verify",
+		`${reference}^{tree}`
+	]).trim();
+}
+function loadWorkingTreeGraph(repositoryRoot, inputPathWithinRepository) {
+	const packageGraph = tryAnalyzePackageGraph(resolveSnapshotInputPath(repositoryRoot, inputPathWithinRepository));
+	return packageGraph === void 0 ? void 0 : toComparableGraph(packageGraph);
+}
+function loadGitTreeGraph(repositoryRoot, tree, inputPathWithinRepository) {
+	const snapshotRoot = materializeGitTreeSnapshot(repositoryRoot, tree);
+	try {
+		const packageGraph = tryAnalyzePackageGraph(resolveSnapshotInputPath(snapshotRoot, inputPathWithinRepository));
+		return packageGraph === void 0 ? void 0 : toComparableGraph(packageGraph);
+	} finally {
+		fs.rmSync(snapshotRoot, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function materializeGitTreeSnapshot(repositoryRoot, tree) {
+	const snapshotRoot = fs.mkdtempSync(path.join(os.tmpdir(), "foresthouse-deps-diff-"));
+	const trackedFiles = runGit(repositoryRoot, [
+		"ls-tree",
+		"-r",
+		"-z",
+		"--name-only",
+		tree
+	]).split("\0").filter((filePath) => filePath.length > 0);
+	trackedFiles.forEach((filePath) => {
+		ensureSnapshotDirectory(snapshotRoot, filePath);
+	});
+	trackedFiles.filter(isManifestSnapshotFile).forEach((filePath) => {
+		const fileContent = runGit(repositoryRoot, [
+			"cat-file",
+			"-p",
+			`${tree}:${filePath}`
+		], { trim: false });
+		const absolutePath = path.join(snapshotRoot, ...filePath.split("/"));
+		fs.writeFileSync(absolutePath, fileContent);
+	});
+	return snapshotRoot;
+}
+function ensureSnapshotDirectory(snapshotRoot, filePath) {
+	const parentDirectory = path.dirname(filePath);
+	if (parentDirectory === ".") return;
+	fs.mkdirSync(path.join(snapshotRoot, ...parentDirectory.split("/")), { recursive: true });
+}
+function isManifestSnapshotFile(filePath) {
+	const fileName = path.posix.basename(filePath);
+	return fileName === "package.json" || fileName === PNPM_WORKSPACE_FILE;
+}
+function resolveSnapshotInputPath(snapshotRoot, inputPathWithinRepository) {
+	if (inputPathWithinRepository === "") return snapshotRoot;
+	return path.join(snapshotRoot, inputPathWithinRepository);
+}
+function tryAnalyzePackageGraph(inputPath) {
+	if (!fs.existsSync(inputPath)) return;
+	try {
+		return analyzePackageDependencies(inputPath);
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("No package.json found from ")) return;
+		throw error;
+	}
+}
+function toComparableGraph(graph) {
+	const nodes = /* @__PURE__ */ new Map();
+	graph.nodes.forEach((node, packageDir) => {
+		const packagePath = toDisplayPath(packageDir, graph.repositoryRoot);
+		const dependenciesByKey = /* @__PURE__ */ new Map();
+		node.dependencies.forEach((dependency) => {
+			dependenciesByKey.set(createDependencyKey(dependency), toComparableDependency(dependency, graph.repositoryRoot));
+		});
+		nodes.set(packagePath, {
+			path: packagePath,
+			packageName: node.packageName,
+			dependenciesByKey
+		});
+	});
+	return {
+		rootPath: toDisplayPath(graph.rootId, graph.repositoryRoot),
+		nodes
+	};
+}
+function createDependencyKey(dependency) {
+	return `${dependency.kind}:${dependency.name}`;
+}
+function toComparableDependency(dependency, repositoryRoot) {
+	if (dependency.kind === "external") return {
+		kind: "external",
+		key: createDependencyKey(dependency),
+		name: dependency.name,
+		specifier: dependency.specifier
+	};
+	return {
+		kind: "workspace",
+		key: createDependencyKey(dependency),
+		name: dependency.name,
+		specifier: dependency.specifier,
+		targetPath: toDisplayPath(dependency.target, repositoryRoot)
+	};
+}
+function diffPackageNode(location, beforeGraph, afterGraph, ancestry) {
+	const nodeKey = `${location.beforePath ?? ""}->${location.afterPath ?? ""}`;
+	const beforeNode = location.beforePath === void 0 ? void 0 : beforeGraph?.nodes.get(location.beforePath);
+	const afterNode = location.afterPath === void 0 ? void 0 : afterGraph?.nodes.get(location.afterPath);
+	if (beforeNode === void 0 && afterNode === void 0) throw new Error("Unable to resolve package diff node.");
+	const packageName = afterNode?.packageName ?? beforeNode?.packageName ?? location.afterPath ?? location.beforePath ?? ".";
+	const packagePath = location.afterPath ?? location.beforePath ?? ".";
+	if (ancestry.has(nodeKey)) return {
+		kind: "circular",
+		label: location.kind === "root" ? packageName : packagePath,
+		packageName,
+		path: packagePath,
+		change: "unchanged",
+		dependencies: []
+	};
+	const nextAncestry = new Set(ancestry);
+	nextAncestry.add(nodeKey);
+	const dependencies = collectDependencyDiffs(beforeNode, afterNode, beforeGraph, afterGraph, nextAncestry);
+	const change = resolveNodeChange(location, beforeNode, afterNode, dependencies);
+	return {
+		kind: location.kind,
+		label: location.kind === "root" ? packageName : packagePath,
+		packageName,
+		path: packagePath,
+		change,
+		...beforeNode !== void 0 && afterNode !== void 0 && beforeNode.packageName !== afterNode.packageName ? {
+			beforePackageName: beforeNode.packageName,
+			afterPackageName: afterNode.packageName
+		} : {},
+		dependencies
+	};
+}
+function collectDependencyDiffs(beforeNode, afterNode, beforeGraph, afterGraph, ancestry) {
+	const dependencyKeys = new Set([...Array.from(beforeNode?.dependenciesByKey.keys() ?? []), ...Array.from(afterNode?.dependenciesByKey.keys() ?? [])]);
+	return Array.from(dependencyKeys).sort((left, right) => compareDependencyLabels(beforeNode?.dependenciesByKey.get(left) ?? afterNode?.dependenciesByKey.get(left), beforeNode?.dependenciesByKey.get(right) ?? afterNode?.dependenciesByKey.get(right))).flatMap((dependencyKey) => {
+		const dependency = diffDependency(beforeNode?.dependenciesByKey.get(dependencyKey), afterNode?.dependenciesByKey.get(dependencyKey), beforeGraph, afterGraph, ancestry);
+		return dependency === void 0 ? [] : [dependency];
+	});
+}
+function compareDependencyLabels(left, right) {
+	const leftLabel = left === void 0 ? "" : getDependencySortLabel(left);
+	const rightLabel = right === void 0 ? "" : getDependencySortLabel(right);
+	return leftLabel.localeCompare(rightLabel);
+}
+function getDependencySortLabel(dependency) {
+	if (dependency.kind === "external") return `${dependency.name}@${dependency.specifier}`;
+	return dependency.targetPath;
+}
+function diffDependency(beforeDependency, afterDependency, beforeGraph, afterGraph, ancestry) {
+	const change = resolveDependencyChange(beforeDependency, afterDependency);
+	if (beforeDependency?.kind === "workspace" || afterDependency?.kind === "workspace") {
+		const workspaceDependency = afterDependency?.kind === "workspace" ? afterDependency : beforeDependency?.kind === "workspace" ? beforeDependency : void 0;
+		if (workspaceDependency === void 0) return;
+		const node = diffPackageNode({
+			beforePath: beforeDependency?.kind === "workspace" ? beforeDependency.targetPath : void 0,
+			afterPath: afterDependency?.kind === "workspace" ? afterDependency.targetPath : void 0,
+			kind: "workspace"
+		}, beforeGraph, afterGraph, ancestry);
+		if (change === "unchanged" && !hasVisibleChanges(node)) return;
+		return {
+			kind: "workspace",
+			name: workspaceDependency.name,
+			change,
+			...beforeDependency === void 0 ? {} : { before: toDiffState(beforeDependency) },
+			...afterDependency === void 0 ? {} : { after: toDiffState(afterDependency) },
+			node
+		};
+	}
+	if (change === "unchanged") return;
+	const dependency = afterDependency ?? beforeDependency;
+	if (dependency === void 0 || dependency.kind !== "external") return;
+	return {
+		kind: "external",
+		name: dependency.name,
+		change,
+		...beforeDependency === void 0 ? {} : { before: toDiffState(beforeDependency) },
+		...afterDependency === void 0 ? {} : { after: toDiffState(afterDependency) }
+	};
+}
+function resolveDependencyChange(beforeDependency, afterDependency) {
+	if (beforeDependency === void 0 && afterDependency !== void 0) return "added";
+	if (beforeDependency !== void 0 && afterDependency === void 0) return "removed";
+	if (beforeDependency === void 0 || afterDependency === void 0) return "unchanged";
+	if (beforeDependency.kind !== afterDependency.kind) return "changed";
+	if (beforeDependency.kind === "external" && afterDependency.kind === "external") return beforeDependency.specifier === afterDependency.specifier ? "unchanged" : "changed";
+	if (beforeDependency.kind === "workspace" && afterDependency.kind === "workspace") return beforeDependency.specifier === afterDependency.specifier && beforeDependency.targetPath === afterDependency.targetPath ? "unchanged" : "changed";
+	return "changed";
+}
+function toDiffState(dependency) {
+	if (dependency.kind === "external") return {
+		target: `${dependency.name}@${dependency.specifier}`,
+		specifier: dependency.specifier
+	};
+	return dependency.specifier === void 0 ? { target: dependency.targetPath } : {
+		target: dependency.targetPath,
+		specifier: dependency.specifier
+	};
+}
+function hasVisibleChanges(node) {
+	return node.change !== "unchanged" || node.dependencies.length > 0;
+}
+function resolveNodeChange(location, beforeNode, afterNode, dependencies) {
+	if (beforeNode === void 0 && afterNode !== void 0) return "added";
+	if (beforeNode !== void 0 && afterNode === void 0) return "removed";
+	if (beforeNode === void 0 || afterNode === void 0) return "unchanged";
+	if (location.beforePath !== location.afterPath) return "changed";
+	if (beforeNode.packageName !== afterNode.packageName) return "changed";
+	return dependencies.some((dependency) => dependency.change !== "unchanged") ? "changed" : "unchanged";
+}
+function runGit(repositoryRoot, args, options = {}) {
+	const output = execFileSync("git", [
+		"-C",
+		repositoryRoot,
+		...args
+	], { encoding: "utf8" });
+	return options.trim === false ? output : output.trimEnd();
+}
+function getCommandErrorMessage(error) {
+	if (!(error instanceof Error)) return "Unknown Git error";
+	const stderr = Reflect.get(error, "stderr");
+	if (typeof stderr === "string" && stderr.trim().length > 0) return stderr.trim();
+	if (Buffer.isBuffer(stderr) && stderr.byteLength > 0) return stderr.toString("utf8").trim();
+	return error.message;
+}
+//#endregion
 //#region src/typescript/config.ts
 function loadCompilerOptions(searchFrom, explicitConfigPath) {
 	const configPath = explicitConfigPath === void 0 ? findNearestConfig(searchFrom) : path.resolve(searchFrom, explicitConfigPath);
@@ -54,17 +623,6 @@ function isInsideNodeModules$1(filePath) {
 	return filePath.includes(`${path.sep}node_modules${path.sep}`);
 }
 //#endregion
-//#region src/analyzers/base.ts
-var BaseAnalyzer = class {
-	constructor(entryFile, options) {
-		this.entryFile = entryFile;
-		this.options = options;
-	}
-	analyze() {
-		return this.doAnalyze();
-	}
-};
-//#endregion
 //#region src/utils/is-source-code-file.ts
 const SOURCE_EXTENSIONS = new Set([
 	".js",
@@ -1258,6 +1816,9 @@ const ANSI_HOOK = "\x1B[35m";
 const ANSI_BUILTIN = "\x1B[34m";
 const ANSI_MUTED = "\x1B[38;5;244m";
 const ANSI_UNUSED = "\x1B[38;5;214m";
+const ANSI_DIFF_ADDED = "\x1B[32m";
+const ANSI_DIFF_REMOVED = "\x1B[31m";
+const ANSI_DIFF_CHANGED = "\x1B[33m";
 function resolveColorSupport(mode = "auto", options = {}) {
 	if (mode === true) return true;
 	if (mode === false) return false;
@@ -1288,18 +1849,128 @@ function colorizeMuted(text, enabled) {
 	if (!enabled) return text;
 	return `${ANSI_MUTED}${text}${ANSI_RESET}`;
 }
+function colorizePackageDiff(text, change, enabled) {
+	if (!enabled) return text;
+	return `${getPackageDiffColor(change)}${text}${ANSI_RESET}`;
+}
 function getReactSymbolColor(kind) {
 	if (kind === "component") return ANSI_COMPONENT;
 	if (kind === "hook") return ANSI_HOOK;
 	return ANSI_BUILTIN;
 }
+function getPackageDiffColor(change) {
+	if (change === "added") return ANSI_DIFF_ADDED;
+	if (change === "removed") return ANSI_DIFF_REMOVED;
+	return ANSI_DIFF_CHANGED;
+}
 //#endregion
-//#region src/utils/to-display-path.ts
-function toDisplayPath(filePath, cwd) {
-	const relativePath = path.relative(cwd, filePath);
-	if (relativePath === "") return ".";
-	const normalizedPath = relativePath.split(path.sep).join("/");
-	return normalizedPath.startsWith("..") ? filePath : normalizedPath;
+//#region src/output/ascii/deps.ts
+function printPackageDependencyTree(graph, _options = {}) {
+	const rootNode = graph.nodes.get(graph.rootId);
+	if (rootNode === void 0) return toDisplayPath(graph.rootId, graph.repositoryRoot);
+	const lines = [rootNode.packageName];
+	const visited = new Set([graph.rootId]);
+	rootNode.dependencies.forEach((dependency, index) => {
+		lines.push(...renderDependency$1(dependency, graph, visited, "", index === rootNode.dependencies.length - 1));
+	});
+	return lines.join("\n");
+}
+function printPackageDependencyDiffTree(graph, options = {}) {
+	const color = resolveColorSupport(options.color);
+	const lines = [formatDiffRootLabel(graph.root, color)];
+	graph.root.dependencies.forEach((dependency, index) => {
+		lines.push(...renderDiffDependency(dependency, "", index === graph.root.dependencies.length - 1, color));
+	});
+	return lines.join("\n");
+}
+function renderDependency$1(dependency, graph, visited, prefix, isLast) {
+	const branch = `${prefix}${isLast ? "└─ " : "├─ "}`;
+	const label = formatDependencyLabel$1(dependency, graph.repositoryRoot);
+	if (dependency.kind === "external") return [`${branch}${label}`];
+	if (visited.has(dependency.target)) return [`${branch}${label} (circular)`];
+	const childNode = graph.nodes.get(dependency.target);
+	if (childNode === void 0) return [`${branch}${label}`];
+	const childLines = [`${branch}${label}`];
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	const nextVisited = new Set(visited);
+	nextVisited.add(dependency.target);
+	childNode.dependencies.forEach((childDependency, index) => {
+		childLines.push(...renderDependency$1(childDependency, graph, nextVisited, nextPrefix, index === childNode.dependencies.length - 1));
+	});
+	return childLines;
+}
+function formatDependencyLabel$1(dependency, repositoryRoot) {
+	if (dependency.kind === "external") return `${dependency.name}@${dependency.specifier}`;
+	const workspaceLabel = toDisplayPath(dependency.target, repositoryRoot);
+	if (dependency.specifier === void 0) return workspaceLabel;
+	return `${workspaceLabel} (${dependency.specifier})`;
+}
+function renderDiffDependency(dependency, prefix, isLast, color) {
+	const line = `${`${prefix}${isLast ? "└─ " : "├─ "}`}${formatDiffDependencyLine(dependency, color)}`;
+	if (dependency.kind === "external") return [line];
+	if (dependency.node.kind === "circular") return [`${line} (circular)`];
+	const childLines = [line];
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	dependency.node.dependencies.forEach((childDependency, index) => {
+		childLines.push(...renderDiffDependency(childDependency, nextPrefix, index === dependency.node.dependencies.length - 1, color));
+	});
+	return childLines;
+}
+function formatDiffRootLabel(node, color) {
+	if (node.change === "changed" && node.beforePackageName !== void 0 && node.afterPackageName !== void 0) return colorizeDiffText(`${toMarker(node.change)} ${node.beforePackageName} -> ${node.afterPackageName}`, node.change, color);
+	if (node.change === "unchanged") return node.packageName;
+	return colorizeDiffText(`${toMarker(node.change)} ${node.packageName}`, node.change, color);
+}
+function formatDiffDependencyLine(dependency, color) {
+	const marker = resolveVisibleDependencyMarker(dependency);
+	const label = formatDiffDependencyLabel(dependency);
+	if (marker === "unchanged") return label;
+	return colorizeDiffText(`${toMarker(marker)} ${label}`, marker, color);
+}
+function resolveVisibleDependencyMarker(dependency) {
+	if (dependency.change !== "unchanged") return dependency.change;
+	if (dependency.kind === "workspace" && dependency.node.change !== "unchanged") return dependency.node.change;
+	return "unchanged";
+}
+function formatDiffDependencyLabel(dependency) {
+	if (dependency.kind === "external") return formatExternalDiffLabel(dependency);
+	return formatWorkspaceDiffLabel(dependency);
+}
+function formatExternalDiffLabel(dependency) {
+	if (dependency.change !== "changed") return dependency.after?.target ?? dependency.before?.target ?? dependency.name;
+	const previousSpecifier = dependency.before?.specifier ?? "none";
+	const nextSpecifier = dependency.after?.specifier ?? "none";
+	return `${dependency.name}@${previousSpecifier} -> ${nextSpecifier}`;
+}
+function formatWorkspaceDiffLabel(dependency) {
+	if (dependency.change !== "changed") return formatWorkspaceState(dependency.after ?? dependency.before, dependency.node.path);
+	const previousTarget = dependency.before?.target ?? dependency.node.path;
+	const nextTarget = dependency.after?.target ?? dependency.node.path;
+	const targetLabel = previousTarget === nextTarget ? nextTarget : `${previousTarget} -> ${nextTarget}`;
+	const previousSpecifier = dependency.before?.specifier;
+	const nextSpecifier = dependency.after?.specifier;
+	if (previousSpecifier === nextSpecifier) return formatWorkspaceState({
+		target: targetLabel,
+		...nextSpecifier === void 0 ? {} : { specifier: nextSpecifier }
+	}, dependency.node.path);
+	return formatWorkspaceState({
+		target: targetLabel,
+		specifier: `${previousSpecifier ?? "none"} -> ${nextSpecifier ?? "none"}`
+	}, dependency.node.path);
+}
+function formatWorkspaceState(state, fallbackTarget) {
+	const target = state?.target ?? fallbackTarget;
+	if (state?.specifier === void 0) return target;
+	return `${target} (${state.specifier})`;
+}
+function toMarker(change) {
+	if (change === "added") return "+";
+	if (change === "removed") return "-";
+	return "~";
+}
+function colorizeDiffText(text, change, color) {
+	if (change === "unchanged") return text;
+	return colorizePackageDiff(text, change, color);
 }
 //#endregion
 //#region src/output/ascii/import.ts
@@ -1422,6 +2093,77 @@ function formatReactNodeFilePath$1(node, cwd) {
 	return node.kind === "builtin" ? "html" : toDisplayPath(node.filePath, cwd);
 }
 //#endregion
+//#region src/output/json/deps.ts
+function graphToSerializablePackageTree(graph) {
+	return serializePackageNode(graph.rootId, graph, /* @__PURE__ */ new Set());
+}
+function diffGraphToSerializablePackageTree(graph) {
+	return serializePackageDiffNode(graph.root);
+}
+function serializePackageNode(packageDir, graph, visited) {
+	const packageNode = graph.nodes.get(packageDir);
+	const packagePath = toDisplayPath(packageDir, graph.repositoryRoot);
+	if (packageNode === void 0) return {
+		kind: "missing",
+		label: packagePath,
+		path: packagePath,
+		dependencies: []
+	};
+	if (visited.has(packageDir)) return {
+		kind: "circular",
+		label: packageNode.packageName,
+		packageName: packageNode.packageName,
+		path: packagePath,
+		dependencies: []
+	};
+	visited.add(packageDir);
+	return {
+		kind: packageDir === graph.rootId ? "root" : "workspace",
+		label: packageDir === graph.rootId ? packageNode.packageName : packagePath,
+		packageName: packageNode.packageName,
+		path: packagePath,
+		dependencies: packageNode.dependencies.map((dependency) => serializeDependency(dependency, graph, new Set(visited)))
+	};
+}
+function serializeDependency(dependency, graph, visited) {
+	if (dependency.kind === "external") return {
+		kind: "external",
+		name: dependency.name,
+		specifier: dependency.specifier,
+		target: `${dependency.name}@${dependency.specifier}`
+	};
+	return {
+		kind: "workspace",
+		name: dependency.name,
+		...dependency.specifier === void 0 ? {} : { specifier: dependency.specifier },
+		target: toDisplayPath(dependency.target, graph.repositoryRoot),
+		node: serializePackageNode(dependency.target, graph, visited)
+	};
+}
+function serializePackageDiffNode(node) {
+	return {
+		kind: node.kind,
+		label: node.label,
+		packageName: node.packageName,
+		path: node.path,
+		change: node.change,
+		...node.beforePackageName === void 0 ? {} : { beforePackageName: node.beforePackageName },
+		...node.afterPackageName === void 0 ? {} : { afterPackageName: node.afterPackageName },
+		dependencies: node.dependencies.map((dependency) => serializePackageDiffDependency(dependency))
+	};
+}
+function serializePackageDiffDependency(dependency) {
+	return {
+		kind: dependency.kind,
+		name: dependency.name,
+		change: dependency.change,
+		...dependency.before === void 0 ? {} : { before: dependency.before },
+		...dependency.after === void 0 ? {} : { after: dependency.after },
+		...dependency.after === void 0 ? dependency.before === void 0 ? {} : { target: dependency.before.target } : { target: dependency.after.target },
+		...dependency.kind === "workspace" ? { node: serializePackageDiffNode(dependency.node) } : {}
+	};
+}
+//#endregion
 //#region src/output/json/import.ts
 function graphToSerializableTree(graph, options = {}) {
 	const visited = /* @__PURE__ */ new Set();
@@ -1532,6 +2274,6 @@ function formatReactNodeFilePath(filePath, kind, cwd) {
 	return kind === "builtin" ? "html" : toDisplayPath(filePath, cwd);
 }
 //#endregion
-export { getFilteredUsages as a, analyzeReactUsage as c, printDependencyTree as i, analyzeDependencies as l, graphToSerializableTree as n, getReactUsageEntries as o, printReactUsageTree as r, getReactUsageRoots as s, graphToSerializableReactTree as t, isSourceCodeFile as u };
+export { printReactUsageTree as a, printPackageDependencyTree as c, getReactUsageRoots as d, analyzeReactUsage as f, analyzePackageDependencies as g, analyzePackageDependencyDiff as h, graphToSerializablePackageTree as i, getFilteredUsages as l, isSourceCodeFile as m, graphToSerializableTree as n, printDependencyTree as o, analyzeDependencies as p, diffGraphToSerializablePackageTree as r, printPackageDependencyDiffTree as s, graphToSerializableReactTree as t, getReactUsageEntries as u };
 
-//# sourceMappingURL=react-GNHqx2A-.mjs.map
+//# sourceMappingURL=react-B2on-FAy.mjs.map