metascope 0.1.0 → 0.2.0

package/dist/lib/sources/codemeta-json.d.ts

@@ -0,0 +1,117 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/codemeta-json.d.ts
+declare const codeMetaJsonDataSchema: z.ZodObject<{
+  applicationCategory: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  applicationSubCategory: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  author: z.ZodOptional<z.ZodPipe<z.ZodTransform<Record<string, unknown>[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodObject<{
+    affiliation: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    familyName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    givenName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    id: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+      Organization: "Organization";
+      Person: "Person";
+    }>>;
+    url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>>>>>;
+  buildInstructions: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  codeRepository: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  continuousIntegration: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  contributor: z.ZodOptional<z.ZodPipe<z.ZodTransform<Record<string, unknown>[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodObject<{
+    affiliation: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    familyName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    givenName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    id: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+      Organization: "Organization";
+      Person: "Person";
+    }>>;
+    url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>>>>>;
+  copyrightHolder: z.ZodOptional<z.ZodPipe<z.ZodTransform<Record<string, unknown>[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodObject<{
+    affiliation: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    familyName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    givenName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    id: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+      Organization: "Organization";
+      Person: "Person";
+    }>>;
+    url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>>>>>;
+  copyrightYear: z.ZodPipe<z.ZodTransform<number | undefined, unknown>, z.ZodOptional<z.ZodNumber>>;
+  dateCreated: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  dateModified: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  datePublished: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  developmentStatus: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  downloadUrl: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  funder: z.ZodOptional<z.ZodPipe<z.ZodTransform<Record<string, unknown>[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodObject<{
+    affiliation: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    familyName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    givenName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    id: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+      Organization: "Organization";
+      Person: "Person";
+    }>>;
+    url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>>>>>;
+  funding: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  identifier: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  installUrl: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  isAccessibleForFree: z.ZodOptional<z.ZodBoolean>;
+  issueTracker: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  keywords: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodString>>>>;
+  license: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | string[] | undefined, unknown>, z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>>;
+  maintainer: z.ZodOptional<z.ZodPipe<z.ZodTransform<Record<string, unknown>[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodObject<{
+    affiliation: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    familyName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    givenName: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    id: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+      Organization: "Organization";
+      Person: "Person";
+    }>>;
+    url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>>>>>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  operatingSystem: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodString>>>>;
+  programmingLanguage: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodString>>>>;
+  readme: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  relatedLink: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | string[] | undefined, unknown>, z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>>;
+  releaseNotes: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  runtimePlatform: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodString>>>>;
+  softwareHelp: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  softwareRequirements: z.ZodOptional<z.ZodPipe<z.ZodTransform<Record<string, unknown>[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodObject<{
+    identifier: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    runtimePlatform: 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>>>>>;
+  softwareSuggestions: z.ZodOptional<z.ZodPipe<z.ZodTransform<Record<string, unknown>[] | undefined, unknown>, z.ZodOptional<z.ZodArray<z.ZodObject<{
+    identifier: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+    runtimePlatform: 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>>>>>;
+  softwareVersion: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+  version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>>;
+}, z.core.$strip>;
+type CodeMetaJson = z.infer<typeof codeMetaJsonDataSchema>;
+type CodeMetaJsonData = OneOrMany<SourceRecord<CodeMetaJson>> | undefined;
+//#endregion
+export { CodeMetaJson, CodeMetaJsonData };

package/dist/lib/sources/codemeta-json.js

@@ -0,0 +1,226 @@
+import { log } from "../log.js";
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, parseJsonRecord } 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";
+//#region src/lib/sources/codemeta-json.ts
+/**
+* CodeMeta JSON metadata source.
+*
+* Reads a codemeta.json file (v1, v2, or v3) and normalizes it into a
+* consistent shape with predictable types. No enrichment, no JSON-LD
+* expansion — just an honest representation of what's in the file.
+*
+* Uses Zod preprocess schemas to handle v1/v2/v3 normalization:
+*   - `@`-prefixed JSON-LD keys stripped, v1 property names remapped
+*   - `{"@type": "xsd:anyURI", "@value": "..."}` unwrapped to plain strings
+*   - Person/org objects normalized (`@type`→`type`, `@id`→`id`, affiliation-as-object)
+*   - Comma-separated strings split to arrays, `{"name":"..."}` objects unwrapped
+*   - Dependencies normalized (string → `{name: string}`)
+*/
+/**
+* A string that also unwraps `{"@value": "..."}` JSON-LD typed values.
+* Empty/whitespace strings become undefined via `nonEmptyString`.
+*/
+const codeMetaString = z.preprocess((value) => {
+	if (typeof value === "string") return value;
+	if (is.plainObject(value) && typeof value["@value"] === "string") return value["@value"];
+}, nonEmptyString);
+/** Same as codeMetaString but semantically a URL field. */
+const codeMetaUrl = z.preprocess((value) => {
+	if (typeof value === "string") return value;
+	if (is.plainObject(value) && typeof value["@value"] === "string") return value["@value"];
+}, optionalUrl);
+/**
+* A string array that handles CodeMeta's polymorphic inputs:
+*   - Single comma-separated string → split to array (common in v1)
+*   - Array of strings → pass through
+*   - Array of `{"name":"..."}` objects → extract name strings (e.g. programmingLanguage)
+*/
+const codeMetaStringArray = z.preprocess((value) => {
+	if (value === void 0 || value === null) return;
+	if (typeof value === "string") return value.includes(",") ? splitCommaSeparated(value) : [value];
+	if (Array.isArray(value)) return value.map((item) => {
+		if (typeof item === "string") return item.trim();
+		if (is.plainObject(item)) return typeof item.name === "string" ? item.name.trim() : "";
+		log.warn("Invalid type found in codemeta json parser");
+		return "";
+	}).filter((s) => s.length > 0);
+}, z.array(z.string()).optional()).optional();
+/**
+* License field — preserve as string or string[].
+*/
+const codeMetaLicense = z.preprocess((value) => {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		const filtered = value.filter((l) => typeof l === "string");
+		return filtered.length > 0 ? filtered : void 0;
+	}
+}, z.union([z.string(), z.array(z.string())]).optional()).optional();
+const codeMetaPersonOrOrgSchema = z.object({
+	affiliation: nonEmptyString,
+	email: nonEmptyString,
+	familyName: nonEmptyString,
+	givenName: nonEmptyString,
+	id: nonEmptyString,
+	name: nonEmptyString,
+	type: z.enum(["Organization", "Person"]).optional(),
+	url: optionalUrl
+});
+/**
+* Preprocess a raw person/org value into a normalized shape.
+* Handles: plain string → {name: string}, `@type`→`type`, `@id`→`id`,
+* affiliation-as-object → affiliation string.
+*/
+function preprocessPersonOrOrg(value) {
+	if (typeof value === "string") return { name: value };
+	if (!is.plainObject(value)) return;
+	const result = {};
+	if (typeof value["@type"] === "string") {
+		const rawType = value["@type"].toLowerCase();
+		if (rawType === "person") result.type = "Person";
+		else if (rawType === "organization") result.type = "Organization";
+	}
+	if (typeof value["@id"] === "string") result.id = value["@id"];
+	if (typeof value.name === "string") result.name = value.name;
+	if (typeof value.givenName === "string") result.givenName = value.givenName;
+	if (typeof value.familyName === "string") result.familyName = value.familyName;
+	if (typeof value.email === "string") result.email = value.email;
+	if (typeof value.url === "string") result.url = value.url;
+	if (typeof value.affiliation === "string") result.affiliation = value.affiliation;
+	else if (is.plainObject(value.affiliation) && typeof value.affiliation.name === "string") result.affiliation = value.affiliation.name;
+	if (result.name ?? result.givenName ?? result.familyName ?? result.email) return result;
+}
+/**
+* A person/org array that normalizes single values to arrays,
+* and each element through `preprocessPersonOrOrg`.
+*/
+const codeMetaPersonArray = z.preprocess((value) => {
+	if (value === void 0 || value === null) return;
+	const normalized = (Array.isArray(value) ? value : [value]).map((item) => preprocessPersonOrOrg(item)).filter((p) => p !== void 0);
+	return normalized.length > 0 ? normalized : void 0;
+}, z.array(codeMetaPersonOrOrgSchema).optional()).optional();
+const codeMetaDependencySchema = z.object({
+	identifier: nonEmptyString,
+	name: nonEmptyString,
+	runtimePlatform: nonEmptyString,
+	version: nonEmptyString
+});
+/**
+* Preprocess a raw dependency value into a normalized shape.
+* Handles: plain string → {name: string}.
+*/
+function preprocessDependency(value) {
+	if (typeof value === "string") return { name: value };
+	if (!is.plainObject(value)) return;
+	const dep = {};
+	if (typeof value.name === "string") dep.name = value.name;
+	if (typeof value.identifier === "string") dep.identifier = value.identifier;
+	if (typeof value.version === "string") dep.version = value.version;
+	if (typeof value.runtimePlatform === "string") dep.runtimePlatform = value.runtimePlatform;
+	if (dep.name ?? dep.identifier) return dep;
+}
+/**
+* A dependency array that normalizes single values to arrays,
+* and each element through `preprocessDependency`.
+*/
+const codeMetaDependencyArray = z.preprocess((value) => {
+	if (value === void 0 || value === null) return;
+	const normalized = (Array.isArray(value) ? value : [value]).map((item) => preprocessDependency(item)).filter((d) => d !== void 0);
+	return normalized.length > 0 ? normalized : void 0;
+}, z.array(codeMetaDependencySchema).optional()).optional();
+const codeMetaJsonDataSchema = z.object({
+	applicationCategory: codeMetaString,
+	applicationSubCategory: codeMetaString,
+	author: codeMetaPersonArray,
+	buildInstructions: codeMetaUrl,
+	codeRepository: codeMetaUrl,
+	continuousIntegration: codeMetaUrl,
+	contributor: codeMetaPersonArray,
+	copyrightHolder: codeMetaPersonArray,
+	copyrightYear: z.preprocess((v) => {
+		if (typeof v === "number") return v;
+		if (typeof v === "string") {
+			const parsed = Number.parseInt(v, 10);
+			return Number.isNaN(parsed) ? void 0 : parsed;
+		}
+	}, z.number().optional()),
+	dateCreated: codeMetaString,
+	dateModified: codeMetaString,
+	datePublished: codeMetaString,
+	description: codeMetaString,
+	developmentStatus: codeMetaString,
+	downloadUrl: codeMetaUrl,
+	funder: codeMetaPersonArray,
+	funding: codeMetaString,
+	identifier: codeMetaString,
+	installUrl: codeMetaUrl,
+	isAccessibleForFree: z.boolean().optional(),
+	issueTracker: codeMetaUrl,
+	keywords: codeMetaStringArray,
+	license: codeMetaLicense,
+	maintainer: codeMetaPersonArray,
+	name: codeMetaString,
+	operatingSystem: codeMetaStringArray,
+	programmingLanguage: codeMetaStringArray,
+	readme: codeMetaUrl,
+	relatedLink: codeMetaLicense,
+	releaseNotes: codeMetaString,
+	runtimePlatform: codeMetaStringArray,
+	softwareHelp: codeMetaUrl,
+	softwareRequirements: codeMetaDependencyArray,
+	softwareSuggestions: codeMetaDependencyArray,
+	softwareVersion: codeMetaString,
+	url: codeMetaUrl,
+	version: codeMetaString
+});
+/** Map v1 property names to their v2/v3 equivalents. */
+const v1PropertyMap = {
+	agents: "author",
+	contIntegration: "continuousIntegration",
+	depends: "softwareRequirements",
+	suggests: "softwareSuggestions",
+	title: "name"
+};
+/**
+* Parse a codemeta.json file, normalizing v1/v2/v3 into a consistent shape.
+*/
+function parse(content) {
+	const raw = parseJsonRecord(content);
+	if (!raw) return void 0;
+	const migrated = migrateV1Properties(raw);
+	if (migrated.datePublished === void 0 && typeof migrated.dateReleased === "string") migrated.datePublished = migrated.dateReleased;
+	return codeMetaJsonDataSchema.parse(migrated);
+}
+/**
+* Strip `@`-prefixed JSON-LD keys and remap v1 property names.
+*/
+function migrateV1Properties(raw) {
+	const result = {};
+	for (const [key, value] of Object.entries(raw)) {
+		if (key.startsWith("@")) continue;
+		const mappedKey = v1PropertyMap[key] ?? key;
+		if (!(mappedKey in result)) result[mappedKey] = value;
+	}
+	return result;
+}
+const codemetaJsonSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["codemeta.json"]);
+	},
+	key: "codemetaJson",
+	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 { codeMetaJsonDataSchema, codemetaJsonSource };

package/dist/lib/sources/dependency-updates.d.ts

@@ -0,0 +1,22 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+
+//#region src/lib/sources/dependency-updates.d.ts
+type DependencyUpdatesPackage = {
+  /** Human-readable age of the update (e.g. "3 months"). */age?: string; /** Additional info about the update (e.g. deprecation notice). */
+  info?: string; /** Package name. */
+  name: string; /** Latest available version. */
+  new: string; /** Currently installed version. */
+  old: string;
+};
+type DependencyUpdatesFields = {
+  /** Packages with available major version updates. */major?: DependencyUpdatesPackage[]; /** Packages with available minor version updates. */
+  minor?: DependencyUpdatesPackage[]; /** Packages with available patch version updates. */
+  patch?: DependencyUpdatesPackage[];
+};
+type DependencyUpdatesExtra = {
+  /** Total dependency staleness in libyears. */libyears?: number; /** Total number of outdated packages. */
+  total?: number;
+};
+type DependencyUpdatesData = OneOrMany<SourceRecord<DependencyUpdatesFields, DependencyUpdatesExtra>> | undefined;
+//#endregion
+export { DependencyUpdatesData };

package/dist/lib/sources/dependency-updates.js

@@ -0,0 +1,132 @@
+import { log } from "../log.js";
+import { defineSource } from "../source.js";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { exec } from "tinyexec";
+import { z } from "zod";
+import { coerce, diff } from "semver";
+//#region src/lib/sources/dependency-updates.ts
+const depSchema = z.object({
+	age: z.string().optional(),
+	info: z.string().optional(),
+	new: z.string(),
+	old: z.string()
+});
+const updatesOutputSchema = z.object({ results: z.record(z.string(), z.record(z.string(), z.record(z.string(), depSchema))) });
+/**
+* Resolve the path to the `updates` CLI binary from its installed package.
+*/
+function resolveUpdatesBinary() {
+	const require = createRequire(import.meta.url);
+	const packageJsonPath = require.resolve("updates/package.json");
+	const packageJson = require(packageJsonPath);
+	const bin = typeof packageJson === "object" && packageJson !== null && "bin" in packageJson && typeof packageJson.bin === "string" ? packageJson.bin : void 0;
+	if (!bin) throw new Error("Could not resolve updates binary path");
+	return join(dirname(packageJsonPath), bin);
+}
+/**
+* Parse an age string from the `updates` CLI (via the `timerel` library) into fractional years.
+*
+* Possible formats: "now", "<n> sec(s)", "<n> min(s)", "<n> hour(s)",
+* "<n> day(s)", "<n> week(s)", "<n> month(s)", "<n> year(s)"
+*/
+function parseAgeToYears(age) {
+	if (age === "now") return 0;
+	const match = /^(\d+)\s+(\w+)$/.exec(age.trim());
+	if (!match) return 0;
+	const value = Number(match[1]);
+	switch (match[2]) {
+		case "day":
+		case "days": return value / 365.25;
+		case "hour":
+		case "hours": return value / (365.25 * 24);
+		case "min":
+		case "mins": return value / (365.25 * 24 * 60);
+		case "month":
+		case "months": return value / 12;
+		case "sec":
+		case "secs": return value / (365.25 * 24 * 60 * 60);
+		case "week":
+		case "weeks": return value * 7 / 365.25;
+		case "year":
+		case "years": return value;
+		default: return 0;
+	}
+}
+/**
+* Classify a version bump as major, minor, or patch using semver.
+* Falls back to 'major' for non-semver versions (e.g. GitHub Actions tags).
+*/
+function classifyBump(oldVersion, newVersion) {
+	const oldSemver = coerce(oldVersion);
+	const newSemver = coerce(newVersion);
+	if (!oldSemver || !newSemver) return "major";
+	const result = diff(oldSemver, newSemver);
+	if (!result) return "major";
+	if (result.startsWith("major") || result === "premajor") return "major";
+	if (result.startsWith("minor") || result === "preminor") return "minor";
+	return "patch";
+}
+const dependencyUpdatesSource = defineSource({
+	async discover(context) {
+		return [context.options.path];
+	},
+	key: "dependencyUpdates",
+	async parse(input) {
+		log.debug("Extracting dependency update information via updates...");
+		const result = await exec("node", [
+			resolveUpdatesBinary(),
+			"--file",
+			input,
+			"--json"
+		]);
+		let parsed;
+		try {
+			parsed = updatesOutputSchema.parse(JSON.parse(result.stdout));
+		} catch {
+			log.debug("No dependency files found for updates analysis.");
+			return;
+		}
+		const major = [];
+		const minor = [];
+		const patch = [];
+		let libyears = 0;
+		for (const mode of Object.values(parsed.results)) for (const depGroup of Object.values(mode)) for (const [name, dep] of Object.entries(depGroup)) {
+			if (name === "@types/node") continue;
+			if (dep.age) libyears += parseAgeToYears(dep.age);
+			const packageStatus = {
+				name,
+				new: dep.new,
+				old: dep.old
+			};
+			if (dep.age) packageStatus.age = dep.age;
+			if (dep.info) packageStatus.info = dep.info;
+			switch (classifyBump(dep.old, dep.new)) {
+				case "major":
+					major.push(packageStatus);
+					break;
+				case "minor":
+					minor.push(packageStatus);
+					break;
+				case "patch":
+					patch.push(packageStatus);
+					break;
+			}
+		}
+		return {
+			data: {
+				major,
+				minor,
+				patch
+			},
+			extra: {
+				libyears: Math.round(libyears * 10) / 10,
+				total: major.length + minor.length + patch.length
+			},
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { dependencyUpdatesSource };

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

@@ -0,0 +1,12 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+
+//#region src/lib/sources/file-stats.d.ts
+type FileStats = {
+  /** Name of repo folder, possibly useful as a name fallback */folderName?: string; /** Total number of directories (recursive). */
+  totalDirectoryCount?: number; /** Total number of files (recursive). */
+  totalFileCount?: number; /** Total size of all files in bytes. */
+  totalSizeBytes?: number;
+};
+type FileStatsData = OneOrMany<SourceRecord<FileStats>> | undefined;
+//#endregion
+export { FileStatsData };

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

@@ -0,0 +1,48 @@
+import { log } from "../log.js";
+import { getMatches, getWorkspaces } from "../file-matching.js";
+import { batchMap } from "../utilities/formatting.js";
+import { defineSource } from "../source.js";
+import { stat } from "node:fs/promises";
+import path, { dirname } from "node:path";
+//#region src/lib/sources/file-stats.ts
+const fileStatsSource = defineSource({
+	async discover(context) {
+		return [context.options.path, ...getWorkspaces(context.options.path, context.options.workspaces)];
+	},
+	key: "fileStats",
+	async parse(input, context) {
+		log.debug("Extracting file statistics metadata...");
+		const allFiles = await getMatches({
+			...context.options,
+			path: input,
+			recursive: false,
+			workspaces: false
+		}, ["**"]);
+		const totalFileCount = allFiles.length;
+		const uniqueDirectories = /* @__PURE__ */ new Set();
+		for (const file of allFiles) {
+			const directory = dirname(file);
+			if (directory !== input) uniqueDirectories.add(directory);
+		}
+		const totalDirectoryCount = uniqueDirectories.size;
+		const totalSizeBytes = (await batchMap(allFiles, async (file) => {
+			try {
+				return (await stat(file)).size;
+			} catch {
+				return 0;
+			}
+		}, 100)).reduce((sum, size) => sum + size, 0);
+		return {
+			data: {
+				folderName: input.split(path.sep).at(-1),
+				totalDirectoryCount,
+				totalFileCount,
+				totalSizeBytes
+			},
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { fileStatsSource };

package/dist/lib/sources/git-config.d.ts

@@ -0,0 +1,8 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { GitConfig } from "pkg-types";
+
+//#region src/lib/sources/git-config.d.ts
+type GitConfigInfo = GitConfig;
+type GitConfigData = OneOrMany<SourceRecord<GitConfigInfo>> | undefined;
+//#endregion
+export { GitConfigData };

package/dist/lib/sources/git-config.js

@@ -0,0 +1,21 @@
+import { log } from "../log.js";
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { readGitConfig } from "pkg-types";
+//#region src/lib/sources/git-config.ts
+const gitConfigSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, [".git/config"]);
+	},
+	key: "gitConfig",
+	async parse(input) {
+		log.debug("Extracting git config metadata...");
+		return {
+			data: { ...await readGitConfig(input) },
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { gitConfigSource };

package/dist/lib/sources/git-stats.d.ts

@@ -0,0 +1,35 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+
+//#region src/lib/sources/git-stats.d.ts
+type GitStatsInfo = {
+  /** Total number of local branches. */branchCount?: number; /** Name of the currently checked-out branch. */
+  branchCurrent?: string; /** Total number of commits in the current branch. */
+  commitCount?: number; /** ISO 8601 date of the repository's first commit. */
+  commitDateFirst?: string; /** ISO 8601 date of the most recent commit. */
+  commitDateLast?: string; /** Number of unique commit author emails. */
+  contributorCount?: number; /** Whether the repo uses Git LFS. */
+  hasLfs?: boolean; /** Whether the working tree has no uncommitted changes. */
+  isClean?: boolean; /** Whether the working tree has uncommitted changes. */
+  isDirty?: boolean; /** Whether any remote is ahead of the local branch. */
+  isRemoteAhead?: boolean; /** Number of configured remotes. */
+  remoteCount?: number; /** Per-remote ahead/behind commit counts relative to HEAD. */
+  remoteStatus?: Record<string, {
+    ahead: number;
+    behind: number;
+  }>; /** Number of registered git submodules. */
+  submoduleCount?: number; /** Total number of tags. */
+  tagCount?: number; /** ISO 8601 date of the most recent tag. */
+  tagDateLatest?: string; /** Name of the most recent tag. */
+  tagNameLatest?: string; /** Number of tags matching a version pattern (e.g. v1.2.3). */
+  tagReleaseCount?: number; /** ISO 8601 date of the most recent version tag. */
+  tagVersionDateLatest?: string; /** Most recent version tag, without the leading "v". */
+  tagVersionLatest?: string; /** Total commits ahead of all remotes combined. */
+  totalAhead?: number; /** Total commits behind all remotes combined. */
+  totalBehind?: number; /** Number of files tracked by git. */
+  trackedFileCount?: number; /** Total size in bytes of all tracked files. */
+  trackedSizeBytes?: number; /** Number of files with staged or unstaged changes. */
+  uncommittedFileCount?: number;
+};
+type GitStatsData = OneOrMany<SourceRecord<GitStatsInfo>> | undefined;
+//#endregion
+export { GitStatsData };