@callidescope/nx 0.0.1

package/dist/plugin-context.utilities-bBTXF3Wk.js

@@ -0,0 +1,815 @@
+import "reflect-metadata";
+import { NestFactory as e } from "@nestjs/core";
+import { ConsoleLogger as t, Global as n, Injectable as r, Module as i, Scope as a } from "@nestjs/common";
+import { existsSync as o, mkdirSync as s, readFileSync as c } from "node:fs";
+import l from "node:path";
+import u from "pino";
+import { AddressLookupModule as ee, AddressLookupService as d, CallidescopeModule as te, CallidescopeService as f } from "@callidescope/cli";
+import { AddressDepthService as p, BreadthService as m, FileFilterService as h, GraphModule as g, WorkspaceModule as ne } from "@callidescope/graph";
+import { AddressReportModule as _, AddressReportService as v, MarkdownReportService as y, ProjectReportsModule as b, ProjectReportsService as x, ReportModule as re } from "@callidescope/output";
+import { CALLIDESCOPE_OUTPUT_FORMATS as ie, ConfigurationModule as S, ConfigurationService as C, DEFAULT_OUTPUT_FORMAT as w, DEFAULT_PREVIEW_COUNT as T, DEFAULT_RUN_HEADING as ae } from "@callidescope/configuration";
+import { createProjectGraphAsync as oe } from "@nx/devkit";
+//#region packages/logger/src/modules/logger/logger.constants.ts
+var se = /^(\p{Extended_Pictographic}️?(?:‍\p{Extended_Pictographic}️?)*)\s+/u, E = /^([A-Za-z]+)/, D = /* @__PURE__ */ new Set([
+	"built",
+	"cut",
+	"found",
+	"got",
+	"kept",
+	"left",
+	"lost",
+	"made",
+	"put",
+	"ran",
+	"read",
+	"rebuilt",
+	"sent",
+	"set",
+	"split",
+	"took",
+	"wrote"
+]), O = /* @__PURE__ */ new Set([
+	"CommandFactory",
+	"ExceptionHandler",
+	"GraphQLModule",
+	"InstanceLoader",
+	"NestApplication",
+	"NestFactory",
+	"RouterExplorer",
+	"RoutesResolver",
+	"TypeOrmModule"
+]);
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+function k(e, t) {
+	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
+function A(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
+}
+//#endregion
+//#region packages/logger/src/modules/logger/logger.service.ts
+var j, M = class extends t {
+	static {
+		j = this;
+	}
+	constructor() {
+		super();
+	}
+	static isProduction = process.env.NODE_ENV === "production";
+	static rootLogger;
+	static writesToStandardError = !1;
+	child = j.root;
+	static createRootLogger() {
+		let e = process.env.LOG_LEVEL ?? "info";
+		return j.isProduction ? j.writesToStandardError ? u({ level: e }, u.destination(2)) : u({ level: e }) : u({
+			level: e,
+			transport: {
+				options: {
+					colorize: !0,
+					destination: j.writesToStandardError ? 2 : 1,
+					ignore: "pid,hostname,emoji",
+					messageFormat: "{emoji} {msg}",
+					singleLine: !0
+				},
+				target: "pino-pretty"
+			}
+		});
+	}
+	static logToStandardError() {
+		if (j.rootLogger !== void 0) {
+			process.emitWarning("LoggerService.logToStandardError() was called after the first log line, so log lines still go to standard output and anything piping that stream will read them as data. Call it as the first statement of the application's bootstrap.");
+			return;
+		}
+		j.writesToStandardError = !0;
+	}
+	assertConventionalMessage(e) {
+		if (j.isProduction || this.shouldSkipConventionalMessageValidation(e.context)) return;
+		let t = this.getConventionalMessageViolation(e.parsed);
+		if (t !== void 0) throw Error(t);
+	}
+	buildBindings(e) {
+		return this.assertConventionalMessage({
+			context: e.context,
+			parsed: e.parsed
+		}), {
+			...e.data,
+			context: e.context,
+			...j.isProduction ? {} : { emoji: e.parsed.emoji }
+		};
+	}
+	getConventionalMessageViolation(e) {
+		let t = e.emoji, n = e.text;
+		if (t === void 0) return `Log message must start with an emoji naming its subject, then a verb: "${n}"`;
+		let r = E.exec(n)?.[1];
+		if (r === void 0 || !this.isConventionalVerb(r)) return `Log message must begin with a verb in present progressive or past tense, got "${r ?? ""}": "${t} ${n}"`;
+	}
+	isConventionalVerb(e) {
+		let t = e.toLowerCase();
+		return t.endsWith("ing") || t.endsWith("ed") || D.has(t);
+	}
+	parseMessage(e) {
+		let t = String(e), n = se.exec(t), r = n?.[1];
+		return r === void 0 ? {
+			emoji: void 0,
+			text: t
+		} : {
+			emoji: r,
+			text: t.slice(n?.[0].length)
+		};
+	}
+	shouldSkipConventionalMessageValidation(e) {
+		return e !== void 0 && O.has(e);
+	}
+	static get root() {
+		return j.rootLogger ??= j.createRootLogger(), j.rootLogger;
+	}
+	buildErrorLogEntry(e, t) {
+		let n = t instanceof Error ? t.stack || t.message : String(t);
+		return {
+			errorMessage: n,
+			logLine: `[${(/* @__PURE__ */ new Date()).toISOString()}] ${e}: ${n}\n`
+		};
+	}
+	createTimestampedOutputLogFilePath(e) {
+		let t = l.join(process.cwd(), "output");
+		return o(t) || s(t, { recursive: !0 }), l.join(t, `${e}-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-")}.log`);
+	}
+	debug(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.debug(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	error(e, t, n) {
+		let r = this.parseMessage(e), i = typeof n == "object" ? n : void 0, a = typeof n == "string" ? n : this.context;
+		this.child.error({
+			...this.buildBindings({
+				context: a,
+				data: i,
+				parsed: r
+			}),
+			stack: t
+		}, r.text);
+	}
+	info(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.info(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	log(e, t, n) {
+		this.info(e, t, n);
+	}
+	setContext(e) {
+		super.setContext(e), this.child = j.root.child({ context: e });
+	}
+	verbose(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.trace(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	warn(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.warn(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+};
+M = j = A([r({ scope: a.TRANSIENT }), k("design:paramtypes", [])], M);
+//#endregion
+//#region packages/logger/src/modules/logger/logger.module.ts
+var N = class {};
+N = A([n(), i({
+	controllers: [],
+	exports: [M],
+	imports: [],
+	providers: [M]
+})], N);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/address/address.service.ts
+var P = class {
+	addressLookupService;
+	addressReportService;
+	addressDepthService;
+	breadthService;
+	constructor(e, t, n, r) {
+		this.addressLookupService = e, this.addressReportService = t, this.addressDepthService = n, this.breadthService = r;
+	}
+	identify(e) {
+		let t = this.addressLookupService.resolve(e), n = this.addressLookupService.describeProblem({
+			address: e.address,
+			resolution: t
+		});
+		return n !== void 0 || t.kind !== "resolved" ? { problem: n ?? `"${e.address}" resolved to nothing.` } : { id: t.id };
+	}
+	async locate(e) {
+		let t = await this.addressLookupService.locate({
+			...e.configurationPath === void 0 ? {} : { config: e.configurationPath },
+			directories: [...e.directories],
+			...e.format === void 0 ? {} : { format: e.format }
+		}), n = [], r = [];
+		for (let i of e.addresses) {
+			let e = this.identify({
+				address: i,
+				workspace: t
+			});
+			if ("problem" in e) {
+				r.push(e.problem);
+				continue;
+			}
+			n.push({
+				address: i,
+				id: e.id
+			});
+		}
+		return r.length > 0 ? r.join("\n") : {
+			identified: n,
+			workspace: t
+		};
+	}
+	async runBreadth(e) {
+		let t = await this.locate(e);
+		if (typeof t == "string") return {
+			ok: !1,
+			report: t
+		};
+		let { identified: n, workspace: r } = t, { located: i } = r, a = [];
+		for (let { address: e, id: t } of n) {
+			let n = i.callablesById.get(t);
+			if (n === void 0) return {
+				ok: !1,
+				report: `"${e}" resolved to a callable that was not traced.`
+			};
+			a.push({
+				address: e,
+				directCalls: this.breadthService.describeDirectCalls({
+					callablesById: i.callablesById,
+					graph: i.graph,
+					id: t
+				}),
+				displayName: n.node.displayName,
+				id: t,
+				location: n.node.location
+			});
+		}
+		return {
+			ok: !0,
+			report: this.addressReportService.renderBreadthReports({
+				format: e.format ?? w,
+				reports: a
+			})
+		};
+	}
+	async runDepth(e) {
+		let t = await this.locate(e);
+		if (typeof t == "string") return {
+			ok: !1,
+			report: t
+		};
+		let { identified: n, workspace: r } = t;
+		return {
+			ok: !0,
+			report: this.addressReportService.renderDepthReports({
+				format: e.format ?? w,
+				reports: n.map(({ address: e, id: t }) => {
+					let n = {
+						callablesById: r.located.callablesById,
+						graph: r.located.graph,
+						startId: t
+					};
+					return {
+						address: e,
+						downward: this.addressDepthService.buildDownwardStacks(n),
+						upward: this.addressDepthService.buildUpwardStacks(n)
+					};
+				})
+			})
+		};
+	}
+};
+P = A([r(), k("design:paramtypes", [
+	d === void 0 ? Object : d,
+	v === void 0 ? Object : v,
+	p === void 0 ? Object : p,
+	m === void 0 ? Object : m
+])], P);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/address/address.module.ts
+var F = class {};
+F = A([i({
+	controllers: [],
+	exports: [P],
+	imports: [
+		ee,
+		_,
+		g
+	],
+	providers: [P]
+})], F);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/options/options.constants.ts
+var I = "@callidescope/nx", L = "trace", R = "depth", z = "breadth", B = "gate", V = ["callidescope.config.ts", "configuration/callidescope.config.ts"], H = "tsconfig.json", U = class {
+	constructor() {}
+	isUnknownArray(e) {
+		return Array.isArray(e);
+	}
+	readEntryConfigurationPath(e) {
+		if (typeof e != "object" || !e) return;
+		let { options: t, plugin: n } = { ...e };
+		if (n === "@callidescope/nx" && typeof t == "object" && t) return this.readString({
+			key: "configurationPath",
+			options: { ...t }
+		});
+	}
+	readRegisteredConfigurationPath(e) {
+		if (typeof e != "object" || !e) return;
+		let { plugins: t } = { ...e };
+		if (this.isUnknownArray(t)) for (let e of t) {
+			let t = this.readEntryConfigurationPath(e);
+			if (t !== void 0) return t;
+		}
+	}
+	readString(e) {
+		let t = e.options[e.key];
+		return typeof t == "string" && t !== "" ? t : void 0;
+	}
+	readFormat(e) {
+		return ie.find((t) => t === e);
+	}
+	readStringList(e) {
+		return this.isUnknownArray(e) ? e.filter((e) => typeof e == "string").flatMap((e) => e.split(",")).map((e) => e.trim()).filter((e) => e !== "") : typeof e == "string" ? this.readStringList([e]) : [];
+	}
+	resolveConfigurationPath(e) {
+		return this.readRegisteredConfigurationPath(e.nxConfiguration) ?? V.find((t) => e.exists(t)) ?? V[0];
+	}
+	resolvePluginOptions(e) {
+		let t = typeof e == "object" && e ? { ...e } : {};
+		return {
+			breadthTargetName: this.readString({
+				key: "breadthTargetName",
+				options: t
+			}) ?? "breadth",
+			configurationPath: this.readString({
+				key: "configurationPath",
+				options: t
+			}) ?? V[0],
+			depthTargetName: this.readString({
+				key: "depthTargetName",
+				options: t
+			}) ?? "depth",
+			gateTargetName: this.readString({
+				key: "gateTargetName",
+				options: t
+			}) ?? "gate",
+			traceTargetName: this.readString({
+				key: "traceTargetName",
+				options: t
+			}) ?? "trace"
+		};
+	}
+};
+U = A([r(), k("design:paramtypes", [])], U);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/options/options.module.ts
+var W = class {};
+W = A([i({
+	controllers: [],
+	exports: [U],
+	imports: [],
+	providers: [U]
+})], W);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/projects/projects.service.ts
+var G = class {
+	constructor() {}
+	readTags(e) {
+		return [...new Set(e.flatMap((e) => e.tags))].toSorted((e, t) => e.localeCompare(t));
+	}
+	resolveTaggedNames(e) {
+		let t = [], n = [];
+		for (let r of e.tags) {
+			let i = e.projects.filter((e) => e.tags.includes(r));
+			if (i.length === 0) {
+				n.push(r);
+				continue;
+			}
+			t.push(...i.map((e) => e.name));
+		}
+		return {
+			names: t,
+			unmatchedTags: n
+		};
+	}
+	async readProjectGraph() {
+		return oe({ exitOnError: !1 });
+	}
+	readProjects(e) {
+		return Object.entries(e.nodes).map(([e, t]) => ({
+			name: e,
+			root: t.data.root,
+			tags: t.data.tags ?? []
+		})).toSorted((e, t) => e.name.localeCompare(t.name));
+	}
+	resolveDependencyClosure(e) {
+		let t = new Set(Object.keys(e.graph.nodes)), n = /* @__PURE__ */ new Set(), r = e.projectNames.filter((e) => t.has(e));
+		for (; r.length > 0;) {
+			let i = [];
+			for (let a of r) if (!n.has(a)) {
+				n.add(a);
+				for (let n of e.graph.dependencies[a] ?? []) t.has(n.target) && i.push(n.target);
+			}
+			r = i;
+		}
+		return [...n].toSorted((e, t) => e.localeCompare(t));
+	}
+	resolveDirectories(e) {
+		let t = this.resolveProjectNames(e);
+		return {
+			...t,
+			directories: this.toDirectories({
+				graph: e.graph,
+				projectNames: t.projectNames
+			})
+		};
+	}
+	resolveProjectNames(e) {
+		let t = this.readProjects(e.graph), n = new Set(t.map((e) => e.name)), r = /* @__PURE__ */ new Set(), i = [];
+		for (let t of e.projectNames ?? []) {
+			if (n.has(t)) {
+				r.add(t);
+				continue;
+			}
+			i.push(t);
+		}
+		let a = this.resolveTaggedNames({
+			projects: t,
+			tags: e.tags ?? []
+		});
+		for (let e of a.names) r.add(e);
+		return {
+			knownNames: t.map((e) => e.name),
+			knownTags: this.readTags(t),
+			projectNames: [...r].toSorted((e, t) => e.localeCompare(t)),
+			unknownNames: i,
+			unmatchedTags: a.unmatchedTags
+		};
+	}
+	toDirectories(e) {
+		let t = new Map(this.readProjects(e.graph).map((e) => [e.name, e.root])), n = /* @__PURE__ */ new Set();
+		for (let r of e.projectNames) {
+			let e = t.get(r);
+			e !== void 0 && n.add(e);
+		}
+		return [...n].toSorted((e, t) => e.localeCompare(t));
+	}
+};
+G = A([r(), k("design:paramtypes", [])], G);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/projects/projects.module.ts
+var K = class {};
+K = A([i({
+	controllers: [],
+	exports: [G],
+	imports: [],
+	providers: [G]
+})], K);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/run-configuration/run-configuration.constants.ts
+var ce = "nx.json", q = class {
+	configurationService;
+	optionsService;
+	constructor(e, t) {
+		this.configurationService = e, this.optionsService = t;
+	}
+	readNxConfiguration(e) {
+		try {
+			return JSON.parse(c(l.join(e, ce), "utf8"));
+		} catch {
+			return;
+		}
+	}
+	async load(e) {
+		let t = e.configurationPath ?? this.optionsService.resolveConfigurationPath({
+			exists: (t) => o(l.join(e.workspaceRoot, t)),
+			nxConfiguration: this.readNxConfiguration(e.workspaceRoot)
+		}), n = await this.configurationService.loadConfigurationFile({
+			configurationPath: t,
+			searchDirectory: e.workspaceRoot
+		});
+		return {
+			configuration: n.configuration,
+			path: n.path
+		};
+	}
+};
+q = A([r(), k("design:paramtypes", [C === void 0 ? Object : C, U === void 0 ? Object : U])], q);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/run-configuration/run-configuration.module.ts
+var J = class {};
+J = A([i({
+	controllers: [],
+	exports: [q],
+	imports: [S, W],
+	providers: [q]
+})], J);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/plugin/plugin.constants.ts
+var le = "**/{project.json,callidescope.config.*}", ue = "{projectRoot}/callidescope.config.*", Y = "__callidescopePluginContext", de = (e) => [
+	"## Read nothing of its own (0 files)",
+	"",
+	`This run judged ${e.length === 1 ? "a project" : "projects"} whose own code it never read:`,
+	"",
+	...e.map((e) => `- \`${e}\``),
+	"",
+	"A `gate` fails on this and a `trace` does not: a gate that never looked",
+	"cannot tell a clean project from an unread one, where a trace decides",
+	"nothing and is a report for a reader to open. The run itself was not",
+	"empty — the dependencies it traced were read — so only the judged",
+	"project's own sources went missing.",
+	"",
+	"Check `exclude` and `excludeFrom` in the workspace callidescope",
+	"configuration and `exclude` in the project's own `callidescope.config.*`",
+	"for a pattern matching everything that project holds, and check that the",
+	"project still holds sources its `tsconfig.json` includes."
+].join("\n"), fe = [
+	"## Traced nothing (0 callables)",
+	"",
+	"This gate read no code, so it judged none. It fails rather than passing:",
+	"a gate that never looked cannot tell a clean project from an unread one.",
+	"",
+	"Check `exclude` and `excludeFrom` in the workspace callidescope",
+	"configuration and in this project's own `callidescope.config.*` for a",
+	"pattern matching everything the project holds."
+].join("\n"), pe = [
+	"## Traced nothing (no directories in scope)",
+	"",
+	"This gate's Nx selection resolved to no directory, so nothing was traced",
+	"and nothing was judged. It fails rather than passing: a gate that never",
+	"looked cannot tell a clean project from an unread one.",
+	"",
+	"Check the `projects` and `tags` this target was given, and whether the",
+	"projects they name still hold a root of their own."
+].join("\n"), X = class {
+	callidescopeService;
+	configurationService;
+	fileFilterService;
+	markdownReportService;
+	optionsService;
+	projectReportsService;
+	projectsService;
+	runConfigurationService;
+	constructor(e, t, n, r, i, a, o, s) {
+		this.callidescopeService = e, this.configurationService = t, this.fileFilterService = n, this.markdownReportService = r, this.optionsService = i, this.projectReportsService = a, this.projectsService = o, this.runConfigurationService = s;
+	}
+	async buildExclusionFilter(e) {
+		try {
+			let { configuration: t } = await this.configurationService.loadConfigurationFile({
+				configurationPath: e.configurationPath,
+				searchDirectory: e.workspaceRoot
+			});
+			return this.fileFilterService.buildFileFilter({
+				exclude: t.exclude,
+				excludeFrom: t.excludeFrom,
+				workspaceRoot: e.workspaceRoot
+			});
+		} catch {
+			return { isExcluded: () => !1 };
+		}
+	}
+	buildInferredTargets(e) {
+		let { pluginOptions: t } = e, n = [
+			"default",
+			"^default",
+			`{workspaceRoot}/${t.configurationPath}`
+		], r = {
+			[t.breadthTargetName]: {
+				cache: !0,
+				executor: `${I}:breadth`,
+				inputs: n,
+				options: {}
+			},
+			[t.depthTargetName]: {
+				cache: !0,
+				executor: `${I}:depth`,
+				inputs: n,
+				options: {}
+			},
+			[t.traceTargetName]: {
+				cache: !0,
+				executor: `${I}:trace`,
+				inputs: n,
+				options: {}
+			}
+		};
+		return e.isExcluded ? r : {
+			...r,
+			[t.gateTargetName]: {
+				cache: !0,
+				executor: `${I}:gate`,
+				inputs: [...n, ue],
+				options: {}
+			}
+		};
+	}
+	explainVerdict(e) {
+		return e.unreadProjectNames.length > 0 ? de(e.unreadProjectNames) : e.reason;
+	}
+	holdsProgram(e) {
+		return o(l.join(e.workspaceRoot, e.projectRoot, H));
+	}
+	isExcludedProject(e) {
+		return e.fileFilter.isExcluded(l.posix.join(e.projectRoot, H));
+	}
+	judge(e) {
+		let t = this.projectReportsService.findOwnedFindings({
+			limits: e.projectLimits,
+			projectNames: e.judgedProjectNames,
+			reports: e.result.projects
+		}), n = this.projectReportsService.findUnreadProjects({
+			projectNames: e.judgedProjectNames,
+			reports: e.result.projects
+		});
+		return e.result.summary.callableCount === 0 ? {
+			findings: t,
+			ok: !1,
+			reason: fe,
+			unreadProjectNames: n
+		} : {
+			findings: t,
+			ok: t.deepStacks.length === 0 && t.wideCallables.length === 0,
+			reason: void 0,
+			unreadProjectNames: n
+		};
+	}
+	describeRefusedScope(e) {
+		return [e.unknownNames.length > 0 ? `Unknown Nx projects: ${e.unknownNames.join(", ")}. Known: ${e.knownNames.join(", ")}.` : void 0, e.unmatchedTags.length > 0 ? `Unmatched Nx tags: ${e.unmatchedTags.join(", ")}. Known: ${e.knownTags.join(", ")}.` : void 0].filter((e) => e !== void 0).join(" ");
+	}
+	async inferTargets(e) {
+		let t = this.optionsService.resolvePluginOptions(e.options), n = await this.buildExclusionFilter({
+			configurationPath: t.configurationPath,
+			workspaceRoot: e.workspaceRoot
+		}), r = /* @__PURE__ */ new Map();
+		for (let i of e.projectConfigurationFiles) {
+			if (l.basename(i) !== "project.json") continue;
+			let a = l.dirname(i);
+			a !== "." && this.holdsProgram({
+				projectRoot: a,
+				workspaceRoot: e.workspaceRoot
+			}) && r.set(a, this.buildInferredTargets({
+				isExcluded: this.isExcludedProject({
+					fileFilter: n,
+					projectRoot: a
+				}),
+				pluginOptions: t
+			}));
+		}
+		return r;
+	}
+	async resolveTraceScope(e) {
+		let t = await this.projectsService.readProjectGraph(), n = this.projectsService.resolveProjectNames({
+			graph: t,
+			projectNames: e.projectNames,
+			tags: e.tags
+		}), r = e.withDependencies ? this.projectsService.resolveDependencyClosure({
+			graph: t,
+			projectNames: n.projectNames
+		}) : n.projectNames;
+		return {
+			directories: this.projectsService.resolveDirectories({
+				graph: t,
+				projectNames: r
+			}).directories,
+			knownNames: n.knownNames,
+			knownTags: n.knownTags,
+			projectNames: r,
+			selectedDirectories: this.projectsService.resolveDirectories({
+				graph: t,
+				projectNames: n.projectNames
+			}).directories,
+			unknownNames: n.unknownNames,
+			unmatchedTags: n.unmatchedTags
+		};
+	}
+	async runGate(e) {
+		let { configuration: t, path: n } = await this.runConfigurationService.load(e), r = await this.callidescopeService.trace({
+			configuration: t,
+			configurationPath: n,
+			directories: e.directories,
+			workspaceRoot: e.workspaceRoot
+		}), i = this.judge({
+			judgedProjectNames: e.judgedProjectNames,
+			projectLimits: r.projectLimits,
+			result: r.result
+		});
+		return {
+			ok: i.ok && i.unreadProjectNames.length === 0,
+			report: this.explainVerdict(i) ?? this.markdownReportService.renderFindings({
+				...i.findings,
+				previewCount: T
+			})
+		};
+	}
+	async runTrace(e) {
+		let { configuration: t, path: n } = await this.runConfigurationService.load(e), r = e.format ?? w, i = await this.callidescopeService.trace({
+			configuration: t,
+			configurationPath: n,
+			directories: e.directories,
+			workspaceRoot: e.workspaceRoot
+		}), a = this.judge({
+			judgedProjectNames: e.judgedProjectNames,
+			projectLimits: i.projectLimits,
+			result: i.result
+		}), o = this.markdownReportService.renderRun({
+			description: void 0,
+			heading: ae,
+			limits: i.projectLimits,
+			previewCount: T,
+			rendering: r === "mermaid" ? "diagram" : "tree",
+			result: i.result
+		}), s = this.explainVerdict(a);
+		return {
+			ok: a.ok,
+			report: s === void 0 ? o : `${o}\n${s}`
+		};
+	}
+};
+X = A([r(), k("design:paramtypes", [
+	f === void 0 ? Object : f,
+	C === void 0 ? Object : C,
+	h === void 0 ? Object : h,
+	y === void 0 ? Object : y,
+	U === void 0 ? Object : U,
+	x === void 0 ? Object : x,
+	G === void 0 ? Object : G,
+	q === void 0 ? Object : q
+])], X);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/plugin/plugin.module.ts
+var Z = class {};
+Z = A([i({
+	controllers: [],
+	exports: [X],
+	imports: [
+		te,
+		S,
+		N,
+		W,
+		b,
+		K,
+		re,
+		J,
+		ne
+	],
+	providers: [X]
+})], Z);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/main.module.ts
+var Q = class {};
+Q = A([i({
+	controllers: [],
+	exports: [F, Z],
+	imports: [
+		F,
+		N,
+		Z
+	],
+	providers: []
+})], Q);
+//#endregion
+//#region packages/ic-suite/callidescope/callidescope-nx/src/modules/plugin/plugin-context.utilities.ts
+async function me() {
+	return (await $()).get(P);
+}
+async function he() {
+	return (await $()).get(U);
+}
+async function ge() {
+	return (await $()).get(X);
+}
+async function _e() {
+	return (await $()).get(G);
+}
+async function $() {
+	let t = globalThis;
+	return t[Y] ??= e.createApplicationContext(Q, {
+		abortOnError: !1,
+		logger: !1
+	}), await t[Y];
+}
+//#endregion
+export { B as _, Q as a, P as b, pe as c, G as d, W as f, R as g, z as h, _e as i, le as l, I as m, he as n, Z as o, U as p, ge as r, X as s, me as t, K as u, L as v, F as y };