@savvy-web/silk 1.3.11 → 2.1.0

package/packages/silk-effects/dist/dev/pkg/changesets/services/config-inspector.cjs

@@ -1,489 +0,0 @@
-const require_ChangesetConfigReader = require('../../services/ChangesetConfigReader.cjs');
-const require_WorkspaceDiscovery = require('../../../../../../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect_platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/services/WorkspaceDiscovery.cjs');
-const require_SilkPublishability = require('../../services/SilkPublishability.cjs');
-const require_errors = require('../errors.cjs');
-const require_options = require('../schemas/options.cjs');
-const require_index = require('../../../../../../../node_modules/.pnpm/tinyglobby@0.2.17/node_modules/tinyglobby/dist/index.cjs');
-let effect = require("effect");
-let _effect_platform = require("@effect/platform");
-let node_path = require("node:path");
-
-//#region ../silk-effects/dist/dev/pkg/changesets/services/config-inspector.js
-/**
-* `ConfigInspector` service — surface the project's `.changeset/config.json`
-* in a structured, validated form that agents and tooling can consume.
-*
-* @remarks
-* The inspector handles three responsibilities that the schemas alone cannot:
-*
-* 1. **Legacy normalization.** Configs from 0.8.x still use the flat
-*    top-level `versionFiles[]` array. When that field is populated, the
-*    inspector emits a one-line deprecation warning to stderr (naming the
-*    config path and the required edit) and folds each legacy entry into
-*    the equivalent `packages[entry.package].versionFiles` shape for
-*    downstream consumers. Removed in 1.0.0.
-* 2. **Resolution against the workspace.** Each `packages` key must resolve
-*    to a known workspace package via `WorkspaceDiscovery`. Unknown keys
-*    surface as a {@link ConfigurationError}. The inspector returns the
-*    package's absolute workspace directory alongside the resolved scope.
-* 3. **Overlap detection.** Cross-package validation rules that the schemas
-*    cannot enforce:
-*    - `additionalScopes` of two different packages must not overlap.
-*    - `additionalScopes` of one package must not shadow another package's
-*      workspace directory.
-*    - Two `versionFiles` entries (within or across packages) must not
-*      resolve to the same `(file, $.path)` tuple.
-*
-* Validation is performed eagerly on the first {@link ConfigInspectorShape.inspect}
-* call. The resolved state is cached internally per `cwd` so subsequent
-* {@link ConfigInspectorShape.classify} calls reuse it.
-*
-* @see {@link ConfigInspector} for the Effect service tag
-* @see {@link ConfigInspectorLive} for the production layer
-*
-*/
-/** A `versionFiles` entry expanded to its absolute target paths. @public */
-const ResolvedVersionFileSchema = effect.Schema.Struct({
-	glob: effect.Schema.String,
-	paths: effect.Schema.Array(effect.Schema.String).annotations({ description: "JSONPath expressions to update (defaults to [\"$.version\"])." }),
-	matchedFiles: effect.Schema.Array(effect.Schema.String)
-}).annotations({ identifier: "ResolvedVersionFile" });
-/** A package's resolved release surface. @public */
-const ResolvedPackageScopeSchema = effect.Schema.Struct({
-	name: effect.Schema.String,
-	workspaceDir: effect.Schema.String,
-	version: effect.Schema.String,
-	additionalScopes: effect.Schema.Array(effect.Schema.String),
-	additionalScopeFiles: effect.Schema.Array(effect.Schema.String),
-	versionFiles: effect.Schema.Array(ResolvedVersionFileSchema)
-}).annotations({ identifier: "ResolvedPackageScope" });
-/** Structured representation of a resolved `.changeset/config.json`. @public */
-const InspectedConfigSchema = effect.Schema.Struct({
-	configPath: effect.Schema.String,
-	projectDir: effect.Schema.String.annotations({ description: "Absolute project root (the directory containing .changeset/)." }),
-	changelog: effect.Schema.NullOr(effect.Schema.String),
-	baseBranch: effect.Schema.String,
-	access: effect.Schema.Literal("public", "restricted"),
-	ignore: effect.Schema.Array(effect.Schema.String),
-	packages: effect.Schema.Array(ResolvedPackageScopeSchema),
-	legacyVersionFilesUsed: effect.Schema.Boolean
-}).annotations({ identifier: "InspectedConfig" });
-/** Reason a path was attributed to a package (or left unmapped). @public */
-const ClassificationReasonSchema = effect.Schema.Union(effect.Schema.Literal("workspace"), effect.Schema.Struct({
-	kind: effect.Schema.Literal("additionalScope"),
-	glob: effect.Schema.String
-}), effect.Schema.Struct({
-	kind: effect.Schema.Literal("versionFile"),
-	glob: effect.Schema.String
-}), effect.Schema.Null).annotations({ identifier: "ClassificationReason" });
-/** The result of classifying a single path against a resolved config. @public */
-const ClassificationSchema = effect.Schema.Struct({
-	path: effect.Schema.String,
-	package: effect.Schema.NullOr(effect.Schema.String),
-	reason: ClassificationReasonSchema
-}).annotations({ identifier: "Classification" });
-/**
-* Base class for {@link ConfigInspector}.
-*
-* @privateRemarks
-* Effect's `Context.Tag` creates an anonymous base class that api-extractor
-* cannot follow without an explicit export. Do not delete.
-*
-* @internal
-*/
-const ConfigInspectorBase = effect.Context.Tag("ConfigInspector")();
-/**
-* Effect service tag for {@link ConfigInspectorShape}.
-*
-* @example
-* ```typescript
-* import { Effect } from "effect";
-* import { ConfigInspector, ConfigInspectorLive } from "@savvy-web/changesets";
-*
-* const program = Effect.gen(function* () {
-*   const inspector = yield* ConfigInspector;
-*   const config = yield* inspector.inspect(process.cwd());
-*   return config.packages.map((p) => p.name);
-* });
-*
-* Effect.runPromise(program.pipe(Effect.provide(ConfigInspectorLive)));
-* ```
-*
-* @public
-*/
-var ConfigInspector = class extends ConfigInspectorBase {};
-/**
-* Pull the changelog formatter ID and its options object out of the raw
-* `.changeset/config.json` shape (where `changelog` may be a tuple, a string,
-* or absent).
-*/
-function extractChangelogOptions(config) {
-	const { changelog } = config;
-	if (Array.isArray(changelog)) return {
-		changelogId: typeof changelog[0] === "string" ? changelog[0] : null,
-		options: changelog[1] ?? {}
-	};
-	if (typeof changelog === "string") return {
-		changelogId: changelog,
-		options: {}
-	};
-	return {
-		changelogId: null,
-		options: {}
-	};
-}
-/**
-* Normalize the deprecated top-level `versionFiles[]` array into the
-* equivalent `packages[entry.package].versionFiles` shape. Mutates a fresh
-* copy of the options; never the input.
-*
-* Returns the normalized options and a flag indicating whether normalization
-* happened (so the caller can emit a deprecation warning once per inspect).
-*/
-function normalizeLegacyOptions(options, configPath) {
-	const legacy = options.versionFiles;
-	if (!Array.isArray(legacy) || legacy.length === 0) return {
-		normalized: options,
-		legacyUsed: false
-	};
-	console.warn(`[changesets] DEPRECATION: ${configPath} uses the top-level \`versionFiles\` array. Migrate to \`changelog[1].packages[<name>].versionFiles\`. Removed in 1.0.0.`);
-	const existing = options.packages ?? {};
-	const next = {};
-	for (const [k, v] of Object.entries(existing)) next[k] = { ...v };
-	for (const entry of legacy) {
-		const ownerName = typeof entry.package === "string" ? entry.package : void 0;
-		if (!ownerName) throw new require_errors.ConfigurationError({
-			field: "versionFiles",
-			reason: `Legacy versionFiles entry { glob: ${JSON.stringify(entry.glob)} } in ${configPath} has no \`package\` field. Path-based owner inference is removed during the 0.9.0 migration — add an explicit \`package\` field, or migrate the entry to \`packages[<name>].versionFiles\`.`
-		});
-		if (!next[ownerName]) next[ownerName] = {};
-		const slot = next[ownerName];
-		const arr = Array.isArray(slot.versionFiles) ? slot.versionFiles.slice() : [];
-		const cleaned = { glob: entry.glob };
-		if (Array.isArray(entry.paths)) cleaned.paths = entry.paths;
-		arr.push(cleaned);
-		slot.versionFiles = arr;
-	}
-	const normalized = {
-		...options,
-		packages: next
-	};
-	delete normalized.versionFiles;
-	return {
-		normalized,
-		legacyUsed: true
-	};
-}
-/**
-* Materialize a glob against `cwd` and return the matched file paths as
-* repo-relative strings. Honors negation patterns and ignores `node_modules`.
-*/
-function materializeGlob(glob, cwd) {
-	return require_index.globSync(glob, {
-		cwd,
-		ignore: ["**/node_modules/**"],
-		dot: true
-	});
-}
-/**
-* Determine whether `child` is the same directory as `parent` or sits inside
-* it. Both paths must be absolute.
-*/
-function isInside(parent, child) {
-	const rel = (0, node_path.relative)(parent, child);
-	return rel === "" || !rel.startsWith("..") && !(0, node_path.isAbsolute)(rel);
-}
-/**
-* Build per-package resolved scopes by intersecting the (possibly normalized)
-* options with workspace info.
-*/
-function buildResolvedScopes(params) {
-	const { options, workspaces, projectDir, configPath } = params;
-	const packages = options.packages ?? {};
-	const workspacesByName = new Map(workspaces.map((w) => [w.name, w]));
-	const scopes = [];
-	for (const [pkgName, scope] of Object.entries(packages)) {
-		const ws = workspacesByName.get(pkgName);
-		if (!ws) throw new require_errors.ConfigurationError({
-			field: `packages["${pkgName}"]`,
-			reason: `Unknown package "${pkgName}" in ${configPath}. Known workspace packages: ${workspaces.map((w) => w.name).join(", ") || "(none)"}.`
-		});
-		const additionalScopes = scope.additionalScopes ?? [];
-		const additionalScopeFiles = additionalScopes.flatMap((g) => materializeGlob(g, projectDir));
-		const resolvedVersionFiles = (scope.versionFiles ?? []).map((entry) => ({
-			glob: entry.glob,
-			paths: entry.paths ?? ["$.version"],
-			matchedFiles: materializeGlob(entry.glob, projectDir).map((rel) => (0, node_path.join)(projectDir, rel))
-		}));
-		scopes.push({
-			name: pkgName,
-			workspaceDir: ws.path,
-			version: ws.version,
-			additionalScopes,
-			additionalScopeFiles: additionalScopeFiles.map((rel) => (0, node_path.join)(projectDir, rel)),
-			versionFiles: resolvedVersionFiles
-		});
-	}
-	return scopes;
-}
-/**
-* Read a workspace package's raw package.json. A genuinely missing manifest
-* resolves to `null` so the caller can skip that package — a workspace
-* directory without a `package.json` is not a release surface. Any OTHER
-* failure (unreadable file, malformed JSON) is surfaced as a
-* {@link ConfigurationError} carrying the package path, rather than silently
-* dropping the package, which would cascade into wrong attribution.
-*/
-function readRawPackageJson(fs, pkgDir) {
-	const pkgJsonPath = (0, node_path.join)(pkgDir, "package.json");
-	return fs.readFileString(pkgJsonPath).pipe(effect.Effect.flatMap((content) => effect.Effect.try(() => JSON.parse(content))), effect.Effect.catchAll((err) => {
-		if (err.reason === "NotFound") return effect.Effect.succeed(null);
-		return effect.Effect.fail(new require_errors.ConfigurationError({
-			field: "workspace",
-			reason: `Failed to read or parse ${pkgJsonPath}: ${err instanceof Error ? err.message : String(err)}`
-		}));
-	}));
-}
-/**
-* Build resolved scopes from the discovered workspace packages, keeping only
-* those that are a release surface (declare publishConfig that yields at least
-* one publish target). Used both when `.changeset/config.json` declares no
-* explicit `packages` record AND to augment an explicit record with the
-* remaining workspace packages it does not list (so the record annotates the
-* listed packages without shrinking the release surface). The changeset
-* `ignore` list is intentionally NOT consulted here — an ignored package still
-* declares publishConfig and remains a valid changeset target.
-*/
-function buildFallbackScopes(fs, workspaces) {
-	return effect.Effect.forEach(workspaces, (ws) => effect.Effect.gen(function* () {
-		const raw = yield* readRawPackageJson(fs, ws.path);
-		if (raw === null) return [];
-		const binding = yield* require_SilkPublishability.readTargetsBinding(fs, ws.path);
-		if (require_SilkPublishability.SilkPublishability.detect(ws.name, raw, binding).length === 0) return [];
-		return [{
-			name: ws.name,
-			workspaceDir: ws.path,
-			version: ws.version,
-			additionalScopes: [],
-			additionalScopeFiles: [],
-			versionFiles: []
-		}];
-	})).pipe(effect.Effect.map((nested) => nested.flat()));
-}
-/**
-* Cross-package validation: no overlap in `additionalScopes`, no shadowing
-* of another workspace package's directory (regardless of whether that
-* package is itself declared in `config.packages`), and no duplicate
-* `(file, JSONPath)` tuples in `versionFiles`.
-*/
-function checkConflicts(scopes, allWorkspaces, projectDir, configPath) {
-	const scopeOwner = /* @__PURE__ */ new Map();
-	for (const s of scopes) for (const f of s.additionalScopeFiles) {
-		const prev = scopeOwner.get(f);
-		if (prev && prev !== s.name) throw new require_errors.ConfigurationError({
-			field: `packages["${s.name}"].additionalScopes`,
-			reason: `Overlap in ${configPath}: file ${JSON.stringify(f)} is matched by both "${prev}" and "${s.name}". additionalScopes must not overlap between packages.`
-		});
-		scopeOwner.set(f, s.name);
-	}
-	for (const s of scopes) for (const f of s.additionalScopeFiles) for (const ws of allWorkspaces) {
-		if (ws.name === s.name) continue;
-		if (ws.path === projectDir) continue;
-		if (isInside(ws.path, f)) throw new require_errors.ConfigurationError({
-			field: `packages["${s.name}"].additionalScopes`,
-			reason: `Shadowing in ${configPath}: "${s.name}" claims ${JSON.stringify(f)} via additionalScopes, but that path is inside "${ws.name}"'s workspace directory (${ws.path}). A package's additionalScopes must not include another package's workspace files.`
-		});
-	}
-	const seen = /* @__PURE__ */ new Map();
-	for (const s of scopes) for (const vf of s.versionFiles) for (const file of vf.matchedFiles) for (const path of vf.paths) {
-		const key = `${file}::${path}`;
-		const prev = seen.get(key);
-		if (prev && (prev.pkg !== s.name || prev.glob !== vf.glob)) throw new require_errors.ConfigurationError({
-			field: `packages["${s.name}"].versionFiles`,
-			reason: `Conflict in ${configPath}: target (${JSON.stringify(file)}, ${path}) is claimed by both "${prev.pkg}" (glob ${JSON.stringify(prev.glob)}) and "${s.name}" (glob ${JSON.stringify(vf.glob)}). Two versionFiles entries must not resolve to the same (file, JSONPath) tuple.`
-		});
-		seen.set(key, {
-			pkg: s.name,
-			glob: vf.glob
-		});
-	}
-}
-/**
-* Build a `ConfigurationError` from a Schema `ParseError`. Captures the
-* original message verbatim so the user sees exactly what the schema
-* complained about.
-*/
-function configErrorFromParseError(parseError, configPath) {
-	return new require_errors.ConfigurationError({
-		field: "options",
-		reason: `Invalid options in ${configPath}: ${String(parseError)}`
-	});
-}
-/**
-* Build a {@link ConfigInspectorShape} that closes over already-resolved
-* service implementations. This keeps the public `inspect`/`classify`
-* signatures requirement-free (`R = never`) while still allowing the
-* implementation to use `ChangesetConfigReader` and `WorkspaceDiscovery`.
-*
-* Each shape carries a private cache keyed by absolute project dir so
-* repeat `inspect`/`classify` calls reuse the materialized state.
-*/
-function makeShape(reader, discovery, fs) {
-	const cache = /* @__PURE__ */ new Map();
-	const inspect = (cwd) => effect.Effect.gen(function* () {
-		const projectDir = (0, node_path.resolve)(cwd);
-		const cached = cache.get(projectDir);
-		if (cached) return cached;
-		const config = yield* reader.read(projectDir).pipe(effect.Effect.mapError((err) => new require_errors.ConfigurationError({
-			field: "configFile",
-			reason: err.message
-		})));
-		const configPath = (0, node_path.join)(projectDir, ".changeset", "config.json");
-		const { changelogId, options: rawOptions } = extractChangelogOptions(config);
-		const optionsRecord = typeof rawOptions === "object" && rawOptions !== null ? rawOptions : {};
-		if (Array.isArray(optionsRecord.versionFiles) && typeof optionsRecord.packages === "object" && optionsRecord.packages !== null) return yield* effect.Effect.fail(new require_errors.ConfigurationError({
-			field: "options",
-			reason: `Configuration in ${configPath} declares both \`packages\` and the deprecated top-level \`versionFiles\` array. Migrate the legacy entries into \`packages[<name>].versionFiles\` and remove the top-level field.`
-		}));
-		let normalized;
-		let legacyUsed;
-		try {
-			const result = normalizeLegacyOptions(optionsRecord, configPath);
-			normalized = result.normalized;
-			legacyUsed = result.legacyUsed;
-		} catch (e) {
-			if (e instanceof require_errors.ConfigurationError) return yield* effect.Effect.fail(e);
-			throw e;
-		}
-		const decodedOptions = yield* effect.Schema.decodeUnknown(require_options.ChangesetOptionsSchema)(normalized).pipe(effect.Effect.mapError((parseError) => configErrorFromParseError(parseError, configPath)));
-		const workspaces = (yield* discovery.listPackages(projectDir).pipe(effect.Effect.mapError((err) => new require_errors.ConfigurationError({
-			field: "workspace",
-			reason: `Workspace discovery failed for ${projectDir}: ${err.message}`
-		})))).map((w) => ({
-			name: w.name,
-			path: w.path,
-			version: w.version
-		}));
-		const hasExplicitPackages = Object.keys(decodedOptions.packages ?? {}).length > 0;
-		let scopes;
-		if (hasExplicitPackages) {
-			let explicitScopes;
-			try {
-				explicitScopes = buildResolvedScopes({
-					options: decodedOptions,
-					workspaces,
-					projectDir,
-					configPath
-				});
-				checkConflicts(explicitScopes, workspaces, projectDir, configPath);
-			} catch (e) {
-				if (e instanceof require_errors.ConfigurationError) return yield* effect.Effect.fail(e);
-				throw e;
-			}
-			const explicitNames = new Set(explicitScopes.map((s) => s.name));
-			const discoveredScopes = yield* buildFallbackScopes(fs, workspaces.filter((w) => !explicitNames.has(w.name)));
-			scopes = [...explicitScopes, ...discoveredScopes];
-		} else scopes = yield* buildFallbackScopes(fs, workspaces);
-		const inspected = {
-			configPath,
-			projectDir,
-			changelog: changelogId,
-			baseBranch: config.baseBranch ?? "main",
-			access: config.access ?? "restricted",
-			ignore: config.ignore ?? [],
-			packages: scopes,
-			legacyVersionFilesUsed: legacyUsed
-		};
-		cache.set(projectDir, inspected);
-		return inspected;
-	});
-	const classify = (cwd, paths) => effect.Effect.gen(function* () {
-		const inspected = yield* inspect(cwd);
-		return paths.map((p) => classifyOne(inspected, p));
-	});
-	return {
-		inspect,
-		classify
-	};
-}
-/**
-* Classify a single path against an inspected config.
-*/
-function classifyOne(inspected, path) {
-	const abs = (0, node_path.resolve)(inspected.projectDir, path);
-	let bestWorkspace = null;
-	for (const s of inspected.packages) if (isInside(s.workspaceDir, abs)) {
-		const depth = s.workspaceDir.length;
-		if (!bestWorkspace || depth > bestWorkspace.depth) bestWorkspace = {
-			pkg: s.name,
-			depth
-		};
-	}
-	if (bestWorkspace) return {
-		path,
-		package: bestWorkspace.pkg,
-		reason: "workspace"
-	};
-	for (const s of inspected.packages) if (s.additionalScopeFiles.includes(abs)) {
-		const glob = s.additionalScopes.find((g) => materializeGlob(g, inspected.projectDir).map((rel) => (0, node_path.join)(inspected.projectDir, rel)).includes(abs));
-		return {
-			path,
-			package: s.name,
-			reason: {
-				kind: "additionalScope",
-				glob: glob ?? s.additionalScopes[0] ?? ""
-			}
-		};
-	}
-	for (const s of inspected.packages) for (const vf of s.versionFiles) if (vf.matchedFiles.includes(abs)) return {
-		path,
-		package: s.name,
-		reason: {
-			kind: "versionFile",
-			glob: vf.glob
-		}
-	};
-	return {
-		path,
-		package: null,
-		reason: null
-	};
-}
-/**
-* Live layer for {@link ConfigInspector}.
-*
-* Requires {@link ChangesetConfigReader} and `WorkspaceDiscovery`
-* in the environment.
-*
-* @public
-*/
-const ConfigInspectorLive = effect.Layer.effect(ConfigInspector, effect.Effect.gen(function* () {
-	return makeShape(yield* require_ChangesetConfigReader.ChangesetConfigReader, yield* require_WorkspaceDiscovery.WorkspaceDiscovery, yield* _effect_platform.FileSystem.FileSystem);
-}));
-/**
-* Test factory — build a {@link ConfigInspector} that returns a fixed
-* {@link InspectedConfig} without touching the filesystem.
-*
-* Tests that need to exercise the inspect/classify logic against real files
-* should compose `ConfigInspectorLive` with test layers for
-* `ChangesetConfigReader` and `WorkspaceDiscovery` instead.
-*
-* @public
-*/
-function makeConfigInspectorTest(fixed) {
-	return effect.Layer.succeed(ConfigInspector, {
-		inspect: () => effect.Effect.succeed(fixed),
-		classify: (_cwd, paths) => effect.Effect.succeed(paths.map((p) => classifyOne(fixed, p)))
-	});
-}
-
-//#endregion
-exports.ClassificationReasonSchema = ClassificationReasonSchema;
-exports.ClassificationSchema = ClassificationSchema;
-exports.ConfigInspector = ConfigInspector;
-exports.ConfigInspectorBase = ConfigInspectorBase;
-exports.ConfigInspectorLive = ConfigInspectorLive;
-exports.InspectedConfigSchema = InspectedConfigSchema;
-exports.ResolvedPackageScopeSchema = ResolvedPackageScopeSchema;
-exports.ResolvedVersionFileSchema = ResolvedVersionFileSchema;
-exports.makeConfigInspectorTest = makeConfigInspectorTest;