@agimon-ai/po-config 0.0.0-alpha.0

package/dist/domains-CBYkuxs5.cjs

@@ -0,0 +1,727 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_config = require("./config-BUw5kHsx.cjs");
+const require_layeredConfig = require("./layeredConfig-DdI5ysUf.cjs");
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto, 1);
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os, 1);
+//#region src/services/pluginCatalog/index.ts
+const AGENT_PLUGIN_SCHEMA_PREFIX = "https://agent-plugins.org/schemas/";
+const CACHE_DIRECTORY = "plugin-cache";
+const PLUGIN_ID_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const NPM_PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+const LEGACY_PLUGIN_MANIFEST_PATHS = [
+	".codex-plugin/plugin.json",
+	".claude-plugin/plugin.json",
+	".cursor-plugin/plugin.json"
+];
+const MARKETPLACE_MANIFEST_RELATIVE_PATHS = [
+	".agents/plugins/marketplace.json",
+	".agents/plugins/api_marketplace.json",
+	".claude-plugin/marketplace.json",
+	".cursor-plugin/marketplace.json"
+];
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireRecord$1(value, label) {
+	if (!isRecord$1(value)) throw new Error(`${label} must be an object`);
+	return value;
+}
+function optionalString$1(value, label) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || !value.trim()) throw new Error(`${label} must be a non-empty string`);
+	return value.trim();
+}
+function requireString$1(value, label) {
+	const result = optionalString$1(value, label);
+	if (!result) throw new Error(`${label} must be a non-empty string`);
+	return result;
+}
+function assertOnlyKeys$1(record, allowed, label) {
+	const unexpected = Object.keys(record).filter((key) => !allowed.includes(key));
+	if (unexpected.length > 0) throw new Error(`${label} contains unsupported field "${unexpected[0]}"`);
+}
+function validatePluginIdSegment(value, label) {
+	if (!PLUGIN_ID_SEGMENT.test(value)) throw new Error(`${label} must start with an alphanumeric character and contain only alphanumerics, ., _, or -`);
+}
+function validatePluginId(value, label) {
+	const segments = value.split("@");
+	if (segments.length > 2 || segments.some((segment) => !PLUGIN_ID_SEGMENT.test(segment))) throw new Error(`${label} must be a plugin name or plugin@marketplace identifier`);
+}
+function normalizeRemoteSubdirectory(value, label) {
+	const raw = optionalString$1(value, label);
+	if (!raw) return void 0;
+	const normalized = raw.replaceAll("\\", "/").replace(/^\.\//, "");
+	if (normalized.startsWith("/") || normalized.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) throw new Error(`${label} must stay within the remote repository root`);
+	return normalized;
+}
+function normalizeGitUrl(value, baseDirectory, label) {
+	const url = requireString$1(value, label);
+	if (/^(?:https?|ssh|file):\/\//.test(url) || /^git@[^:]+:.+/.test(url) || node_path.default.isAbsolute(url)) return url;
+	if (url.startsWith("./") || url.startsWith(".\\")) {
+		const relative = url.replaceAll("\\", "/").slice(2);
+		if (!relative || relative.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) throw new Error(`${label} must stay within its declaring root`);
+		return node_path.default.resolve(baseDirectory, relative);
+	}
+	if (/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:\.git)?$/.test(url)) return `https://github.com/${url.endsWith(".git") ? url : `${url}.git`}`;
+	throw new Error(`${label} is not a supported Git URL`);
+}
+function resolveMarketplaceLocalPath(rawPath, marketplace, label) {
+	if (rawPath === "." || rawPath === "./") return marketplace.root;
+	const cursorMarketplace = marketplace.manifestPath.endsWith(".cursor-plugin/marketplace.json");
+	const relative = rawPath.startsWith("./") ? rawPath.slice(2) : cursorMarketplace ? rawPath : void 0;
+	if (!relative) throw new Error(`${label} must start with ./`);
+	const normalized = relative.replaceAll("\\", "/");
+	if (normalized.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) throw new Error(`${label} must stay within the marketplace root`);
+	return node_path.default.resolve(marketplace.root, normalized);
+}
+function parseSourceObject(value, baseDirectory, label, marketplace) {
+	const sourceType = requireString$1(value.source, `${label}.source`);
+	if (sourceType === "local") {
+		assertOnlyKeys$1(value, [
+			"source",
+			"path",
+			"description"
+		], label);
+		const rawPath = requireString$1(value.path, `${label}.path`);
+		return {
+			type: "local",
+			path: marketplace ? resolveMarketplaceLocalPath(rawPath, marketplace, `${label}.path`) : node_path.default.resolve(baseDirectory, rawPath)
+		};
+	}
+	if (sourceType === "url" || sourceType === "git-subdir") {
+		assertOnlyKeys$1(value, [
+			"source",
+			"url",
+			"path",
+			"ref",
+			"sha",
+			"description"
+		], label);
+		const remotePath = normalizeRemoteSubdirectory(value.path, `${label}.path`);
+		if (sourceType === "git-subdir" && !remotePath) throw new Error(`${label}.path must be a non-empty string for git-subdir sources`);
+		const ref = optionalString$1(value.ref, `${label}.ref`);
+		const sha = optionalString$1(value.sha, `${label}.sha`);
+		return {
+			type: "git",
+			url: normalizeGitUrl(value.url, marketplace?.root ?? baseDirectory, `${label}.url`),
+			...remotePath ? { path: remotePath } : {},
+			...ref ? { ref } : {},
+			...sha ? { sha } : {}
+		};
+	}
+	if (sourceType === "npm") {
+		assertOnlyKeys$1(value, [
+			"source",
+			"package",
+			"version",
+			"registry",
+			"description"
+		], label);
+		const packageName = requireString$1(value.package, `${label}.package`);
+		if (!NPM_PACKAGE_NAME.test(packageName)) throw new Error(`${label}.package must be a valid npm package name`);
+		const version = optionalString$1(value.version, `${label}.version`);
+		const registry = optionalString$1(value.registry, `${label}.registry`);
+		return {
+			type: "npm",
+			package: packageName,
+			...version ? { version } : {},
+			...registry ? { registry } : {}
+		};
+	}
+	throw new Error(`${label}.source must be local, url, git-subdir, or npm`);
+}
+function parsePluginSource(value, baseDirectory, label, marketplace) {
+	if (typeof value === "string") {
+		const rawPath = requireString$1(value, label);
+		return {
+			type: "local",
+			path: marketplace ? resolveMarketplaceLocalPath(rawPath, marketplace, label) : node_path.default.resolve(baseDirectory, rawPath)
+		};
+	}
+	return parseSourceObject(requireRecord$1(value, label), baseDirectory, label, marketplace);
+}
+function parseConfiguredEntry(value, baseDirectory, label) {
+	if (typeof value === "string") return { source: parsePluginSource(value, baseDirectory, label) };
+	const record = requireRecord$1(value, label);
+	const description = optionalString$1(record.description, `${label}.description`);
+	if (record.source === void 0 && typeof record.path === "string") {
+		assertOnlyKeys$1(record, ["path", "description"], label);
+		return {
+			source: {
+				type: "local",
+				path: node_path.default.resolve(baseDirectory, requireString$1(record.path, `${label}.path`))
+			},
+			...description ? { description } : {}
+		};
+	}
+	if (typeof record.source === "string" && ![
+		"local",
+		"url",
+		"git-subdir",
+		"npm"
+	].includes(record.source)) {
+		assertOnlyKeys$1(record, ["source", "description"], label);
+		return {
+			source: parsePluginSource(record.source, baseDirectory, `${label}.source`),
+			...description ? { description } : {}
+		};
+	}
+	if (isRecord$1(record.source)) {
+		assertOnlyKeys$1(record, ["source", "description"], label);
+		return {
+			source: parsePluginSource(record.source, baseDirectory, `${label}.source`),
+			...description ? { description } : {}
+		};
+	}
+	return {
+		source: parseSourceObject(record, baseDirectory, label),
+		...description ? { description } : {}
+	};
+}
+function marketplaceRootFromManifest(manifestPath) {
+	const normalized = node_path.default.resolve(manifestPath);
+	for (const relativePath of MARKETPLACE_MANIFEST_RELATIVE_PATHS) {
+		const suffix = node_path.default.normalize(relativePath);
+		if (!normalized.endsWith(suffix)) continue;
+		let root = normalized;
+		for (const _segment of relativePath.split("/")) root = node_path.default.dirname(root);
+		return root;
+	}
+}
+function findMarketplace(rootOrManifest) {
+	if (node_fs.default.existsSync(rootOrManifest) && node_fs.default.statSync(rootOrManifest).isFile()) {
+		const root = marketplaceRootFromManifest(rootOrManifest);
+		return root ? {
+			manifestPath: node_path.default.resolve(rootOrManifest),
+			root
+		} : void 0;
+	}
+	for (const relativePath of MARKETPLACE_MANIFEST_RELATIVE_PATHS) {
+		const manifestPath = node_path.default.join(rootOrManifest, relativePath);
+		if (node_fs.default.existsSync(manifestPath) && node_fs.default.statSync(manifestPath).isFile()) return {
+			manifestPath: node_path.default.resolve(manifestPath),
+			root: node_path.default.resolve(rootOrManifest)
+		};
+	}
+}
+function readJsonRecord(filePath, label) {
+	let parsed;
+	try {
+		parsed = JSON.parse(node_fs.default.readFileSync(filePath, "utf8"));
+	} catch (error) {
+		throw new Error(`${label} at ${filePath} is invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return requireRecord$1(parsed, `${label} at ${filePath}`);
+}
+/** Matches Codex manifest precedence, including schema-gated root plugin.json. */
+function findPluginManifestPath(pluginRoot) {
+	const rootManifest = node_path.default.join(pluginRoot, "plugin.json");
+	try {
+		const metadata = node_fs.default.lstatSync(rootManifest);
+		if (metadata.isSymbolicLink() || !metadata.isFile()) return void 0;
+		const parsed = JSON.parse(node_fs.default.readFileSync(rootManifest, "utf8"));
+		if ((isRecord$1(parsed) && typeof parsed.$schema === "string" ? parsed.$schema : void 0)?.startsWith(AGENT_PLUGIN_SCHEMA_PREFIX)) return rootManifest;
+	} catch {}
+	return LEGACY_PLUGIN_MANIFEST_PATHS.map((relativePath) => node_path.default.join(pluginRoot, relativePath)).find((manifestPath) => node_fs.default.existsSync(manifestPath) && node_fs.default.statSync(manifestPath).isFile());
+}
+function readPluginManifestMetadata(pluginRoot, diagnostics) {
+	const manifestPath = findPluginManifestPath(pluginRoot);
+	if (!manifestPath) return void 0;
+	try {
+		const manifest = readJsonRecord(manifestPath, "Plugin manifest");
+		const schema = optionalString$1(manifest.$schema, `${manifestPath}.$schema`);
+		const name = optionalString$1(manifest.name, `${manifestPath}.name`);
+		const version = optionalString$1(manifest.version, `${manifestPath}.version`);
+		const description = optionalString$1(manifest.description, `${manifestPath}.description`);
+		return {
+			path: manifestPath,
+			...name ? { name } : {},
+			...version ? { version } : {},
+			...description ? { description } : {},
+			...schema?.startsWith(AGENT_PLUGIN_SCHEMA_PREFIX) ? { agentPluginSchema: schema } : {}
+		};
+	} catch (error) {
+		diagnostics.push(error instanceof Error ? error.message : String(error));
+		return { path: manifestPath };
+	}
+}
+function discoverPluginRoot(pluginRoot, entries, diagnostics) {
+	const diagnosticCount = diagnostics.length;
+	const manifest = readPluginManifestMetadata(pluginRoot, diagnostics);
+	if (!manifest || diagnostics.length !== diagnosticCount) return false;
+	const name = manifest.name ?? node_path.default.basename(pluginRoot);
+	try {
+		validatePluginIdSegment(name, `Plugin name in ${manifest.path}`);
+	} catch (error) {
+		diagnostics.push(error instanceof Error ? error.message : String(error));
+		return false;
+	}
+	entries[name] = {
+		source: {
+			type: "local",
+			path: pluginRoot
+		},
+		...manifest.description ? { description: manifest.description } : {},
+		manifest
+	};
+	return true;
+}
+function discoverPluginFolder(root, entries, diagnostics) {
+	if (!node_fs.default.existsSync(root) || !node_fs.default.statSync(root).isDirectory()) return 0;
+	if (findPluginManifestPath(root)) return discoverPluginRoot(root, entries, diagnostics) ? 1 : 0;
+	let discovered = 0;
+	const children = node_fs.default.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((left, right) => left.name.localeCompare(right.name));
+	for (const child of children) if (discoverPluginRoot(node_path.default.join(root, child.name), entries, diagnostics)) discovered += 1;
+	return discovered;
+}
+function parseMarketplace(marketplace, entries, diagnostics) {
+	const document = readJsonRecord(marketplace.manifestPath, "Marketplace manifest");
+	const marketplaceName = requireString$1(document.name, `${marketplace.manifestPath}.name`);
+	validatePluginIdSegment(marketplaceName, `${marketplace.manifestPath}.name`);
+	if (!Array.isArray(document.plugins)) throw new Error(`${marketplace.manifestPath}.plugins must be an array`);
+	for (let index = 0; index < document.plugins.length; index += 1) {
+		const label = `${marketplace.manifestPath}.plugins[${index}]`;
+		try {
+			const plugin = requireRecord$1(document.plugins[index], label);
+			const pluginName = requireString$1(plugin.name, `${label}.name`);
+			validatePluginIdSegment(pluginName, `${label}.name`);
+			const id = `${pluginName}@${marketplaceName}`;
+			if (Object.hasOwn(entries, id)) continue;
+			const source = parsePluginSource(plugin.source, marketplace.root, `${label}.source`, marketplace);
+			const description = optionalString$1(plugin.description, `${label}.description`);
+			const manifest = source.type === "local" ? readPluginManifestMetadata(source.path, diagnostics) : void 0;
+			const resolvedDescription = description ?? manifest?.description;
+			entries[id] = {
+				source,
+				marketplace: marketplaceName,
+				...resolvedDescription ? { description: resolvedDescription } : {},
+				...manifest ? { manifest } : {}
+			};
+		} catch (error) {
+			diagnostics.push(error instanceof Error ? error.message : String(error));
+		}
+	}
+}
+function parseConfiguredRoots(source) {
+	if (source.value === void 0) return [];
+	const document = requireRecord$1(source.value, `plugins in ${source.filePath}`);
+	assertOnlyKeys$1(document, ["roots", "entries"], `plugins in ${source.filePath}`);
+	if (document.roots === void 0) return [];
+	if (!Array.isArray(document.roots)) throw new Error(`plugins.roots in ${source.filePath} must be an array`);
+	return document.roots.map((root, index) => node_path.default.resolve(source.baseDirectory, requireString$1(root, `plugins.roots[${index}] in ${source.filePath}`)));
+}
+function applyConfiguredEntries(source, entries, diagnostics) {
+	if (source.value === void 0) return;
+	const document = requireRecord$1(source.value, `plugins in ${source.filePath}`);
+	if (document.entries === void 0) return;
+	const configuredEntries = requireRecord$1(document.entries, `plugins.entries in ${source.filePath}`);
+	for (const [name, value] of Object.entries(configuredEntries)) {
+		validatePluginId(name, `Plugin entry "${name}" in ${source.filePath}`);
+		const parsed = parseConfiguredEntry(value, source.baseDirectory, `plugins.entries.${name} in ${source.filePath}`);
+		const manifest = parsed.source.type === "local" ? readPluginManifestMetadata(parsed.source.path, diagnostics) : void 0;
+		const description = parsed.description ?? manifest?.description;
+		entries[name] = {
+			source: parsed.source,
+			...description ? { description } : {},
+			...manifest ? { manifest } : {}
+		};
+	}
+}
+function pluginDirectoryForSource(source, homeDoomDirectory) {
+	if (source.type === "local") return source.path;
+	const identity = source.type === "git" ? [
+		"git",
+		source.url,
+		source.path ?? "",
+		source.ref ?? "",
+		source.sha ?? ""
+	] : [
+		"npm",
+		source.package,
+		source.version ?? "",
+		source.registry ?? ""
+	];
+	const digest = node_crypto.default.createHash("sha256").update(JSON.stringify(identity)).digest("hex");
+	return node_path.default.join(homeDoomDirectory, CACHE_DIRECTORY, digest);
+}
+function loadPluginCatalog(sources, repoRoot, homeDirectory) {
+	const diagnostics = [];
+	const entries = {};
+	const roots = [...new Set(sources.flatMap(parseConfiguredRoots))];
+	const candidates = [
+		homeDirectory,
+		repoRoot,
+		...roots
+	];
+	const marketplaces = [];
+	const seenMarketplaces = /* @__PURE__ */ new Set();
+	for (const candidate of candidates) {
+		const marketplace = findMarketplace(candidate);
+		if (!marketplace) continue;
+		if (seenMarketplaces.has(marketplace.manifestPath)) continue;
+		seenMarketplaces.add(marketplace.manifestPath);
+		marketplaces.push(marketplace.manifestPath);
+		try {
+			parseMarketplace(marketplace, entries, diagnostics);
+		} catch (error) {
+			diagnostics.push(error instanceof Error ? error.message : String(error));
+		}
+	}
+	for (const root of roots) {
+		if (findMarketplace(root)) continue;
+		if (discoverPluginFolder(root, entries, diagnostics) === 0) diagnostics.push(`Plugin root contains neither a supported marketplace nor discoverable plugins: ${root}`);
+	}
+	for (const source of sources) applyConfiguredEntries(source, entries, diagnostics);
+	return {
+		roots,
+		marketplaces,
+		entries,
+		diagnostics
+	};
+}
+function isRemotePluginSource(source) {
+	return source.type !== "local";
+}
+//#endregion
+//#region src/services/domains/completion.ts
+const NAME_DELIMITER = ",";
+/** Splits comma-joined selections and expands aliases into concrete domain names. */
+function expandDomainNames(manifest, domainNames) {
+	return domainNames.flatMap((raw) => raw.split(NAME_DELIMITER).map((name) => name.trim()).filter(Boolean)).flatMap((name) => manifest.aliases[name] ?? [name]);
+}
+function domainCompletionPrefix(textBeforeCursor) {
+	return textBeforeCursor.match(/^\/domains\s+(?:[^\s,]+,)*([^\s,]*)$/)?.[1];
+}
+function domainCompletionItems(domainNames, query) {
+	const normalizedQuery = query.toLowerCase();
+	return domainNames.filter((name) => name.toLowerCase().startsWith(normalizedQuery)).map((name) => ({
+		value: name,
+		label: name
+	}));
+}
+//#endregion
+//#region src/services/domains/index.ts
+const DOMAINS_FILE = "domains.yaml";
+const UNKNOWN_DOMAIN_ERROR = "Unknown domain";
+const UNKNOWN_PLUGIN_ERROR = "Unknown plugin";
+const MISSING_PLUGIN_DIRECTORY_ERROR = "Plugin directory does not exist";
+const DEFAULT_DOMAINS_PATH = ".po/domains.yaml";
+const SUPPORTED_AGENT_PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireRecord(value, label) {
+	if (!isRecord(value)) throw new Error(`${label} must be an object`);
+	return value;
+}
+function assertOnlyKeys(record, allowed, label) {
+	const unexpected = Object.keys(record).filter((key) => !allowed.includes(key));
+	if (unexpected.length > 0) throw new Error(`${label} contains unsupported field "${unexpected[0]}"`);
+}
+function requireString(value, label) {
+	if (typeof value !== "string" || !value.trim()) throw new Error(`${label} must be a non-empty string`);
+	return value.trim();
+}
+function optionalString(value, label) {
+	if (value === void 0) return void 0;
+	return requireString(value, label);
+}
+function parseStringArray(value, label) {
+	if (!Array.isArray(value)) throw new Error(`${label} must be an array of non-empty strings`);
+	return [...new Set(value.map((entry, index) => requireString(entry, `${label}[${index}]`)))];
+}
+function parseOptionalBoolean(value, label) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "boolean") throw new Error(`${label} must be a boolean`);
+	return value;
+}
+function parseDefaultDomains(value) {
+	return parseStringArray(value, `defaultDomains in ${DEFAULT_DOMAINS_PATH}`);
+}
+function parseDomainPlugin(value, label) {
+	if (typeof value === "string") return requireString(value, label);
+	const plugin = requireRecord(value, label);
+	assertOnlyKeys(plugin, [
+		"name",
+		"skills",
+		"agents",
+		"hooks",
+		"mcp"
+	], label);
+	const skills = plugin.skills === void 0 ? void 0 : parseStringArray(plugin.skills, `${label}.skills`);
+	const agents = plugin.agents === void 0 ? void 0 : parseStringArray(plugin.agents, `${label}.agents`);
+	const hooks = parseOptionalBoolean(plugin.hooks, `${label}.hooks`);
+	const mcp = parseOptionalBoolean(plugin.mcp, `${label}.mcp`);
+	return {
+		name: requireString(plugin.name, `${label}.name`),
+		...skills ? { skills } : {},
+		...agents ? { agents } : {},
+		...hooks === void 0 ? {} : { hooks },
+		...mcp === void 0 ? {} : { mcp }
+	};
+}
+function parseMcpAllowlist(value, label) {
+	const mcp = requireRecord(value, label);
+	assertOnlyKeys(mcp, ["servers", "proxy"], label);
+	return {
+		...mcp.servers === void 0 ? {} : { servers: parseStringArray(mcp.servers, `${label}.servers`) },
+		...mcp.proxy === void 0 ? {} : { proxy: parseStringArray(mcp.proxy, `${label}.proxy`) }
+	};
+}
+function parseDomain(value, label) {
+	const domain = requireRecord(value, label);
+	assertOnlyKeys(domain, [
+		"description",
+		"plugins",
+		"mcp",
+		"sharedSkills"
+	], label);
+	const description = optionalString(domain.description, `${label}.description`);
+	if (domain.plugins !== void 0 && !Array.isArray(domain.plugins)) throw new Error(`${label}.plugins must be an array`);
+	const sharedSkills = parseOptionalBoolean(domain.sharedSkills, `${label}.sharedSkills`);
+	return {
+		...description ? { description } : {},
+		...Array.isArray(domain.plugins) ? { plugins: domain.plugins.map((plugin, index) => parseDomainPlugin(plugin, `${label}.plugins[${index}]`)) } : {},
+		...domain.mcp === void 0 ? {} : { mcp: parseMcpAllowlist(domain.mcp, `${label}.mcp`) },
+		...sharedSkills === void 0 ? {} : { sharedSkills }
+	};
+}
+function parseAliases(value, label) {
+	if (value === void 0) return {};
+	const aliases = requireRecord(value, label);
+	return Object.fromEntries(Object.entries(aliases).map(([name, domains]) => [name, parseStringArray(domains, `${label}.${name}`)]));
+}
+/**
+* Reads domains and plugin catalogs from global and repository configs.
+*
+* Named domains and explicit plugin entries are replaced by later repository
+* definitions. Configured roots accumulate, with exact marketplace manifests
+* deduplicated in discovery order. Explicit entries override discovered IDs.
+*/
+function loadDomains(repoRoot, homeDirectory = node_os.default.homedir()) {
+	const sources = require_layeredConfig.readDoomConfigSources(DOMAINS_FILE, repoRoot, homeDirectory);
+	const aliases = {};
+	const domains = {};
+	let defaultDomains;
+	for (const source of sources) {
+		const document = requireRecord(source.document, source.filePath);
+		assertOnlyKeys(document, [
+			"plugins",
+			"domains",
+			"aliases",
+			"defaultDomains"
+		], source.filePath);
+		Object.assign(aliases, parseAliases(document.aliases, `aliases in ${source.filePath}`));
+		if (document.domains !== void 0) {
+			const sourceDomains = requireRecord(document.domains, `domains in ${source.filePath}`);
+			for (const [name, definition] of Object.entries(sourceDomains)) domains[name] = {
+				...parseDomain(definition, `domains.${name} in ${source.filePath}`),
+				baseDirectory: source.baseDirectory
+			};
+		}
+		if (Object.hasOwn(document, "defaultDomains")) defaultDomains = parseDefaultDomains(document.defaultDomains);
+	}
+	const plugins = loadPluginCatalog(sources.map((source) => ({
+		filePath: source.filePath,
+		baseDirectory: source.baseDirectory,
+		value: requireRecord(source.document, source.filePath).plugins
+	})), repoRoot, homeDirectory);
+	if (defaultDomains) {
+		for (const name of expandDomainNames({
+			plugins,
+			domains,
+			aliases
+		}, defaultDomains)) if (!Object.hasOwn(domains, name)) throw new Error(`Unknown default domain "${name}" in ${DEFAULT_DOMAINS_PATH}`);
+	}
+	return {
+		plugins,
+		domains,
+		aliases,
+		...defaultDomains ? { defaultDomains } : {}
+	};
+}
+function listDomainNames(repoRoot, homeDirectory) {
+	const manifest = loadDomains(repoRoot, homeDirectory);
+	return [.../* @__PURE__ */ new Set([...Object.keys(manifest.domains), ...Object.keys(manifest.aliases)])].sort();
+}
+/**
+* Whether to include .claude/skills as shared fallbacks.
+*
+* Shared skills are included unless every selected domain opts out, so mixing a
+* trimmed domain with an untrimmed one cannot strip the untrimmed one's skills.
+*/
+function resolveSharedSkills(repoRoot, domainNames, homeDirectory) {
+	const manifest = loadDomains(repoRoot, homeDirectory);
+	const expanded = expandDomainNames(manifest, domainNames);
+	if (expanded.length === 0) return true;
+	return expanded.some((name) => manifest.domains[name]?.sharedSkills !== false);
+}
+/** Resolves named domain plugins while preserving each subset filter. */
+function resolvePluginEntries(repoRoot, domainNames, explicitDirectories, homeDirectory = node_os.default.homedir()) {
+	const manifest = loadDomains(repoRoot, homeDirectory);
+	const entries = [];
+	const seen = /* @__PURE__ */ new Set();
+	const homeDoomDirectory = require_config.globalDoomConfigDirectory(homeDirectory);
+	for (const domainName of expandDomainNames(manifest, domainNames)) {
+		const domain = manifest.domains[domainName];
+		if (!domain) throw new Error(`${UNKNOWN_DOMAIN_ERROR}: ${domainName}`);
+		for (const selection of domain.plugins ?? []) {
+			const isSubset = typeof selection !== "string";
+			const pluginName = isSubset ? selection.name : selection;
+			const plugin = manifest.plugins.entries[pluginName];
+			if (!plugin) throw new Error(`${UNKNOWN_PLUGIN_ERROR} "${pluginName}" referenced by domain "${domainName}"`);
+			const directory = pluginDirectoryForSource(plugin.source, homeDoomDirectory);
+			if (plugin.source.type === "local" && (!node_fs.default.existsSync(directory) || !node_fs.default.statSync(directory).isDirectory())) throw new Error(`${MISSING_PLUGIN_DIRECTORY_ERROR}: ${directory}`);
+			if (seen.has(directory)) continue;
+			seen.add(directory);
+			entries.push({
+				name: pluginName,
+				directory,
+				domain: domainName,
+				source: plugin.source,
+				...plugin.manifest ? { manifest: plugin.manifest } : {},
+				...plugin.manifest?.agentPluginSchema === SUPPORTED_AGENT_PLUGIN_SCHEMA ? { skillDiscovery: "direct-children" } : {},
+				...isSubset && selection.skills ? { skills: selection.skills } : {},
+				...isSubset && selection.agents ? { agents: selection.agents } : {},
+				...isSubset && selection.hooks !== void 0 ? { hooks: selection.hooks } : {},
+				...isSubset && selection.mcp !== void 0 ? { mcp: selection.mcp } : {}
+			});
+		}
+	}
+	for (const configuredDirectory of explicitDirectories) {
+		const directory = node_path.default.resolve(configuredDirectory);
+		if (!node_fs.default.existsSync(directory) || !node_fs.default.statSync(directory).isDirectory()) throw new Error(`${MISSING_PLUGIN_DIRECTORY_ERROR}: ${directory}`);
+		if (seen.has(directory)) continue;
+		seen.add(directory);
+		entries.push({
+			name: node_path.default.basename(directory),
+			directory,
+			source: {
+				type: "local",
+				path: directory
+			}
+		});
+	}
+	return entries;
+}
+function resolvePluginDirectories(repoRoot, domainNames, explicitDirectories, homeDirectory) {
+	return resolvePluginEntries(repoRoot, domainNames, explicitDirectories, homeDirectory).map((entry) => entry.directory);
+}
+const PO_DOMAINS_ENV = "PO_DOMAINS";
+const DEFAULT_DOMAIN = "default";
+const MARKETING_MAJOR_MODE = "marketing";
+function parseDomainList(value) {
+	return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+/**
+* Domains selected when the caller names none.
+*
+* Configuration keeps this axis independent of the major mode. The
+* major-mode-derived choice is retained only as the compatibility fallback for
+* domains files that declare no defaultDomains.
+*/
+function defaultDomainsForMajorMode(majorMode, environment, defaultDomains) {
+	const inherited = environment[PO_DOMAINS_ENV];
+	if (inherited !== void 0) return parseDomainList(inherited);
+	if (defaultDomains !== void 0) return [...defaultDomains];
+	return parseDomainList(majorMode === MARKETING_MAJOR_MODE ? MARKETING_MAJOR_MODE : DEFAULT_DOMAIN);
+}
+//#endregion
+Object.defineProperty(exports, "DEFAULT_DOMAIN", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_DOMAIN;
+	}
+});
+Object.defineProperty(exports, "MARKETPLACE_MANIFEST_RELATIVE_PATHS", {
+	enumerable: true,
+	get: function() {
+		return MARKETPLACE_MANIFEST_RELATIVE_PATHS;
+	}
+});
+Object.defineProperty(exports, "PO_DOMAINS_ENV", {
+	enumerable: true,
+	get: function() {
+		return PO_DOMAINS_ENV;
+	}
+});
+Object.defineProperty(exports, "defaultDomainsForMajorMode", {
+	enumerable: true,
+	get: function() {
+		return defaultDomainsForMajorMode;
+	}
+});
+Object.defineProperty(exports, "domainCompletionItems", {
+	enumerable: true,
+	get: function() {
+		return domainCompletionItems;
+	}
+});
+Object.defineProperty(exports, "domainCompletionPrefix", {
+	enumerable: true,
+	get: function() {
+		return domainCompletionPrefix;
+	}
+});
+Object.defineProperty(exports, "expandDomainNames", {
+	enumerable: true,
+	get: function() {
+		return expandDomainNames;
+	}
+});
+Object.defineProperty(exports, "findPluginManifestPath", {
+	enumerable: true,
+	get: function() {
+		return findPluginManifestPath;
+	}
+});
+Object.defineProperty(exports, "isRemotePluginSource", {
+	enumerable: true,
+	get: function() {
+		return isRemotePluginSource;
+	}
+});
+Object.defineProperty(exports, "listDomainNames", {
+	enumerable: true,
+	get: function() {
+		return listDomainNames;
+	}
+});
+Object.defineProperty(exports, "loadDomains", {
+	enumerable: true,
+	get: function() {
+		return loadDomains;
+	}
+});
+Object.defineProperty(exports, "pluginDirectoryForSource", {
+	enumerable: true,
+	get: function() {
+		return pluginDirectoryForSource;
+	}
+});
+Object.defineProperty(exports, "resolvePluginDirectories", {
+	enumerable: true,
+	get: function() {
+		return resolvePluginDirectories;
+	}
+});
+Object.defineProperty(exports, "resolvePluginEntries", {
+	enumerable: true,
+	get: function() {
+		return resolvePluginEntries;
+	}
+});
+Object.defineProperty(exports, "resolveSharedSkills", {
+	enumerable: true,
+	get: function() {
+		return resolveSharedSkills;
+	}
+});
+
+//# sourceMappingURL=domains-CBYkuxs5.cjs.map