metascope 0.1.0 → 0.2.0

package/dist/lib/sources/go-goreleaser-yaml.d.ts

@@ -0,0 +1,19 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/go-goreleaser-yaml.d.ts
+declare const goreleaserDataSchema: z.ZodObject<{
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  homepage: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  license: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  maintainer: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  operating_systems: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  project_name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  repository_url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  vendor: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+/** Parsed goreleaser metadata */
+type Goreleaser = z.infer<typeof goreleaserDataSchema>;
+type GoGoreleaserYamlData = OneOrMany<SourceRecord<Goreleaser>> | undefined;
+//#endregion
+export { GoGoreleaserYamlData };

package/dist/lib/sources/go-goreleaser-yaml.js

@@ -0,0 +1,152 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, stringArray } from "../utilities/schema-primitives.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import is from "@sindresorhus/is";
+import { z } from "zod";
+import { parse } from "yaml";
+//#region src/lib/sources/go-goreleaser-yaml.ts
+const goreleaserDataSchema = z.object({
+	description: nonEmptyString,
+	homepage: optionalUrl,
+	license: nonEmptyString,
+	maintainer: nonEmptyString,
+	operating_systems: stringArray,
+	project_name: nonEmptyString,
+	repository_url: optionalUrl,
+	vendor: nonEmptyString
+});
+/** Map Go OS identifiers to human-readable names. */
+const GOOS_MAP = {
+	aix: "AIX",
+	android: "Android",
+	darwin: "macOS",
+	dragonfly: "DragonFly BSD",
+	freebsd: "FreeBSD",
+	illumos: "illumos",
+	ios: "iOS",
+	js: "JavaScript",
+	linux: "Linux",
+	netbsd: "NetBSD",
+	openbsd: "OpenBSD",
+	plan9: "Plan 9",
+	solaris: "Solaris",
+	wasip1: "WASI",
+	windows: "Windows"
+};
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+/**
+* Get the first non-empty string value of a given field from an array of
+* package-manager section entries. Skips Go template strings (containing `{{`).
+*/
+function firstString(sections, field) {
+	for (const section of sections) if (isPlainObject(section)) {
+		const value = section[field];
+		if (isNonEmptyString(value) && !value.includes("{{")) return value.trim();
+	}
+}
+/**
+* Collect all section entries for a given key, handling both v1 singular
+* and v2 plural forms.
+*/
+function collectSections(data, ...keys) {
+	const result = [];
+	for (const key of keys) {
+		const value = data[key];
+		if (is.array(value)) result.push(...value);
+		else if (isPlainObject(value)) result.push(value);
+	}
+	return result;
+}
+/**
+* Parse a .goreleaser.yml/.yaml file and return structured metadata.
+*
+* Aggregates metadata from multiple package-manager sections (nfpms, brews,
+* scoops, snapcrafts, chocolateys, winget, aurs) with defined priority.
+* Extracts operating systems from builds[].goos.
+*/
+function parse$1(source) {
+	let data;
+	try {
+		data = parse(source);
+	} catch {
+		return;
+	}
+	if (!isPlainObject(data)) return void 0;
+	const result = {
+		description: void 0,
+		homepage: void 0,
+		license: void 0,
+		maintainer: void 0,
+		operating_systems: [],
+		project_name: void 0,
+		repository_url: void 0,
+		vendor: void 0
+	};
+	if (isNonEmptyString(data.project_name)) result.project_name = data.project_name;
+	const nfpms = collectSections(data, "nfpms", "nfpm");
+	const brews = collectSections(data, "brews", "brew", "homebrew_casks");
+	const snaps = collectSections(data, "snapcrafts", "snapcraft");
+	const scoops = collectSections(data, "scoops", "scoop");
+	const chocs = collectSections(data, "chocolateys", "chocolatey");
+	const winget = collectSections(data, "winget");
+	const aurs = collectSections(data, "aurs", "aur");
+	const krews = collectSections(data, "krews", "krew");
+	const allSections = [
+		...nfpms,
+		...brews,
+		...snaps,
+		...scoops,
+		...chocs,
+		...winget,
+		...aurs,
+		...krews
+	];
+	result.description = firstString(allSections, "description") ?? firstString(snaps, "summary") ?? firstString(chocs, "summary") ?? firstString(winget, "short_description");
+	result.homepage = firstString(allSections, "homepage") ?? firstString(chocs, "project_url");
+	result.license = firstString(allSections, "license");
+	result.maintainer = firstString(nfpms, "maintainer") ?? firstString(aurs, "maintainer");
+	result.vendor = firstString(nfpms, "vendor") ?? firstString(chocs, "owners") ?? firstString(winget, "publisher");
+	if (isPlainObject(data.release)) {
+		const { release } = data;
+		if (isPlainObject(release.github)) {
+			const gh = release.github;
+			if (typeof gh.owner === "string" && typeof gh.name === "string") result.repository_url = `https://github.com/${gh.owner}/${gh.name}`;
+		} else if (isPlainObject(release.gitlab)) {
+			const gl = release.gitlab;
+			if (typeof gl.owner === "string" && typeof gl.name === "string") result.repository_url = `https://gitlab.com/${gl.owner}/${gl.name}`;
+		}
+	}
+	const goosSet = /* @__PURE__ */ new Set();
+	const builds = collectSections(data, "builds", "build");
+	for (const build of builds) if (isPlainObject(build)) {
+		const { goos } = build;
+		if (Array.isArray(goos)) {
+			for (const os of goos) if (typeof os === "string") goosSet.add(os.toLowerCase());
+		}
+	}
+	result.operating_systems = [...goosSet].map((os) => GOOS_MAP[os] ?? os.charAt(0).toUpperCase() + os.slice(1));
+	return goreleaserDataSchema.parse(result);
+}
+const goGoreleaserYamlSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, [".goreleaser.yml", ".goreleaser.yaml"]);
+	},
+	key: "goGoreleaserYaml",
+	async parse(input, context) {
+		const data = parse$1(await readFile(resolve(context.options.path, input), "utf8"));
+		if (data !== void 0) return {
+			data,
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { goGoreleaserYamlSource };

package/dist/lib/sources/java-pom-xml.d.ts

@@ -0,0 +1,52 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/java-pom-xml.d.ts
+declare const pomXmlSchema: z.ZodObject<{
+  artifactId: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  ciManagementUrl: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  contributors: z.ZodArray<z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    organization: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  dependencies: z.ZodArray<z.ZodObject<{
+    artifactId: z.ZodString;
+    groupId: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  devDependencies: z.ZodArray<z.ZodObject<{
+    artifactId: z.ZodString;
+    groupId: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  developers: z.ZodArray<z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    organization: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  groupId: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  identifier: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  inceptionYear: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  issueManagementUrl: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  javaVersion: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  licenses: z.ZodArray<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  organization: z.ZodOptional<z.ZodObject<{
+    name: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  scmUrl: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+type PomXml = z.infer<typeof pomXmlSchema>;
+type JavaPomXmlData = OneOrMany<SourceRecord<PomXml>> | undefined;
+//#endregion
+export { JavaPomXmlData };

package/dist/lib/sources/java-pom-xml.js

@@ -0,0 +1,248 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl } from "../utilities/schema-primitives.js";
+import { ensureArray } from "../utilities/template-helpers.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import is from "@sindresorhus/is";
+import { z } from "zod";
+import { XMLParser } from "fast-xml-parser";
+//#region src/lib/sources/java-pom-xml.ts
+/**
+* Source and parser for Maven `pom.xml` files.
+*
+* Extracts project metadata from Maven POM (Project Object Model) files,
+* including coordinates (groupId/artifactId), developers, contributors,
+* licenses, dependencies (with test scope separation), SCM info, CI/issue
+* management URLs, and organization details.
+*
+* Uses `fast-xml-parser` with namespace prefix removal and attribute ignoring.
+*/
+const pomXmlPersonEntrySchema = z.object({
+	email: z.string().optional(),
+	name: z.string(),
+	organization: z.string().optional(),
+	url: z.string().optional()
+});
+const pomXmlLicenseEntrySchema = z.object({
+	name: z.string().optional(),
+	url: z.string().optional()
+});
+const pomXmlDependencyEntrySchema = z.object({
+	artifactId: z.string(),
+	groupId: z.string(),
+	version: z.string().optional()
+});
+const pomXmlOrganizationSchema = z.object({
+	name: z.string(),
+	url: z.string().optional()
+});
+const pomXmlSchema = z.object({
+	artifactId: nonEmptyString,
+	ciManagementUrl: optionalUrl,
+	contributors: z.array(pomXmlPersonEntrySchema),
+	dependencies: z.array(pomXmlDependencyEntrySchema),
+	description: nonEmptyString,
+	devDependencies: z.array(pomXmlDependencyEntrySchema),
+	developers: z.array(pomXmlPersonEntrySchema),
+	groupId: nonEmptyString,
+	identifier: nonEmptyString,
+	inceptionYear: nonEmptyString,
+	issueManagementUrl: optionalUrl,
+	javaVersion: nonEmptyString,
+	licenses: z.array(pomXmlLicenseEntrySchema),
+	name: nonEmptyString,
+	organization: pomXmlOrganizationSchema.optional(),
+	scmUrl: optionalUrl,
+	url: optionalUrl,
+	version: nonEmptyString
+});
+/**
+* Parse a Maven `pom.xml` content string into a structured object.
+* Returns undefined if the XML is malformed or missing the `<project>` root element.
+*/
+function parse(content) {
+	const parser = new XMLParser({
+		ignoreAttributes: true,
+		parseTagValue: false,
+		removeNSPrefix: true
+	});
+	let data;
+	try {
+		const parsed = parser.parse(content);
+		if (!is.plainObject(parsed)) return void 0;
+		data = parsed;
+	} catch {
+		return;
+	}
+	if (!is.plainObject(data.project)) return void 0;
+	const { project } = data;
+	const groupId = getString(project.groupId);
+	const artifactId = getString(project.artifactId);
+	const { dependencies, devDependencies } = parseDependencies(project);
+	return pomXmlSchema.parse({
+		artifactId,
+		ciManagementUrl: getNestedUrl(project.ciManagement),
+		contributors: parsePersonEntries(project.contributors, "contributor"),
+		dependencies,
+		description: getString(project.description),
+		devDependencies,
+		developers: parsePersonEntries(project.developers, "developer"),
+		groupId,
+		identifier: groupId && artifactId ? `${groupId}.${artifactId}` : void 0,
+		inceptionYear: getString(project.inceptionYear),
+		issueManagementUrl: getNestedUrl(project.issueManagement),
+		javaVersion: parseJavaVersion(project),
+		licenses: parseLicenses(project),
+		name: resolveName(project, groupId, artifactId),
+		organization: parseOrganization(project),
+		scmUrl: parseScmUrl(project),
+		url: getString(project.url),
+		version: getString(project.version)
+	});
+}
+/**
+* Get a trimmed non-empty string from a parsed XML value.
+* Returns undefined for empty strings, non-strings, whitespace-only, or Maven variable references.
+*/
+function getString(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return void 0;
+	return trimmed;
+}
+/**
+* Get a string, additionally filtering out Maven variable references ($).
+*/
+function getCleanString(value) {
+	const s = getString(value);
+	if (s?.includes("$")) return void 0;
+	return s;
+}
+/**
+* Resolve Maven variable references in a project name.
+*/
+function resolveName(project, groupId, artifactId) {
+	const name = getString(project.name);
+	if (!name) return void 0;
+	let resolved = name;
+	if (groupId) resolved = resolved.replaceAll("${project.groupId}", groupId);
+	if (artifactId) resolved = resolved.replaceAll("${project.artifactId}", artifactId);
+	return resolved;
+}
+/**
+* Extract a URL from a nested object (e.g. `<ciManagement><url>...</url></ciManagement>`).
+* Filters out Maven variable references.
+*/
+function getNestedUrl(container) {
+	if (!is.plainObject(container)) return void 0;
+	return getCleanString(container.url);
+}
+/**
+* Parse person entries (developers or contributors) from POM XML.
+*/
+function parsePersonEntries(container, childKey) {
+	if (!is.plainObject(container)) return [];
+	const children = container[childKey];
+	const results = [];
+	for (const entry of ensureArray(children)) {
+		if (!is.plainObject(entry)) continue;
+		const name = getString(entry.name);
+		if (!name) continue;
+		results.push({
+			email: getString(entry.email),
+			name,
+			organization: getString(entry.organization),
+			url: getString(entry.url)
+		});
+	}
+	return results;
+}
+/**
+* Parse license entries from `<licenses><license>...</license></licenses>`.
+*/
+function parseLicenses(project) {
+	if (!is.plainObject(project.licenses)) return [];
+	const results = [];
+	for (const entry of ensureArray(project.licenses.license)) {
+		if (!is.plainObject(entry)) continue;
+		const name = getString(entry.name);
+		const url = getString(entry.url);
+		if (name ?? url) results.push({
+			name,
+			url
+		});
+	}
+	return results;
+}
+/**
+* Parse dependencies, separating test-scope into devDependencies.
+*/
+function parseDependencies(project) {
+	const dependencies = [];
+	const devDependencies = [];
+	if (!is.plainObject(project.dependencies)) return {
+		dependencies,
+		devDependencies
+	};
+	for (const entry of ensureArray(project.dependencies.dependency)) {
+		if (!is.plainObject(entry)) continue;
+		const groupId = getString(entry.groupId);
+		const artifactId = getString(entry.artifactId);
+		if (!groupId || !artifactId) continue;
+		const dep = {
+			artifactId,
+			groupId,
+			version: getCleanString(entry.version)
+		};
+		if (getString(entry.scope) === "test") devDependencies.push(dep);
+		else dependencies.push(dep);
+	}
+	return {
+		dependencies,
+		devDependencies
+	};
+}
+/**
+* Parse SCM URL, filtering out Maven variable references.
+*/
+function parseScmUrl(project) {
+	if (!is.plainObject(project.scm)) return void 0;
+	return getCleanString(project.scm.url);
+}
+/**
+* Parse organization from `<organization>` element.
+*/
+function parseOrganization(project) {
+	if (!is.plainObject(project.organization)) return void 0;
+	const name = getString(project.organization.name);
+	if (!name) return void 0;
+	return {
+		name,
+		url: getString(project.organization.url)
+	};
+}
+/**
+* Extract Java version from project properties.
+* Checks `java.version`, `maven.compiler.source`, and `java.compiler.source`.
+*/
+function parseJavaVersion(project) {
+	if (!is.plainObject(project.properties)) return void 0;
+	return getCleanString(project.properties["java.version"]) ?? getCleanString(project.properties["maven.compiler.source"]) ?? getCleanString(project.properties["java.compiler.source"]);
+}
+const javaPomXmlSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["pom.xml"]);
+	},
+	key: "javaPomXml",
+	async parse(input, context) {
+		const data = parse(await readFile(resolve(context.options.path, input), "utf8"));
+		if (data !== void 0) return {
+			data,
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { javaPomXmlSource };

package/dist/lib/sources/license-file.d.ts

@@ -0,0 +1,10 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+
+//#region src/lib/sources/license-file.d.ts
+type LicenseMatch = {
+  /** Match confidence between 0 and 1. */confidence: number; /** SPDX license identifier (e.g. "MIT"). */
+  spdxId: string;
+};
+type LicenseFileData = OneOrMany<SourceRecord<LicenseMatch>> | undefined;
+//#endregion
+export { LicenseFileData };

package/dist/lib/sources/license-file.js

@@ -0,0 +1,26 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { identifyLicense } from "../utilities/license-identification.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+//#region src/lib/sources/license-file.ts
+const licenseFileSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["{,un}licen{c,s}e{,.*}", "copying{,.lesser}{,.*}"]);
+	},
+	key: "licenseFile",
+	async parse(input, context) {
+		const match = identifyLicense(await readFile(resolve(context.options.path, input), "utf8"));
+		if (!match) return;
+		return {
+			data: {
+				confidence: match.confidence,
+				spdxId: match.spdxId
+			},
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { licenseFileSource };

package/dist/lib/sources/metadata-file.d.ts

@@ -0,0 +1,14 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/metadata-file.d.ts
+declare const metadataSchema: z.ZodObject<{
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  homepage: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  keywords: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  repository: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+type Metadata = z.infer<typeof metadataSchema>;
+type MetadataFileData = OneOrMany<SourceRecord<Metadata>> | undefined;
+//#endregion
+export { MetadataFileData };

package/dist/lib/sources/metadata-file.js

@@ -0,0 +1,109 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, parseJsonRecord, stringArray } from "../utilities/schema-primitives.js";
+import { splitCommaSeparated } from "../utilities/template-helpers.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import is from "@sindresorhus/is";
+import { z } from "zod";
+import { parse } from "yaml";
+//#region src/lib/sources/metadata-file.ts
+/**
+* Source and parser for custom `metadata.json` / `metadata.yaml` / `metadata.yml` files.
+*
+* This is a simple custom format with synonymous field names for common
+* project metadata. It supports JSON and YAML formats.
+*
+* Field mapping (with fallback chains):
+*   description                                        → description
+*   homepage | url | repository (normalized) | website → homepage
+*   keywords | tags | topics                           → keywords
+*   repository (normalized)                            → repository
+*/
+const metadataSchema = z.object({
+	description: nonEmptyString,
+	homepage: optionalUrl,
+	keywords: stringArray,
+	repository: optionalUrl
+});
+/**
+* Parse a metadata file content string into a structured object.
+* The `format` parameter determines whether to parse as JSON or YAML.
+* Returns undefined if the content is malformed or not an object.
+*/
+function parse$1(content, format) {
+	let data;
+	if (format === "json") data = parseJsonRecord(content);
+	else try {
+		const parsed = parse(content);
+		data = is.plainObject(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+	if (data === void 0) return;
+	const repository = isString(data.repository) ? normalizeRepoUrl(data.repository) : void 0;
+	const homepage = nonEmpty(data.homepage) ?? nonEmpty(data.url) ?? repository ?? nonEmpty(data.website);
+	const keywords = parseKeywords(data.keywords) ?? parseKeywords(data.tags) ?? parseKeywords(data.topics) ?? [];
+	return metadataSchema.parse({
+		description: data.description,
+		homepage,
+		keywords,
+		repository
+	});
+}
+/** Return a trimmed string if the value is a non-empty string, else undefined. */
+function nonEmpty(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/** Type guard for strings. */
+function isString(value) {
+	return typeof value === "string";
+}
+/** Normalize a repository URL by stripping git+ prefix and .git suffix. */
+function normalizeRepoUrl(url) {
+	let normalized = url;
+	if (normalized.startsWith("git+")) normalized = normalized.slice(4);
+	if (normalized.endsWith(".git")) normalized = normalized.slice(0, -4);
+	return normalized;
+}
+/** Parse keywords from an array of strings or a comma-delimited string. */
+function parseKeywords(value) {
+	if (typeof value === "string") {
+		const parsed = splitCommaSeparated(value);
+		return parsed.length > 0 ? parsed : void 0;
+	}
+	if (Array.isArray(value)) {
+		const strings = value.filter((v) => typeof v === "string");
+		return strings.length > 0 ? strings : void 0;
+	}
+}
+/** Determine the format of a metadata file by its extension. */
+function getFormat(file) {
+	if (file.endsWith(".json")) return "json";
+	if (file.endsWith(".yaml") || file.endsWith(".yml")) return "yaml";
+}
+const metadataFileSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, [
+			"metadata.json",
+			"metadata.yaml",
+			"metadata.yml"
+		]);
+	},
+	key: "metadataFile",
+	async parse(input, context) {
+		const format = getFormat(input);
+		if (format !== void 0) {
+			const data = parse$1(await readFile(resolve(context.options.path, input), "utf8"), format);
+			if (data !== void 0) return {
+				data,
+				source: input
+			};
+		}
+	},
+	phase: 1
+});
+//#endregion
+export { metadataFileSource };

package/dist/lib/sources/metascope.d.ts

@@ -0,0 +1,14 @@
+import { SourceRecord } from "../source.js";
+import { GetMetadataBaseOptions } from "../metadata-types.js";
+
+//#region src/lib/sources/metascope.d.ts
+type MetascopeInfo = {
+  /** Total scan duration in milliseconds. */durationMs: number; /** Resolved options used for this scan (credentials excluded). */
+  options: Omit<GetMetadataBaseOptions, 'credentials'>; /** ISO 8601 timestamp of when the scan was performed. */
+  scannedAt: string; /** Version of the metascope library used. */
+  version: string; /** Workspaces Resolved */
+  workspaceDirectories: string[];
+};
+type MetascopeData = SourceRecord<MetascopeInfo> | undefined;
+//#endregion
+export { MetascopeData };

package/dist/lib/sources/metascope.js

@@ -0,0 +1,35 @@
+import { version } from "../package.js";
+import { getWorkspaces } from "../file-matching.js";
+import { formatPath } from "../utilities/formatting.js";
+import { defineSource } from "../source.js";
+//#region src/lib/sources/metascope.ts
+const metascopeSource = defineSource({
+	async discover(context) {
+		return [context.options.path];
+	},
+	key: "metascope",
+	async parse(input, context) {
+		const { absolute, offline, path: basePath, recursive, respectIgnored, templateData, workspaces } = context.options;
+		return {
+			data: {
+				durationMs: 0,
+				options: {
+					absolute,
+					offline,
+					path: formatPath(basePath, basePath, absolute),
+					recursive,
+					respectIgnored,
+					templateData,
+					workspaces
+				},
+				scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				version,
+				workspaceDirectories: getWorkspaces(basePath, workspaces).map((directory) => formatPath(directory, basePath, absolute))
+			},
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { metascopeSource };