dependency-radar 0.2.0 → 0.3.0

package/dist/runners/npmLs.js

@@ -6,27 +6,228 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runNpmLs = runNpmLs;
 const path_1 = __importDefault(require("path"));
 const utils_1 = require("../utils");
-async function runNpmLs(projectPath, tempDir) {
-    const targetFile = path_1.default.join(tempDir, 'npm-ls.json');
+// Normalize package-manager-specific list output into a shared dependency tree.
+async function runNpmLs(projectPath, tempDir, tool = 'npm') {
+    const targetFile = path_1.default.join(tempDir, `${tool}-ls.json`);
     try {
-        const result = await (0, utils_1.runCommand)('npm', ['ls', '--json', '--all'], { cwd: projectPath });
-        let parsed;
-        try {
-            parsed = JSON.parse(result.stdout || '{}');
-        }
-        catch (err) {
-            parsed = undefined;
-        }
-        if (parsed) {
-            await (0, utils_1.writeJsonFile)(targetFile, parsed);
-            return { ok: true, data: parsed, file: targetFile };
+        const { args, normalize } = buildLsCommand(tool);
+        const result = await (0, utils_1.runCommand)(tool, args, { cwd: projectPath });
+        const parsed = parseJsonOutput(result.stdout);
+        const normalized = normalize(parsed);
+        if (normalized) {
+            await (0, utils_1.writeJsonFile)(targetFile, normalized);
+            return { ok: true, data: normalized, file: targetFile };
         }
         await (0, utils_1.writeJsonFile)(targetFile, { stdout: result.stdout, stderr: result.stderr, code: result.code });
-        const error = result.code && result.code !== 0 ? `npm ls exited with code ${result.code}` : 'Failed to parse npm ls output';
+        const error = result.code && result.code !== 0
+            ? `${tool} ls exited with code ${result.code}`
+            : `Failed to parse ${tool} ls output`;
         return { ok: false, error, file: targetFile };
     }
     catch (err) {
         await (0, utils_1.writeJsonFile)(targetFile, { error: String(err) });
-        return { ok: false, error: `npm ls failed: ${String(err)}`, file: targetFile };
+        return { ok: false, error: `${tool} ls failed: ${String(err)}`, file: targetFile };
+    }
+}
+function buildLsCommand(tool) {
+    if (tool === 'pnpm') {
+        return {
+            args: ['list', '--json', '--depth', 'Infinity'],
+            normalize: normalizePnpmTree
+        };
+    }
+    if (tool === 'yarn') {
+        return {
+            args: ['list', '--json', '--depth', 'Infinity'],
+            normalize: normalizeYarnTree
+        };
+    }
+    return {
+        args: ['ls', '--json', '--all', '--long'],
+        normalize: normalizeNpmTree
+    };
+}
+function parseJsonOutput(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        // Some tools emit JSONL (yarn). Parse best-effort into an array of objects.
+        const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        const parsed = [];
+        for (const line of lines) {
+            try {
+                parsed.push(JSON.parse(line));
+            }
+            catch {
+                // ignore non-JSON lines
+            }
+        }
+        return parsed.length > 0 ? parsed : undefined;
+    }
+}
+function normalizeNpmTree(data) {
+    if (!data || typeof data !== 'object')
+        return undefined;
+    const deps = data.dependencies && typeof data.dependencies === 'object' ? data.dependencies : {};
+    const normalized = { dependencies: {} };
+    for (const [name, node] of Object.entries(deps)) {
+        const normalizedNode = normalizeNpmNode(name, node);
+        if (normalizedNode)
+            normalized.dependencies[name] = normalizedNode;
+    }
+    return normalized;
+}
+function normalizeNpmNode(name, node) {
+    if (!node || typeof node !== 'object')
+        return undefined;
+    if (node.missing || node.extraneous)
+        return undefined;
+    const version = typeof (node === null || node === void 0 ? void 0 : node.version) === 'string' ? node.version.trim() : '';
+    if (!version || version === 'unknown' || version === 'missing' || version === 'invalid')
+        return undefined;
+    const out = { name, version, dependencies: {} };
+    if (typeof node.path === 'string' && node.path.trim()) {
+        out.path = node.path.trim();
+    }
+    if ((node === null || node === void 0 ? void 0 : node.dependencies) && typeof node.dependencies === 'object') {
+        for (const [childName, child] of Object.entries(node.dependencies)) {
+            const normalizedChild = normalizeNpmNode(childName, child);
+            if (normalizedChild)
+                out.dependencies[childName] = normalizedChild;
+        }
+    }
+    if ((node === null || node === void 0 ? void 0 : node.dev) !== undefined)
+        out.dev = Boolean(node.dev);
+    if (out.dependencies && Object.keys(out.dependencies).length === 0) {
+        delete out.dependencies;
+    }
+    return out;
+}
+function normalizePnpmTree(data) {
+    const roots = Array.isArray(data) ? data : [data];
+    const root = roots.find((entry) => entry && typeof entry === 'object');
+    if (!root || typeof root !== 'object')
+        return undefined;
+    const dependencies = collectPnpmDependencyMap(root);
+    return { dependencies };
+}
+function collectPnpmDependencyMap(node) {
+    const out = {};
+    const groups = ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies'];
+    for (const group of groups) {
+        const value = node === null || node === void 0 ? void 0 : node[group];
+        if (!value)
+            continue;
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                const name = typeof entry.name === 'string' ? entry.name : undefined;
+                if (!name)
+                    continue;
+                const normalized = normalizePnpmNode(name, entry);
+                if (normalized)
+                    out[name] = normalized;
+            }
+            continue;
+        }
+        if (typeof value === 'object') {
+            for (const [name, entry] of Object.entries(value)) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                const normalized = normalizePnpmNode(name, entry);
+                if (normalized)
+                    out[name] = normalized;
+            }
+        }
+    }
+    if (Object.keys(out).length > 0)
+        return out;
+    if ((node === null || node === void 0 ? void 0 : node.dependencies) && typeof node.dependencies === 'object') {
+        for (const [name, entry] of Object.entries(node.dependencies)) {
+            const normalized = normalizePnpmNode(name, entry);
+            if (normalized)
+                out[name] = normalized;
+        }
+    }
+    return out;
+}
+function normalizePnpmNode(name, node) {
+    const version = typeof (node === null || node === void 0 ? void 0 : node.version) === 'string' ? node.version.trim() : '';
+    if (!version || version === 'unknown' || version === 'missing' || version === 'invalid')
+        return undefined;
+    const out = { name, version, dependencies: {} };
+    const childMap = collectPnpmDependencyMap(node);
+    if (Object.keys(childMap).length > 0) {
+        out.dependencies = childMap;
+    }
+    else {
+        delete out.dependencies;
+    }
+    if ((node === null || node === void 0 ? void 0 : node.dev) !== undefined)
+        out.dev = Boolean(node.dev);
+    return out;
+}
+function normalizeYarnTree(data) {
+    const treePayload = resolveYarnTreePayload(data);
+    if (!treePayload || !Array.isArray(treePayload.trees))
+        return undefined;
+    const out = { dependencies: {} };
+    for (const node of treePayload.trees) {
+        const parsed = normalizeYarnNode(node);
+        if (parsed)
+            out.dependencies[parsed.name] = parsed.node;
+    }
+    return out;
+}
+function resolveYarnTreePayload(data) {
+    var _a;
+    if (!data)
+        return undefined;
+    if ((_a = data === null || data === void 0 ? void 0 : data.data) === null || _a === void 0 ? void 0 : _a.trees)
+        return data.data;
+    if (data === null || data === void 0 ? void 0 : data.trees)
+        return data;
+    if (Array.isArray(data)) {
+        const treeItem = data.find((item) => { var _a; return item && typeof item === 'object' && item.type === 'tree' && ((_a = item.data) === null || _a === void 0 ? void 0 : _a.trees); });
+        return treeItem === null || treeItem === void 0 ? void 0 : treeItem.data;
+    }
+    return undefined;
+}
+function normalizeYarnNode(node) {
+    if (!node || typeof node !== 'object')
+        return undefined;
+    const label = typeof node.name === 'string' ? node.name : '';
+    const parsed = splitYarnLabel(label);
+    if (!parsed.version || parsed.version === 'unknown' || parsed.version === 'missing' || parsed.version === 'invalid')
+        return undefined;
+    const out = { name: parsed.name, version: parsed.version, dependencies: {} };
+    if (Array.isArray(node.children)) {
+        for (const child of node.children) {
+            const parsedChild = normalizeYarnNode(child);
+            if (parsedChild) {
+                out.dependencies[parsedChild.name] = parsedChild.node;
+            }
+        }
+    }
+    if (out.dependencies && Object.keys(out.dependencies).length === 0) {
+        delete out.dependencies;
+    }
+    return { name: parsed.name, node: out };
+}
+function splitYarnLabel(label) {
+    if (!label)
+        return { name: 'unknown', version: 'unknown' };
+    const lastAt = label.lastIndexOf('@');
+    if (lastAt <= 0)
+        return { name: label, version: 'unknown' };
+    const name = label.slice(0, lastAt);
+    let version = label.slice(lastAt + 1);
+    if (version.startsWith('npm:')) {
+        version = version.slice(4);
     }
+    return { name, version: version || 'unknown' };
 }

package/dist/runners/npmOutdated.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPackageOutdated = runPackageOutdated;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../utils");
+function normalizeOutdatedOutput(tool, data) {
+    if (!data)
+        return undefined;
+    if (typeof data === "object" && !Array.isArray(data) && !data.type)
+        return data;
+    if (Array.isArray(data)) {
+        // pnpm often returns arrays of rows
+        const out = {};
+        for (const entry of data) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const name = entry.name || entry.packageName;
+            if (typeof name !== "string" || !name.trim())
+                continue;
+            out[name] = {
+                current: entry.current || entry.currentVersion || entry.from,
+                latest: entry.latest || entry.latestVersion || entry.to,
+                wanted: entry.wanted,
+            };
+        }
+        return Object.keys(out).length > 0 ? out : undefined;
+    }
+    // Yarn JSONL table output
+    const entries = Array.isArray(data) ? data : [data];
+    const tableEntry = entries.find((e) => { var _a; return e && typeof e === "object" && (e.type === "table" || ((_a = e.data) === null || _a === void 0 ? void 0 : _a.body)); });
+    const table = (tableEntry === null || tableEntry === void 0 ? void 0 : tableEntry.data) || tableEntry;
+    if (table && Array.isArray(table.head) && Array.isArray(table.body)) {
+        const head = table.head.map((h) => String(h).toLowerCase());
+        const idx = {
+            name: head.findIndex((h) => h.includes("package") || h.includes("name")),
+            current: head.findIndex((h) => h.includes("current")),
+            latest: head.findIndex((h) => h.includes("latest")),
+            wanted: head.findIndex((h) => h.includes("wanted")),
+        };
+        const out = {};
+        for (const row of table.body) {
+            if (!Array.isArray(row))
+                continue;
+            const name = idx.name >= 0 ? String(row[idx.name]) : "";
+            if (!name)
+                continue;
+            out[name] = {
+                current: idx.current >= 0 ? String(row[idx.current]) : undefined,
+                latest: idx.latest >= 0 ? String(row[idx.latest]) : undefined,
+                wanted: idx.wanted >= 0 ? String(row[idx.wanted]) : undefined,
+            };
+        }
+        return Object.keys(out).length > 0 ? out : undefined;
+    }
+    if (tool === "pnpm" && data.outdated)
+        return data.outdated;
+    return undefined;
+}
+function buildOutdatedCommand(tool) {
+    if (tool === "pnpm") {
+        return {
+            cmd: "pnpm",
+            args: ["outdated", "--json"],
+            lockFiles: ["pnpm-lock.yaml"],
+        };
+    }
+    if (tool === "yarn") {
+        return {
+            cmd: "yarn",
+            args: ["outdated", "--json"],
+            lockFiles: ["yarn.lock"],
+        };
+    }
+    return {
+        cmd: "npm",
+        args: ["outdated", "--json", "--long"],
+        lockFiles: ["package-lock.json", "npm-shrinkwrap.json"],
+    };
+}
+async function runPackageOutdated(projectPath, tempDir, tool) {
+    const targetFile = path_1.default.join(tempDir, `${tool}-outdated.json`);
+    try {
+        const { cmd, args, lockFiles } = buildOutdatedCommand(tool);
+        const lockDir = await (0, utils_1.findLockDir)(projectPath, lockFiles);
+        const cwd = lockDir || projectPath;
+        const result = await (0, utils_1.runCommand)(cmd, args, { cwd });
+        const parsed = (0, utils_1.parseJsonOutput)(result.stdout);
+        const normalized = normalizeOutdatedOutput(tool, parsed);
+        if (normalized && typeof normalized === "object") {
+            await (0, utils_1.writeJsonFile)(targetFile, normalized);
+            return { ok: true, data: normalized, file: targetFile };
+        }
+        await (0, utils_1.writeJsonFile)(targetFile, {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            code: result.code,
+        });
+        return {
+            ok: false,
+            error: `Failed to parse ${tool} outdated output`,
+            file: targetFile,
+        };
+    }
+    catch (err) {
+        await (0, utils_1.writeJsonFile)(targetFile, { error: String(err) });
+        return {
+            ok: false,
+            error: `${tool} outdated failed: ${String(err)}`,
+            file: targetFile,
+        };
+    }
+}

package/dist/utils.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
-exports.delay = delay;
 exports.getDependencyRadarVersion = getDependencyRadarVersion;
 exports.ensureDir = ensureDir;
 exports.writeJsonFile = writeJsonFile;
@@ -15,8 +14,11 @@ exports.readPackageJson = readPackageJson;
 exports.findBin = findBin;
 exports.licenseRiskLevel = licenseRiskLevel;
 exports.vulnRiskLevel = vulnRiskLevel;
-exports.maintenanceRisk = maintenanceRisk;
+exports.resolvePackageJsonPath = resolvePackageJsonPath;
 exports.readLicenseFromPackageJson = readLicenseFromPackageJson;
+exports.readLicenseFromPackageDir = readLicenseFromPackageDir;
+exports.findLockDir = findLockDir;
+exports.parseJsonOutput = parseJsonOutput;
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const promises_1 = __importDefault(require("fs/promises"));
@@ -41,9 +43,6 @@ function runCommand(command, args, options = {}) {
         });
     });
 }
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 function getDependencyRadarVersion() {
     try {
         const pkgPath = path_1.default.join(__dirname, '..', 'package.json');
@@ -118,32 +117,133 @@ function vulnRiskLevel(counts) {
         return 'amber';
     return 'green';
 }
-function maintenanceRisk(lastPublished) {
-    if (!lastPublished)
-        return 'unknown';
-    const last = new Date(lastPublished).getTime();
-    if (Number.isNaN(last))
-        return 'unknown';
-    const now = Date.now();
-    const months = (now - last) / (1000 * 60 * 60 * 24 * 30);
-    if (months <= 12)
-        return 'green';
-    if (months <= 36)
-        return 'amber';
-    return 'red';
+const pnpmStoreEntriesCache = new Map();
+const pnpmStoreIndexCache = new Map();
+function encodePnpmStoreName(pkgName) {
+    if (pkgName.startsWith('@')) {
+        const parts = pkgName.slice(1).split('/');
+        if (parts.length >= 2) {
+            return `@${parts[0]}+${parts.slice(1).join('+')}`;
+        }
+    }
+    return pkgName.replace(/\//g, '+');
+}
+async function getPnpmStoreEntries(pnpmDir) {
+    if (pnpmStoreEntriesCache.has(pnpmDir))
+        return pnpmStoreEntriesCache.get(pnpmDir);
+    try {
+        const entries = await promises_1.default.readdir(pnpmDir, { withFileTypes: true });
+        const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        pnpmStoreEntriesCache.set(pnpmDir, dirs);
+        return dirs;
+    }
+    catch {
+        pnpmStoreEntriesCache.set(pnpmDir, []);
+        return [];
+    }
+}
+async function getPnpmStoreIndex(pnpmDir) {
+    if (pnpmStoreIndexCache.has(pnpmDir))
+        return pnpmStoreIndexCache.get(pnpmDir);
+    const entries = await getPnpmStoreEntries(pnpmDir);
+    const index = new Map();
+    for (const entry of entries) {
+        const prefix = entry.split('(')[0];
+        if (!prefix)
+            continue;
+        if (!index.has(prefix))
+            index.set(prefix, []);
+        index.get(prefix).push(entry);
+    }
+    pnpmStoreIndexCache.set(pnpmDir, index);
+    return index;
+}
+async function resolvePnpmPackageJsonPath(pkgName, version, resolvePaths) {
+    if (!version || version.startsWith('link:') || version.startsWith('workspace:') || version.startsWith('file:')) {
+        return undefined;
+    }
+    const encoded = encodePnpmStoreName(pkgName);
+    const prefix = `${encoded}@${version}`;
+    for (const basePath of resolvePaths) {
+        const pnpmDir = path_1.default.join(basePath, 'node_modules', '.pnpm');
+        if (!(await pathExists(pnpmDir)))
+            continue;
+        const index = await getPnpmStoreIndex(pnpmDir);
+        const matches = index.get(prefix) || [];
+        for (const entry of matches) {
+            const candidate = path_1.default.join(pnpmDir, entry, 'node_modules', pkgName, 'package.json');
+            if (await pathExists(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+async function resolvePackageJsonPath(pkgName, resolvePaths, version) {
+    if (version) {
+        const pnpmResolved = await resolvePnpmPackageJsonPath(pkgName, version, resolvePaths);
+        if (pnpmResolved)
+            return pnpmResolved;
+    }
+    try {
+        const direct = require.resolve(path_1.default.join(pkgName, 'package.json'), { paths: resolvePaths });
+        if (direct)
+            return direct;
+    }
+    catch {
+        // fall through to entry resolution
+    }
+    let entryPath;
+    try {
+        entryPath = require.resolve(pkgName, { paths: resolvePaths });
+    }
+    catch {
+        return undefined;
+    }
+    let current = path_1.default.dirname(entryPath);
+    const root = path_1.default.parse(current).root;
+    while (true) {
+        const candidate = path_1.default.join(current, 'package.json');
+        if (await pathExists(candidate))
+            return candidate;
+        const parent = path_1.default.dirname(current);
+        if (parent === current || parent === root)
+            break;
+        current = parent;
+    }
+    return undefined;
+}
+async function readLicenseFromPackageJson(pkgName, resolvePaths, version) {
+    try {
+        const pkgJsonPath = await resolvePackageJsonPath(pkgName, resolvePaths, version);
+        if (!pkgJsonPath)
+            return undefined;
+        return await readLicenseFromPackageDir(path_1.default.dirname(pkgJsonPath));
+    }
+    catch (err) {
+        return undefined;
+    }
 }
-async function readLicenseFromPackageJson(pkgName, projectPath) {
+async function readLicenseFromPackageDir(packageDir) {
     try {
-        const pkgJsonPath = require.resolve(path_1.default.join(pkgName, 'package.json'), { paths: [projectPath] });
-        const pkgRaw = await promises_1.default.readFile(pkgJsonPath, 'utf8');
+        const pkgPath = path_1.default.join(packageDir, 'package.json');
+        const pkgRaw = await promises_1.default.readFile(pkgPath, 'utf8');
         const pkg = JSON.parse(pkgRaw);
         const license = pkg.license || (Array.isArray(pkg.licenses) ? pkg.licenses.map((l) => (typeof l === 'string' ? l : l === null || l === void 0 ? void 0 : l.type)).filter(Boolean).join(' OR ') : undefined);
-        const licenseFile = await findLicenseFile(path_1.default.dirname(pkgJsonPath));
+        const licenseFile = await findLicenseFile(packageDir);
         if (!license && !licenseFile)
             return undefined;
-        return { license, licenseFile };
+        let licenseText;
+        if (licenseFile) {
+            try {
+                licenseText = await promises_1.default.readFile(licenseFile, 'utf8');
+            }
+            catch {
+                licenseText = undefined;
+            }
+        }
+        return { license, licenseFile, licenseText };
     }
-    catch (err) {
+    catch {
         return undefined;
     }
 }
@@ -162,3 +262,38 @@ async function findLicenseFile(dir) {
         return undefined;
     }
 }
+async function findLockDir(startPath, lockFiles) {
+    let current = startPath;
+    while (true) {
+        for (const file of lockFiles) {
+            if (await pathExists(path_1.default.join(current, file))) {
+                return current;
+            }
+        }
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return undefined;
+}
+function parseJsonOutput(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        const parsed = [];
+        for (const line of lines) {
+            try {
+                parsed.push(JSON.parse(line));
+            }
+            catch {
+                // ignore non-JSON lines
+            }
+        }
+        return parsed.length > 0 ? parsed : undefined;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dependency-radar",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Local-first dependency analysis tool that generates a single HTML report showing risk, size, usage, and structure of your project's dependencies.",
   "main": "dist/index.js",
   "bin": {
@@ -11,11 +11,30 @@
   ],
   "scripts": {
     "dev:report": "cd report-ui && npx vite",
+    "build:spdx": "ts-node scripts/build-spdx.ts",
     "build:report-ui": "cd report-ui && npx vite build",
     "build:report": "npm run build:report-ui && npx ts-node scripts/build-report.ts",
-    "build": "npm run build:report && tsc",
+    "build": "npm run build:spdx && npm run build:report && tsc",
     "dev": "ts-node src/cli.ts scan",
     "scan": "node dist/cli.js scan",
+    "fixtures:install:npm": "cd test-fixtures/npm-basic && npm install",
+    "fixtures:install:npm-heavy": "cd test-fixtures/npm-heavy && npm install --force",
+    "fixtures:install:pnpm": "cd test-fixtures/pnpm-workspace && pnpm install",
+    "fixtures:install:pnpm-hoisted": "cd test-fixtures/pnpm-workspace-hoisted && pnpm install",
+    "fixtures:install:yarn": "cd test-fixtures/yarn-workspace && yarn install",
+    "fixtures:install:yarn-berry": "cd test-fixtures/yarn-berry-workspace && yarn install",
+    "fixtures:install:optional": "cd test-fixtures/optional-deps && npm install",
+    "fixtures:scan:npm": "npm run dev -- --project test-fixtures/npm-basic --out test-fixtures/npm-basic/dependency-radar.html --json --keep-temp",
+    "fixtures:scan:npm-heavy": "npm run dev -- --project test-fixtures/npm-heavy --out test-fixtures/npm-heavy/dependency-radar.html --json --keep-temp",
+    "fixtures:scan:pnpm": "npm run dev -- --project test-fixtures/pnpm-workspace --out test-fixtures/pnpm-workspace/dependency-radar.html --json --keep-temp",
+    "fixtures:scan:pnpm-hoisted": "npm run dev -- --project test-fixtures/pnpm-workspace-hoisted --out test-fixtures/pnpm-workspace-hoisted/dependency-radar.html --json --keep-temp",
+    "fixtures:scan:yarn": "npm run dev -- --project test-fixtures/yarn-workspace --out test-fixtures/yarn-workspace/dependency-radar.html --json --keep-temp",
+    "fixtures:scan:yarn-berry": "npm run dev -- --project test-fixtures/yarn-berry-workspace --out test-fixtures/yarn-berry-workspace/dependency-radar.html --json --keep-temp",
+    "fixtures:scan:optional": "npm run dev -- --project test-fixtures/optional-deps --out test-fixtures/optional-deps/dependency-radar.html --json --keep-temp",
+    "fixtures:scan:no-node-modules": "npm run dev -- --project test-fixtures/no-node-modules --out test-fixtures/no-node-modules/dependency-radar.html --json --keep-temp",
+    "fixtures:install": "npm run fixtures:install:npm && npm run fixtures:install:npm-heavy && npm run fixtures:install:pnpm && npm run fixtures:install:yarn",
+    "fixtures:scan": "npm run fixtures:scan:npm && npm run fixtures:scan:npm-heavy && npm run fixtures:scan:pnpm && npm run fixtures:scan:pnpm-hoisted && npm run fixtures:scan:yarn && npm run fixtures:scan:yarn-berry && npm run fixtures:scan:optional",
+    "fixtures:install:all": "npm run fixtures:install:npm && npm run fixtures:install:npm-heavy && npm run fixtures:install:pnpm && npm run fixtures:install:pnpm-hoisted && npm run fixtures:install:yarn && npm run fixtures:install:yarn-berry && npm run fixtures:install:optional",
     "prepublishOnly": "npm run build",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -52,5 +71,6 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.4.3",
     "vite": "^5.4.0"
-  }
+  },
+  "packageManager": "pnpm@9.5.0+sha512.140036830124618d624a2187b50d04289d5a087f326c9edfc0ccd733d76c4f52c3a313d4fc148794a2a9d81553016004e6742e8cf850670268a7387fc220c903"
 }