dep-brain 0.1.0

package/dist/core/analyzer.d.ts

@@ -0,0 +1,60 @@
+import { type DepBrainConfig, type DepBrainConfigOverrides } from "../utils/config.js";
+export interface AnalysisOptions {
+    rootDir?: string;
+    configPath?: string;
+    config?: DepBrainConfigOverrides;
+}
+export interface DuplicateInstance {
+    path: string;
+    version: string;
+}
+export interface DuplicateDependency {
+    name: string;
+    versions: string[];
+    instances: DuplicateInstance[];
+}
+export interface UnusedDependency {
+    name: string;
+    section: "dependencies" | "devDependencies";
+    package?: string;
+}
+export interface OutdatedDependency {
+    name: string;
+    current: string;
+    latest: string;
+    updateType: "major" | "minor" | "patch" | "unknown";
+    package?: string;
+}
+export interface RiskDependency {
+    name: string;
+    reasons: string[];
+    package?: string;
+}
+export interface AnalysisResult {
+    rootDir: string;
+    score: number;
+    policy: PolicyResult;
+    duplicates: DuplicateDependency[];
+    unused: UnusedDependency[];
+    outdated: OutdatedDependency[];
+    risks: RiskDependency[];
+    suggestions: string[];
+    config: DepBrainConfig;
+    packages?: PackageAnalysisResult[];
+}
+export interface PolicyResult {
+    passed: boolean;
+    reasons: string[];
+}
+export interface PackageAnalysisResult {
+    name: string;
+    rootDir: string;
+    score: number;
+    policy: PolicyResult;
+    duplicates: DuplicateDependency[];
+    unused: UnusedDependency[];
+    outdated: OutdatedDependency[];
+    risks: RiskDependency[];
+    suggestions: string[];
+}
+export declare function analyzeProject(options?: AnalysisOptions): Promise<AnalysisResult>;

package/dist/core/analyzer.js

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { findDuplicateDependencies } from "../checks/duplicate.js";
+import { findOutdatedDependencies } from "../checks/outdated.js";
+import { findRiskDependencies } from "../checks/risk.js";
+import { findUnusedDependencies } from "../checks/unused.js";
+import { loadDepBrainConfig } from "../utils/config.js";
+import { findWorkspacePackages } from "../utils/workspaces.js";
+import { buildDependencyGraph } from "./graph-builder.js";
+import { calculateHealthScore } from "./scorer.js";
+export async function analyzeProject(options = {}) {
+    const rootDir = path.resolve(options.rootDir ?? process.cwd());
+    const loadedConfig = await loadDepBrainConfig(rootDir, options.configPath);
+    const config = mergeConfig(loadedConfig, options.config);
+    const workspaces = await findWorkspacePackages(rootDir);
+    if (workspaces.length === 0) {
+        return analyzeSingleProject(rootDir, config);
+    }
+    const rootGraph = await buildDependencyGraph(rootDir);
+    const rawDuplicates = await findDuplicateDependencies(rootGraph);
+    const duplicates = rawDuplicates.filter((item) => !config.ignore.duplicates.includes(item.name));
+    const packages = [];
+    for (const workspace of workspaces) {
+        const result = await analyzeSingleProject(workspace.rootDir, config, {
+            packageName: workspace.name
+        });
+        packages.push({ ...result, name: workspace.name });
+    }
+    const unused = packages.flatMap((pkg) => pkg.unused.map((item) => ({ ...item, package: pkg.name })));
+    const outdated = packages.flatMap((pkg) => pkg.outdated.map((item) => ({ ...item, package: pkg.name })));
+    const risks = packages.flatMap((pkg) => pkg.risks.map((item) => ({ ...item, package: pkg.name })));
+    const score = calculateHealthScore({
+        duplicates: duplicates.length,
+        unused: unused.length,
+        outdated: outdated.length,
+        risks: risks.length
+    });
+    const suggestions = [
+        ...packages.flatMap((pkg) => pkg.suggestions.map((suggestion) => `[${pkg.name}] ${suggestion}`))
+    ].slice(0, config.report.maxSuggestions);
+    const policy = evaluatePolicy({
+        score,
+        duplicates: duplicates.length,
+        unused: unused.length,
+        outdated: outdated.length,
+        risks: risks.length
+    }, config);
+    return {
+        rootDir,
+        score,
+        policy,
+        duplicates,
+        unused,
+        outdated,
+        risks,
+        suggestions,
+        config,
+        packages
+    };
+}
+function mergeConfig(base, overrides) {
+    if (!overrides) {
+        return base;
+    }
+    return {
+        ignore: {
+            dependencies: overrides.ignore?.dependencies ?? base.ignore.dependencies,
+            devDependencies: overrides.ignore?.devDependencies ?? base.ignore.devDependencies,
+            duplicates: overrides.ignore?.duplicates ?? base.ignore.duplicates,
+            outdated: overrides.ignore?.outdated ?? base.ignore.outdated,
+            risks: overrides.ignore?.risks ?? base.ignore.risks,
+            unused: overrides.ignore?.unused ?? base.ignore.unused
+        },
+        policy: {
+            minScore: overrides.policy?.minScore ?? base.policy.minScore,
+            failOnDuplicates: overrides.policy?.failOnDuplicates ?? base.policy.failOnDuplicates,
+            failOnOutdated: overrides.policy?.failOnOutdated ?? base.policy.failOnOutdated,
+            failOnRisks: overrides.policy?.failOnRisks ?? base.policy.failOnRisks,
+            failOnUnused: overrides.policy?.failOnUnused ?? base.policy.failOnUnused
+        },
+        report: {
+            maxSuggestions: overrides.report?.maxSuggestions ?? base.report.maxSuggestions
+        }
+    };
+}
+function evaluatePolicy(summary, config) {
+    const reasons = [];
+    if (summary.score < config.policy.minScore) {
+        reasons.push(`Score ${summary.score} is below minimum ${config.policy.minScore}`);
+    }
+    if (config.policy.failOnDuplicates && summary.duplicates > 0) {
+        reasons.push(`Found ${summary.duplicates} duplicate dependencies`);
+    }
+    if (config.policy.failOnUnused && summary.unused > 0) {
+        reasons.push(`Found ${summary.unused} unused dependencies`);
+    }
+    if (config.policy.failOnOutdated && summary.outdated > 0) {
+        reasons.push(`Found ${summary.outdated} outdated dependencies`);
+    }
+    if (config.policy.failOnRisks && summary.risks > 0) {
+        reasons.push(`Found ${summary.risks} risky dependencies`);
+    }
+    return {
+        passed: reasons.length === 0,
+        reasons
+    };
+}
+async function analyzeSingleProject(rootDir, config, options = {}) {
+    const graph = await buildDependencyGraph(rootDir);
+    const [rawDuplicates, rawUnused, rawOutdated, rawRisks] = await Promise.all([
+        findDuplicateDependencies(graph),
+        findUnusedDependencies(rootDir, graph),
+        findOutdatedDependencies(graph),
+        findRiskDependencies(graph)
+    ]);
+    const duplicates = rawDuplicates.filter((item) => !config.ignore.duplicates.includes(item.name));
+    const unused = rawUnused.filter((item) => !config.ignore.unused.includes(item.name) &&
+        !config.ignore[item.section].includes(item.name));
+    const outdated = rawOutdated.filter((item) => !config.ignore.outdated.includes(item.name));
+    const risks = rawRisks.filter((item) => !config.ignore.risks.includes(item.name));
+    const score = calculateHealthScore({
+        duplicates: duplicates.length,
+        unused: unused.length,
+        outdated: outdated.length,
+        risks: risks.length
+    });
+    const suggestions = [
+        ...unused.map((item) => `Remove ${item.name} from ${item.section}`),
+        ...duplicates.map((item) => `Consider consolidating ${item.name} to one version`),
+        ...outdated.map((item) => `Review ${item.name}: ${item.current} -> ${item.latest} (${item.updateType})`)
+    ].slice(0, config.report.maxSuggestions);
+    const policy = evaluatePolicy({
+        score,
+        duplicates: duplicates.length,
+        unused: unused.length,
+        outdated: outdated.length,
+        risks: risks.length
+    }, config);
+    const scopedUnused = options.packageName && options.packageName.trim().length > 0
+        ? unused.map((item) => ({ ...item, package: options.packageName }))
+        : unused;
+    const scopedOutdated = options.packageName && options.packageName.trim().length > 0
+        ? outdated.map((item) => ({ ...item, package: options.packageName }))
+        : outdated;
+    const scopedRisks = options.packageName && options.packageName.trim().length > 0
+        ? risks.map((item) => ({ ...item, package: options.packageName }))
+        : risks;
+    return {
+        rootDir,
+        score,
+        policy,
+        duplicates,
+        unused: scopedUnused,
+        outdated: scopedOutdated,
+        risks: scopedRisks,
+        suggestions,
+        config
+    };
+}

package/dist/core/graph-builder.d.ts

@@ -0,0 +1,14 @@
+export interface LockPackageInstance {
+    path: string;
+    version: string;
+}
+export interface DependencyGraph {
+    rootDir: string;
+    packageJsonPath: string;
+    lockfilePath?: string;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    scripts: Record<string, string>;
+    lockPackages: Record<string, LockPackageInstance[]>;
+}
+export declare function buildDependencyGraph(rootDir: string): Promise<DependencyGraph>;

package/dist/core/graph-builder.js

@@ -0,0 +1,63 @@
+import path from "node:path";
+import { readJsonFile } from "../utils/file-parser.js";
+export async function buildDependencyGraph(rootDir) {
+    const packageJsonPath = path.join(rootDir, "package.json");
+    const lockfilePath = path.join(rootDir, "package-lock.json");
+    const packageJson = await readJsonFile(packageJsonPath);
+    const lockPackages = new Map();
+    try {
+        const packageLock = await readJsonFile(lockfilePath);
+        for (const [packagePath, details] of Object.entries(packageLock.packages ?? {})) {
+            const name = extractPackageName(packagePath);
+            const version = details.version;
+            if (!name || !version) {
+                continue;
+            }
+            const instances = lockPackages.get(name) ?? new Map();
+            const normalizedPath = packagePath || "node_modules/" + name;
+            instances.set(normalizedPath, { path: normalizedPath, version });
+            lockPackages.set(name, instances);
+        }
+        for (const [name, details] of Object.entries(packageLock.dependencies ?? {})) {
+            if (!details.version) {
+                continue;
+            }
+            const instances = lockPackages.get(name) ?? new Map();
+            const normalizedPath = `node_modules/${name}`;
+            instances.set(normalizedPath, { path: normalizedPath, version: details.version });
+            lockPackages.set(name, instances);
+        }
+    }
+    catch {
+        return {
+            rootDir,
+            packageJsonPath,
+            dependencies: packageJson.dependencies ?? {},
+            devDependencies: packageJson.devDependencies ?? {},
+            scripts: packageJson.scripts ?? {},
+            lockPackages: {}
+        };
+    }
+    return {
+        rootDir,
+        packageJsonPath,
+        lockfilePath,
+        dependencies: packageJson.dependencies ?? {},
+        devDependencies: packageJson.devDependencies ?? {},
+        scripts: packageJson.scripts ?? {},
+        lockPackages: Object.fromEntries(Array.from(lockPackages.entries()).map(([name, instances]) => [
+            name,
+            Array.from(instances.values()).sort((left, right) => left.path.localeCompare(right.path))
+        ]))
+    };
+}
+function extractPackageName(packagePath) {
+    if (!packagePath) {
+        return null;
+    }
+    const match = packagePath.match(/(?:^|\/)node_modules\/(.+)$/);
+    if (!match) {
+        return null;
+    }
+    return match[1];
+}

package/dist/core/scorer.d.ts

@@ -0,0 +1,7 @@
+export interface ScoreInputs {
+    duplicates: number;
+    unused: number;
+    outdated: number;
+    risks: number;
+}
+export declare function calculateHealthScore(inputs: ScoreInputs): number;

package/dist/core/scorer.js

@@ -0,0 +1,8 @@
+export function calculateHealthScore(inputs) {
+    const rawScore = 100 -
+        inputs.duplicates * 5 -
+        inputs.outdated * 3 -
+        inputs.unused * 4 -
+        inputs.risks * 10;
+    return Math.max(0, rawScore);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { analyzeProject } from "./core/analyzer.js";
+export type { AnalysisOptions, AnalysisResult, DuplicateDependency, OutdatedDependency, PolicyResult, PackageAnalysisResult, RiskDependency, UnusedDependency } from "./core/analyzer.js";
+export type { DepBrainConfig, DepBrainConfigOverrides } from "./utils/config.js";
+export type { WorkspacePackage } from "./utils/workspaces.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { analyzeProject } from "./core/analyzer.js";

package/dist/reporters/console.d.ts

@@ -0,0 +1,2 @@
+import type { AnalysisResult } from "../core/analyzer.js";
+export declare function renderConsoleReport(result: AnalysisResult): string;

package/dist/reporters/console.js

@@ -0,0 +1,51 @@
+export function renderConsoleReport(result) {
+    const lines = [];
+    lines.push(`Project Health: ${result.score}/100`);
+    lines.push(`Path: ${result.rootDir}`);
+    lines.push(`Policy: ${result.policy.passed ? "PASS" : "FAIL"}`);
+    lines.push("");
+    lines.push(summaryLine("Duplicates", result.duplicates.length));
+    lines.push(summaryLine("Unused", result.unused.length));
+    lines.push(summaryLine("Outdated", result.outdated.length));
+    lines.push(summaryLine("Risks", result.risks.length));
+    if (result.packages && result.packages.length > 0) {
+        lines.push("");
+        lines.push("Packages:");
+        for (const pkg of result.packages) {
+            lines.push(`- ${pkg.name}: ${pkg.score}/100, D:${pkg.duplicates.length} U:${pkg.unused.length} O:${pkg.outdated.length} R:${pkg.risks.length}`);
+        }
+    }
+    appendSection(lines, "Duplicate dependencies", result.duplicates.map((item) => `${item.name}: ${item.versions.join(", ")}`));
+    appendSection(lines, "Unused dependencies", result.unused.map((item) => item.package
+        ? `${item.name} (${item.section}) [${item.package}]`
+        : `${item.name} (${item.section})`));
+    appendSection(lines, "Outdated dependencies", result.outdated.map((item) => item.package
+        ? `${item.name}: ${item.current} -> ${item.latest} [${item.updateType}] [${item.package}]`
+        : `${item.name}: ${item.current} -> ${item.latest} [${item.updateType}]`));
+    appendSection(lines, "Risky dependencies", result.risks.map((item) => item.package
+        ? `${item.name}: ${item.reasons.join("; ")} [${item.package}]`
+        : `${item.name}: ${item.reasons.join("; ")}`));
+    appendSection(lines, "Policy reasons", result.policy.reasons);
+    if (result.suggestions.length > 0) {
+        lines.push("");
+        lines.push("Suggestions:");
+        for (const suggestion of result.suggestions) {
+            lines.push(`- ${suggestion}`);
+        }
+    }
+    return lines.join("\n");
+}
+function summaryLine(label, count) {
+    const indicator = count === 0 ? "OK" : "WARN";
+    return `${indicator} ${label}: ${count}`;
+}
+function appendSection(lines, title, entries) {
+    if (entries.length === 0) {
+        return;
+    }
+    lines.push("");
+    lines.push(`${title}:`);
+    for (const entry of entries.slice(0, 10)) {
+        lines.push(`- ${entry}`);
+    }
+}

package/dist/reporters/json.d.ts

@@ -0,0 +1,2 @@
+import type { AnalysisResult } from "../core/analyzer.js";
+export declare function renderJsonReport(result: AnalysisResult): string;

package/dist/reporters/json.js

@@ -0,0 +1,3 @@
+export function renderJsonReport(result) {
+    return JSON.stringify(result, null, 2);
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,27 @@
+export interface DepBrainConfig {
+    ignore: {
+        dependencies: string[];
+        devDependencies: string[];
+        duplicates: string[];
+        outdated: string[];
+        risks: string[];
+        unused: string[];
+    };
+    policy: {
+        minScore: number;
+        failOnDuplicates: boolean;
+        failOnOutdated: boolean;
+        failOnRisks: boolean;
+        failOnUnused: boolean;
+    };
+    report: {
+        maxSuggestions: number;
+    };
+}
+export interface DepBrainConfigOverrides {
+    ignore?: Partial<DepBrainConfig["ignore"]>;
+    policy?: Partial<DepBrainConfig["policy"]>;
+    report?: Partial<DepBrainConfig["report"]>;
+}
+export declare const defaultConfig: DepBrainConfig;
+export declare function loadDepBrainConfig(rootDir: string, configPath?: string): Promise<DepBrainConfig>;

package/dist/utils/config.js

@@ -0,0 +1,66 @@
+import path from "node:path";
+import { readJsonFile } from "./file-parser.js";
+export const defaultConfig = {
+    ignore: {
+        dependencies: [],
+        devDependencies: [],
+        duplicates: [],
+        outdated: [],
+        risks: [],
+        unused: []
+    },
+    policy: {
+        minScore: 0,
+        failOnDuplicates: false,
+        failOnOutdated: false,
+        failOnRisks: false,
+        failOnUnused: false
+    },
+    report: {
+        maxSuggestions: 5
+    }
+};
+export async function loadDepBrainConfig(rootDir, configPath) {
+    const resolvedPath = path.resolve(rootDir, configPath ?? "depbrain.config.json");
+    try {
+        const loaded = await readJsonFile(resolvedPath);
+        return normalizeConfig(loaded);
+    }
+    catch {
+        return defaultConfig;
+    }
+}
+function normalizeConfig(loaded) {
+    return {
+        ignore: {
+            dependencies: normalizeStringArray(loaded.ignore?.dependencies, defaultConfig.ignore.dependencies),
+            devDependencies: normalizeStringArray(loaded.ignore?.devDependencies, defaultConfig.ignore.devDependencies),
+            duplicates: normalizeStringArray(loaded.ignore?.duplicates, defaultConfig.ignore.duplicates),
+            outdated: normalizeStringArray(loaded.ignore?.outdated, defaultConfig.ignore.outdated),
+            risks: normalizeStringArray(loaded.ignore?.risks, defaultConfig.ignore.risks),
+            unused: normalizeStringArray(loaded.ignore?.unused, defaultConfig.ignore.unused)
+        },
+        policy: {
+            minScore: normalizeNumber(loaded.policy?.minScore, defaultConfig.policy.minScore),
+            failOnDuplicates: normalizeBoolean(loaded.policy?.failOnDuplicates, defaultConfig.policy.failOnDuplicates),
+            failOnOutdated: normalizeBoolean(loaded.policy?.failOnOutdated, defaultConfig.policy.failOnOutdated),
+            failOnRisks: normalizeBoolean(loaded.policy?.failOnRisks, defaultConfig.policy.failOnRisks),
+            failOnUnused: normalizeBoolean(loaded.policy?.failOnUnused, defaultConfig.policy.failOnUnused)
+        },
+        report: {
+            maxSuggestions: normalizeNumber(loaded.report?.maxSuggestions, defaultConfig.report.maxSuggestions)
+        }
+    };
+}
+function normalizeStringArray(value, fallback) {
+    if (!Array.isArray(value)) {
+        return fallback;
+    }
+    return value.filter((item) => typeof item === "string");
+}
+function normalizeBoolean(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function normalizeNumber(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}

package/dist/utils/file-parser.d.ts

@@ -0,0 +1,3 @@
+export declare function readJsonFile<T>(filePath: string): Promise<T>;
+export declare function readTextFile(filePath: string): Promise<string>;
+export declare function collectProjectFiles(rootDir: string, pattern: RegExp): Promise<string[]>;

package/dist/utils/file-parser.js

@@ -0,0 +1,27 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function readJsonFile(filePath) {
+    const content = await fs.readFile(filePath, "utf8");
+    return JSON.parse(content);
+}
+export async function readTextFile(filePath) {
+    return fs.readFile(filePath, "utf8");
+}
+export async function collectProjectFiles(rootDir, pattern) {
+    const entries = await fs.readdir(rootDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === ".git") {
+                continue;
+            }
+            files.push(...(await collectProjectFiles(fullPath, pattern)));
+            continue;
+        }
+        if (pattern.test(entry.name)) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}

package/dist/utils/npm-api.d.ts

@@ -0,0 +1,8 @@
+export interface PackageMetadata {
+    latestVersion: string | null;
+    repository: string | null;
+    downloads: number | null;
+    daysSincePublish: number | null;
+}
+export declare function getLatestVersion(name: string): Promise<string | null>;
+export declare function getPackageMetadata(name: string): Promise<PackageMetadata | null>;

package/dist/utils/npm-api.js

@@ -0,0 +1,52 @@
+const metadataCache = new Map();
+export async function getLatestVersion(name) {
+    const metadata = await getPackageMetadata(name);
+    return metadata?.latestVersion ?? null;
+}
+export async function getPackageMetadata(name) {
+    const existing = metadataCache.get(name);
+    if (existing) {
+        return existing;
+    }
+    const request = fetchPackageMetadata(name);
+    metadataCache.set(name, request);
+    return request;
+}
+async function fetchPackageMetadata(name) {
+    try {
+        const [packageResponse, downloadsResponse] = await Promise.all([
+            fetch(`https://registry.npmjs.org/${encodeURIComponent(name)}`, {
+                signal: AbortSignal.timeout(5000)
+            }),
+            fetch(`https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(name)}`, {
+                signal: AbortSignal.timeout(5000)
+            })
+        ]);
+        if (!packageResponse.ok) {
+            return null;
+        }
+        const packageJson = (await packageResponse.json());
+        const downloadsJson = downloadsResponse.ok
+            ? (await downloadsResponse.json())
+            : {};
+        const latestVersion = packageJson["dist-tags"]?.latest ?? null;
+        const latestPublishedAt = latestVersion && packageJson.time?.[latestVersion]
+            ? new Date(packageJson.time[latestVersion])
+            : null;
+        const daysSincePublish = latestPublishedAt === null
+            ? null
+            : Math.floor((Date.now() - latestPublishedAt.getTime()) / (1000 * 60 * 60 * 24));
+        const repository = typeof packageJson.repository === "string"
+            ? packageJson.repository
+            : packageJson.repository?.url ?? null;
+        return {
+            latestVersion,
+            repository,
+            downloads: downloadsJson.downloads ?? null,
+            daysSincePublish
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/workspaces.d.ts

@@ -0,0 +1,6 @@
+export interface WorkspacePackage {
+    name: string;
+    rootDir: string;
+    packageJsonPath: string;
+}
+export declare function findWorkspacePackages(rootDir: string): Promise<WorkspacePackage[]>;

package/dist/utils/workspaces.js

@@ -0,0 +1,68 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { readJsonFile } from "./file-parser.js";
+export async function findWorkspacePackages(rootDir) {
+    const rootPackageJsonPath = path.join(rootDir, "package.json");
+    const rootPackage = await readJsonFile(rootPackageJsonPath).catch(() => null);
+    if (!rootPackage?.workspaces) {
+        return [];
+    }
+    const patterns = Array.isArray(rootPackage.workspaces)
+        ? rootPackage.workspaces
+        : rootPackage.workspaces.packages ?? [];
+    if (patterns.length === 0) {
+        return [];
+    }
+    const packageJsonFiles = await collectPackageJsonFiles(rootDir);
+    const matches = packageJsonFiles.filter((filePath) => matchesWorkspacePatterns(rootDir, filePath, patterns));
+    const packages = [];
+    for (const packageJsonPath of matches) {
+        const pkg = await readJsonFile(packageJsonPath).catch(() => null);
+        if (!pkg?.name) {
+            continue;
+        }
+        packages.push({
+            name: pkg.name,
+            rootDir: path.dirname(packageJsonPath),
+            packageJsonPath
+        });
+    }
+    return packages.sort((left, right) => left.name.localeCompare(right.name));
+}
+async function collectPackageJsonFiles(rootDir) {
+    const entries = await fs.readdir(rootDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (entry.name === "node_modules" || entry.name === ".git") {
+            continue;
+        }
+        const fullPath = path.join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await collectPackageJsonFiles(fullPath)));
+            continue;
+        }
+        if (entry.isFile() && entry.name === "package.json") {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function matchesWorkspacePatterns(rootDir, packageJsonPath, patterns) {
+    const rel = normalizePath(path.relative(rootDir, path.dirname(packageJsonPath)));
+    return patterns.some((pattern) => {
+        const regex = globToRegExp(pattern);
+        return regex.test(rel);
+    });
+}
+function globToRegExp(pattern) {
+    const normalized = normalizePath(pattern)
+        .replace(/\/+$/, "")
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, "___DEPBRAIN_GLOBSTAR___")
+        .replace(/\*/g, "[^/]*")
+        .replace(/___DEPBRAIN_GLOBSTAR___/g, ".*");
+    return new RegExp(`^${normalized}$`);
+}
+function normalizePath(value) {
+    return value.split(path.sep).join("/");
+}