pruneguard 0.1.0

package/dist/bin.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { n as binaryPath, t as PruneguardExecutionError } from "./runtime-BxlGT_W-.mjs";
+import { spawn } from "node:child_process";
+//#region src-js/bin.ts
+try {
+	const child = spawn(binaryPath({ allowPathFallback: true }), process.argv.slice(2), { stdio: "inherit" });
+	for (const sig of [
+		"SIGINT",
+		"SIGTERM",
+		"SIGHUP"
+	]) process.on(sig, () => child.kill(sig));
+	child.on("close", (code, signal) => {
+		if (signal) process.kill(process.pid, signal);
+		else process.exitCode = code ?? 1;
+	});
+} catch (err) {
+	console.error(err instanceof PruneguardExecutionError ? err.message : String(err));
+	process.exitCode = 2;
+}
+//#endregion
+export {};

package/dist/index.d.mts

@@ -0,0 +1,228 @@
+//#region src-js/runtime.d.ts
+type CommandResult = {
+  args: string[];
+  cwd?: string;
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  durationMs: number;
+};
+declare class PruneguardExecutionError extends Error {
+  code: "PRUNEGUARD_BINARY_NOT_FOUND" | "PRUNEGUARD_EXECUTION_FAILED" | "PRUNEGUARD_JSON_PARSE_FAILED";
+  exitCode?: number;
+  stdout?: string;
+  stderr?: string;
+  binaryPath?: string;
+  args?: string[];
+  constructor(code: PruneguardExecutionError["code"], message: string, details?: {
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    binaryPath?: string;
+    args?: string[];
+  });
+}
+//#endregion
+//#region src-js/index.d.ts
+type Profile = "production" | "development" | "all";
+type ScanOptions = {
+  cwd?: string;
+  config?: string;
+  paths?: string[];
+  profile?: Profile;
+  changedSince?: string;
+  focus?: string;
+  noCache?: boolean;
+  noBaseline?: boolean;
+  requireFullScope?: boolean;
+};
+type ImpactOptions = {
+  cwd?: string;
+  config?: string;
+  target: string;
+  profile?: Profile;
+  focus?: string;
+};
+type ExplainOptions = {
+  cwd?: string;
+  config?: string;
+  query: string;
+  profile?: Profile;
+  focus?: string;
+};
+type DebugResolveOptions = {
+  cwd?: string;
+  config?: string;
+  specifier: string;
+  from: string;
+};
+type DebugEntrypointsOptions = {
+  cwd?: string;
+  config?: string;
+  profile?: Profile;
+};
+type AnalysisReport = {
+  version: number;
+  toolVersion: string;
+  cwd: string;
+  profile: string;
+  summary: {
+    totalFiles: number;
+    totalPackages: number;
+    totalWorkspaces: number;
+    totalExports: number;
+    totalFindings: number;
+    errors: number;
+    warnings: number;
+    infos: number;
+  };
+  inventories: {
+    files: Array<{
+      path: string;
+      workspace?: string;
+      kind: string;
+      role?: "source" | "test" | "story" | "fixture" | "example" | "template" | "benchmark" | "config" | "generated" | "buildOutput";
+    }>;
+    packages: Array<{
+      name: string;
+      version?: string;
+      workspace: string;
+      path: string;
+    }>;
+    workspaces: Array<{
+      name: string;
+      path: string;
+      packageCount: number;
+    }>;
+  };
+  findings: Array<{
+    id: string;
+    code: string;
+    severity: "error" | "warn" | "info";
+    confidence: "high" | "medium" | "low";
+    category: string;
+    subject: string;
+    workspace?: string;
+    package?: string;
+    message: string;
+    evidence: Array<{
+      kind: string;
+      file?: string;
+      line?: number;
+      description: string;
+    }>;
+    suggestion?: string;
+    ruleName?: string;
+  }>;
+  entrypoints: Array<{
+    path: string;
+    kind: string;
+    profile: string;
+    workspace?: string;
+    source: string;
+  }>;
+  stats: {
+    durationMs: number;
+    filesParsed: number;
+    filesCached: number;
+    filesDiscovered: number;
+    filesResolved: number;
+    unresolvedSpecifiers: number;
+    unresolvedByReason: {
+      missingFile: number;
+      unsupportedSpecifier: number;
+      tsconfigPathMiss: number;
+      exportsConditionMiss: number;
+      externalized: number;
+    };
+    resolvedViaExports: number;
+    entrypointsDetected: number;
+    graphNodes: number;
+    graphEdges: number;
+    changedFiles: number;
+    affectedFiles: number;
+    affectedPackages: number;
+    affectedEntrypoints: number;
+    baselineApplied: boolean;
+    baselineProfileMismatch: boolean;
+    suppressedFindings: number;
+    newFindings: number;
+    focusApplied: boolean;
+    focusedFiles: number;
+    focusedFindings: number;
+    fullScopeRequired: boolean;
+    partialScope: boolean;
+    partialScopeReason?: string;
+    confidenceCounts: {
+      high: number;
+      medium: number;
+      low: number;
+    };
+    parityWarnings: string[];
+    cacheHits: number;
+    cacheMisses: number;
+    cacheEntriesRead: number;
+    cacheEntriesWritten: number;
+    affectedScopeIncomplete: boolean;
+  };
+};
+type MigrationOutput = {
+  source: string;
+  config: PruneguardConfig;
+  warnings: string[];
+};
+type ImpactReport = {
+  target: string;
+  affectedEntrypoints: string[];
+  affectedPackages: string[];
+  affectedFiles: string[];
+  evidence: Array<{
+    kind: string;
+    file?: string;
+    line?: number;
+    description: string;
+  }>;
+  focusFiltered: boolean;
+};
+type ExplainReport = {
+  query: string;
+  matchedNode?: string;
+  queryKind: "finding" | "file" | "export";
+  proofs: Array<{
+    node: string;
+    relationship: string;
+    children: ExplainReport["proofs"];
+  }>;
+  relatedFindings: AnalysisReport["findings"];
+  focusFiltered: boolean;
+};
+type PruneguardConfig = Record<string, unknown>;
+declare function scan(options?: ScanOptions): Promise<AnalysisReport>;
+/** @experimental */
+declare function scanDot(options?: ScanOptions): Promise<string>;
+declare function impact(options: ImpactOptions): Promise<ImpactReport>;
+declare function explain(options: ExplainOptions): Promise<ExplainReport>;
+declare function loadConfig(options?: {
+  cwd?: string;
+  config?: string;
+}): Promise<PruneguardConfig>;
+declare function schemaPath(): string;
+declare function binaryPath(): string;
+declare function run(args: string[], options?: {
+  cwd?: string;
+}): Promise<CommandResult>;
+declare function debugResolve(options: DebugResolveOptions): Promise<string>;
+declare function debugEntrypoints(options?: DebugEntrypointsOptions): Promise<string[]>;
+/** @experimental */
+declare function migrateKnip(options?: {
+  cwd?: string;
+  file?: string;
+}): Promise<MigrationOutput>;
+/** @experimental */
+declare function migrateDepcruise(options?: {
+  cwd?: string;
+  file?: string;
+  node?: boolean;
+}): Promise<MigrationOutput>;
+//#endregion
+export { AnalysisReport, type CommandResult, DebugEntrypointsOptions, DebugResolveOptions, ExplainOptions, ExplainReport, ImpactOptions, ImpactReport, MigrationOutput, Profile, PruneguardConfig, PruneguardExecutionError, ScanOptions, binaryPath, debugEntrypoints, debugResolve, explain, impact, loadConfig, migrateDepcruise, migrateKnip, run, scan, scanDot, schemaPath };

package/dist/index.mjs

@@ -0,0 +1,144 @@
+import { n as binaryPath$1, r as run$1, t as PruneguardExecutionError } from "./runtime-BxlGT_W-.mjs";
+import { fileURLToPath } from "node:url";
+//#region src-js/index.ts
+function parseJson(result) {
+	try {
+		return JSON.parse(result.stdout);
+	} catch {
+		throw new PruneguardExecutionError("PRUNEGUARD_JSON_PARSE_FAILED", `Failed to parse pruneguard JSON output: ${result.stderr || result.stdout.slice(0, 200)}`, {
+			exitCode: result.exitCode,
+			stdout: result.stdout,
+			stderr: result.stderr,
+			args: result.args
+		});
+	}
+}
+function requireSuccess(result) {
+	if (result.exitCode !== 0) throw new PruneguardExecutionError("PRUNEGUARD_EXECUTION_FAILED", `pruneguard exited with code ${result.exitCode}: ${result.stderr}`, {
+		exitCode: result.exitCode,
+		stdout: result.stdout,
+		stderr: result.stderr,
+		args: result.args
+	});
+}
+function pushGlobalFlags(args, options) {
+	if (options.config) args.push("--config", options.config);
+	if (options.profile) args.push("--profile", options.profile);
+	if (options.focus) args.push("--focus", options.focus);
+}
+async function scan(options = {}) {
+	const args = [
+		"--format",
+		"json",
+		"--severity",
+		"info"
+	];
+	pushGlobalFlags(args, options);
+	if (options.changedSince) args.push("--changed-since", options.changedSince);
+	if (options.noCache) args.push("--no-cache");
+	if (options.noBaseline) args.push("--no-baseline");
+	if (options.requireFullScope) args.push("--require-full-scope");
+	args.push("scan");
+	if (options.paths?.length) args.push(...options.paths);
+	const result = await run$1(args, { cwd: options.cwd });
+	if (result.exitCode !== 0 && result.exitCode !== 1) requireSuccess(result);
+	return parseJson(result);
+}
+/** @experimental */
+async function scanDot(options = {}) {
+	const args = [
+		"--format",
+		"dot",
+		"--severity",
+		"info"
+	];
+	pushGlobalFlags(args, options);
+	if (options.changedSince) args.push("--changed-since", options.changedSince);
+	if (options.noCache) args.push("--no-cache");
+	if (options.noBaseline) args.push("--no-baseline");
+	if (options.requireFullScope) args.push("--require-full-scope");
+	args.push("scan");
+	if (options.paths?.length) args.push(...options.paths);
+	const result = await run$1(args, { cwd: options.cwd });
+	if (result.exitCode !== 0 && result.exitCode !== 1) requireSuccess(result);
+	return result.stdout;
+}
+async function impact(options) {
+	const args = ["--format", "json"];
+	pushGlobalFlags(args, options);
+	args.push("impact", options.target);
+	const result = await run$1(args, { cwd: options.cwd });
+	requireSuccess(result);
+	return parseJson(result);
+}
+async function explain(options) {
+	const args = ["--format", "json"];
+	pushGlobalFlags(args, options);
+	args.push("explain", options.query);
+	const result = await run$1(args, { cwd: options.cwd });
+	requireSuccess(result);
+	return parseJson(result);
+}
+async function loadConfig(options) {
+	const args = [];
+	if (options?.config) args.push("--config", options.config);
+	args.push("print-config");
+	const result = await run$1(args, { cwd: options?.cwd });
+	requireSuccess(result);
+	return parseJson(result);
+}
+function schemaPath() {
+	return fileURLToPath(new URL("../configuration_schema.json", import.meta.url));
+}
+function binaryPath() {
+	return binaryPath$1();
+}
+function run(args, options) {
+	return run$1(args, options);
+}
+async function debugResolve(options) {
+	const args = [];
+	if (options.config) args.push("--config", options.config);
+	args.push("debug", "resolve", "--from", options.from, options.specifier);
+	const result = await run$1(args, { cwd: options.cwd });
+	requireSuccess(result);
+	return result.stdout.trimEnd();
+}
+async function debugEntrypoints(options = {}) {
+	const args = [];
+	if (options.config) args.push("--config", options.config);
+	if (options.profile) args.push("--profile", options.profile);
+	args.push("debug", "entrypoints");
+	const result = await run$1(args, { cwd: options.cwd });
+	requireSuccess(result);
+	return result.stdout.trimEnd().split("\n").filter(Boolean);
+}
+/** @experimental */
+async function migrateKnip(options = {}) {
+	const args = [
+		"--format",
+		"json",
+		"migrate",
+		"knip"
+	];
+	if (options.file) args.push(options.file);
+	const result = await run$1(args, { cwd: options.cwd });
+	requireSuccess(result);
+	return parseJson(result);
+}
+/** @experimental */
+async function migrateDepcruise(options = {}) {
+	const args = [
+		"--format",
+		"json",
+		"migrate",
+		"depcruise"
+	];
+	if (options.node) args.push("--node");
+	if (options.file) args.push(options.file);
+	const result = await run$1(args, { cwd: options.cwd });
+	requireSuccess(result);
+	return parseJson(result);
+}
+//#endregion
+export { PruneguardExecutionError, binaryPath, debugEntrypoints, debugResolve, explain, impact, loadConfig, migrateDepcruise, migrateKnip, run, scan, scanDot, schemaPath };

package/dist/runtime-BxlGT_W-.mjs

@@ -0,0 +1,132 @@
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src-js/runtime.ts
+const require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+var PruneguardExecutionError = class extends Error {
+	code;
+	exitCode;
+	stdout;
+	stderr;
+	binaryPath;
+	args;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "PruneguardExecutionError";
+		this.code = code;
+		this.exitCode = details?.exitCode;
+		this.stdout = details?.stdout;
+		this.stderr = details?.stderr;
+		this.binaryPath = details?.binaryPath;
+		this.args = details?.args;
+	}
+};
+const PLATFORM_PACKAGES = {
+	"darwin-arm64": ["@pruneguard/cli-darwin-arm64"],
+	"darwin-x64": ["@pruneguard/cli-darwin-x64"],
+	"linux-arm64": ["@pruneguard/cli-linux-arm64-gnu", "@pruneguard/cli-linux-arm64-musl"],
+	"linux-x64": ["@pruneguard/cli-linux-x64-gnu", "@pruneguard/cli-linux-x64-musl"],
+	"win32-arm64": ["@pruneguard/cli-win32-arm64-msvc"],
+	"win32-x64": ["@pruneguard/cli-win32-x64-msvc"]
+};
+function exeName() {
+	return process.platform === "win32" ? "pruneguard.exe" : "pruneguard";
+}
+function findPlatformBinary() {
+	const candidates = PLATFORM_PACKAGES[`${process.platform}-${process.arch === "arm64" ? "arm64" : "x64"}`];
+	if (!candidates) return void 0;
+	for (const pkg of candidates) try {
+		const binPath = join(dirname(require.resolve(`${pkg}/package.json`)), "bin", exeName());
+		if (existsSync(binPath)) return binPath;
+	} catch {
+		continue;
+	}
+}
+function findDevBinary() {
+	const candidates = [join(__dirname, "..", "..", "..", "target", "release", exeName()), join(__dirname, "..", "..", "..", "target", "debug", exeName())];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+}
+function findPathBinary() {
+	try {
+		const binPath = execFileSync(process.platform === "win32" ? "where" : "which", [exeName()], {
+			encoding: "utf8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim().split("\n")[0];
+		if (binPath) return binPath;
+	} catch {}
+}
+let cachedBinaryPath;
+function binaryPath(options) {
+	if (cachedBinaryPath) return cachedBinaryPath;
+	const envPath = process.env.PRUNEGUARD_BINARY;
+	if (envPath) {
+		if (!existsSync(envPath)) throw new PruneguardExecutionError("PRUNEGUARD_BINARY_NOT_FOUND", `PRUNEGUARD_BINARY points to ${envPath} but the file does not exist`, { binaryPath: envPath });
+		cachedBinaryPath = envPath;
+		return envPath;
+	}
+	const platformBin = findPlatformBinary();
+	if (platformBin) {
+		cachedBinaryPath = platformBin;
+		return platformBin;
+	}
+	const devBin = findDevBinary();
+	if (devBin) {
+		cachedBinaryPath = devBin;
+		return devBin;
+	}
+	if (options?.allowPathFallback) {
+		const pathBin = findPathBinary();
+		if (pathBin) {
+			cachedBinaryPath = pathBin;
+			return pathBin;
+		}
+	}
+	throw new PruneguardExecutionError("PRUNEGUARD_BINARY_NOT_FOUND", "Could not find the pruneguard binary. Install a platform-specific package or set PRUNEGUARD_BINARY.");
+}
+function run(args, options) {
+	const binary = binaryPath();
+	const start = performance.now();
+	return new Promise((resolve, reject) => {
+		const child = spawn(binary, args, {
+			cwd: options?.cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.on("error", (err) => {
+			reject(new PruneguardExecutionError("PRUNEGUARD_EXECUTION_FAILED", `Failed to spawn pruneguard: ${err.message}`, {
+				binaryPath: binary,
+				args
+			}));
+		});
+		child.on("close", (exitCode) => {
+			resolve({
+				args,
+				cwd: options?.cwd,
+				exitCode: exitCode ?? 1,
+				stdout,
+				stderr,
+				durationMs: Math.round(performance.now() - start)
+			});
+		});
+	});
+}
+//#endregion
+export { binaryPath as n, run as r, PruneguardExecutionError as t };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "pruneguard",
+  "version": "0.1.0",
+  "description": "Repo truth engine for JS/TS monorepos",
+  "keywords": [
+    "javascript",
+    "typescript",
+    "monorepo",
+    "graph",
+    "unused-code",
+    "dead-code",
+    "dependency-graph",
+    "architecture"
+  ],
+  "homepage": "https://github.com/user/pruneguard",
+  "bugs": "https://github.com/user/pruneguard/issues",
+  "license": "MIT",
+  "author": "pruneguard contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/user/pruneguard",
+    "directory": "npm/pruneguard"
+  },
+  "bin": {
+    "pruneguard": "bin/pruneguard"
+  },
+  "files": [
+    "configuration_schema.json",
+    "report_schema.json",
+    "dist",
+    "README.md",
+    "bin/pruneguard"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "optionalDependencies": {
+    "@pruneguard/cli-darwin-arm64": "0.1.0",
+    "@pruneguard/cli-darwin-x64": "0.1.0",
+    "@pruneguard/cli-linux-arm64-gnu": "0.1.0",
+    "@pruneguard/cli-linux-arm64-musl": "0.1.0",
+    "@pruneguard/cli-linux-x64-gnu": "0.1.0",
+    "@pruneguard/cli-linux-x64-musl": "0.1.0",
+    "@pruneguard/cli-win32-arm64-msvc": "0.1.0",
+    "@pruneguard/cli-win32-x64-msvc": "0.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "preferUnplugged": true
+}