metascope 0.1.0 → 0.2.0

package/dist/lib/parsers/setup-py-parser.js

@@ -0,0 +1,173 @@
+import { splitCommaSeparated } from "../utilities/template-helpers.js";
+import { getPythonLanguage, initParser } from "../utilities/tree-sitter-wasm.js";
+//#region src/lib/parsers/setup-py-parser.ts
+/** Filter nulls from web-tree-sitter's `namedChildren` array. */
+function children(node) {
+	return node.namedChildren.filter((c) => c !== null);
+}
+function emptySetupPyData() {
+	return {
+		author: void 0,
+		author_email: void 0,
+		classifiers: [],
+		description: void 0,
+		download_url: void 0,
+		extras_require: {},
+		install_requires: [],
+		keywords: void 0,
+		license: void 0,
+		long_description: void 0,
+		maintainer: void 0,
+		maintainer_email: void 0,
+		name: void 0,
+		project_urls: {},
+		python_requires: void 0,
+		url: void 0,
+		version: void 0
+	};
+}
+/** Extract a string literal value from a tree-sitter node. */
+function extractString(node) {
+	switch (node.type) {
+		case "concatenated_string": {
+			const parts = children(node).map((child) => extractString(child)).filter((s) => s !== void 0);
+			return parts.length > 0 ? parts.join("") : void 0;
+		}
+		case "float":
+		case "integer": return node.text;
+		case "string": {
+			const content = children(node).find((c) => c.type === "string_content");
+			if (content) return content.text;
+			const withoutPrefix = node.text.replace(/^[bfru]*/i, "");
+			if (withoutPrefix.startsWith("\"\"\"") || withoutPrefix.startsWith("'''")) return withoutPrefix.slice(3, -3);
+			return withoutPrefix.slice(1, -1);
+		}
+		case "string_content": return node.text;
+		default: return;
+	}
+}
+/** Extract a list of strings from an array/list literal node. */
+function extractStringList(node) {
+	if (node.type === "list") return children(node).map((child) => extractString(child)).filter((s) => s !== void 0);
+	if (node.type === "tuple") return children(node).map((child) => extractString(child)).filter((s) => s !== void 0);
+	const single = extractString(node);
+	return single === void 0 ? [] : [single];
+}
+/** Extract a dict literal into a Record<string, string>. */
+function extractStringDict(node) {
+	const result = {};
+	if (node.type !== "dictionary") return result;
+	for (const pair of children(node)) {
+		if (pair.type !== "pair") continue;
+		const key = pair.childForFieldName("key");
+		const value = pair.childForFieldName("value");
+		if (!key || !value) continue;
+		const k = extractString(key);
+		const v = extractString(value);
+		if (k && v) result[k] = v;
+	}
+	return result;
+}
+/** Extract a dict of string lists (for extras_require). */
+function extractStringListDict(node) {
+	const result = {};
+	if (node.type !== "dictionary") return result;
+	for (const pair of children(node)) {
+		if (pair.type !== "pair") continue;
+		const key = pair.childForFieldName("key");
+		const value = pair.childForFieldName("value");
+		if (!key || !value) continue;
+		const k = extractString(key);
+		if (k) result[k] = extractStringList(value);
+	}
+	return result;
+}
+/** Simple string attributes to extract from setup() keyword arguments. */
+const STRING_ATTRS = new Set([
+	"author",
+	"author_email",
+	"description",
+	"download_url",
+	"license",
+	"long_description",
+	"maintainer",
+	"maintainer_email",
+	"name",
+	"python_requires",
+	"url",
+	"version"
+]);
+/**
+* Parse a setup.py file and return structured metadata.
+*
+* Uses tree-sitter with the Python grammar to find the `setup()` call
+* and extract keyword arguments. Only statically determinable values
+* (string/list literals) are extracted — variables and dynamic expressions
+* are skipped.
+*/
+async function parseSetupPy(source) {
+	const parser = await initParser();
+	const python = await getPythonLanguage();
+	parser.setLanguage(python);
+	const tree = parser.parse(source);
+	if (!tree) throw new Error("Failed to parse setup.py source");
+	const data = emptySetupPyData();
+	const setupCall = findSetupCall(tree.rootNode);
+	if (!setupCall) return data;
+	const argumentChildren = setupCall.childForFieldName("arguments");
+	if (!argumentChildren) return data;
+	for (const child of children(argumentChildren)) {
+		if (child.type !== "keyword_argument") continue;
+		const nameNode = child.childForFieldName("name");
+		const valueNode = child.childForFieldName("value");
+		if (!nameNode || !valueNode) continue;
+		const argumentName = nameNode.text;
+		if (STRING_ATTRS.has(argumentName)) {
+			const value = extractString(valueNode);
+			if (value !== void 0) Object.assign(data, { [argumentName]: value });
+			continue;
+		}
+		switch (argumentName) {
+			case "classifiers":
+				data.classifiers = extractStringList(valueNode);
+				break;
+			case "extras_require":
+				data.extras_require = extractStringListDict(valueNode);
+				break;
+			case "install_requires":
+				data.install_requires = extractStringList(valueNode);
+				break;
+			case "keywords":
+				if (valueNode.type === "list" || valueNode.type === "tuple") data.keywords = extractStringList(valueNode);
+				else {
+					const string_ = extractString(valueNode);
+					if (string_) data.keywords = splitCommaSeparated(string_);
+				}
+				break;
+			case "project_urls":
+				data.project_urls = extractStringDict(valueNode);
+				break;
+		}
+	}
+	return data;
+}
+/**
+* Recursively find the setup() or setuptools.setup() call in the AST.
+*/
+function findSetupCall(node) {
+	if (node.type === "call") {
+		const function_ = node.childForFieldName("function");
+		if (function_) {
+			if (function_.type === "identifier" && function_.text === "setup") return node;
+			if (function_.type === "attribute") {
+				if (function_.childForFieldName("attribute")?.text === "setup") return node;
+			}
+		}
+	}
+	for (const child of children(node)) {
+		const result = findSetupCall(child);
+		if (result) return result;
+	}
+}
+//#endregion
+export { parseSetupPy };

package/dist/lib/source.d.ts

@@ -0,0 +1,17 @@
+//#region src/lib/source.d.ts
+/**
+ * A value that is either a single item or an array of items.
+ */
+type OneOrMany<T> = T | T[];
+/**
+ * A unified record returned by every metadata source.
+ * @template D The shape of the primary data extracted from the source.
+ * @template E The shape of any additional computed/derived fields.
+ */
+type SourceRecord<D extends Record<string, unknown> = Record<string, unknown>, E extends Record<string, unknown> = Record<string, unknown>> = {
+  /** Primary structured data from this source. */data: D; /** Additional computed or derived fields not present in the raw source. */
+  extra?: E; /** The file path or URL from which the data was derived. */
+  source: string;
+};
+//#endregion
+export { OneOrMany, SourceRecord };

package/dist/lib/source.js

@@ -0,0 +1,34 @@
+import { log } from "./log.js";
+import { formatPath } from "./utilities/formatting.js";
+//#region src/lib/source.ts
+/**
+* Define a metadata source with `discover` + `parse`.
+* Automatically wires them into an `extract` implementation that handles:
+* - Empty input check (returns undefined)
+* - Per-input try/catch with log.warn
+* - Filtering undefined results from parse
+* - OneOrMany wrapping (single result unwrapped, multiple as array)
+*/
+function defineSource(config) {
+	return {
+		...config,
+		async extract(context) {
+			const inputs = await config.discover(context);
+			if (inputs.length === 0) return void 0;
+			const results = [];
+			for (const input of inputs) try {
+				const result = await config.parse(input, context);
+				if (result) {
+					result.source = formatPath(result.source, context.options.path, context.options.absolute);
+					results.push(result);
+				}
+			} catch (error) {
+				log.warn(`Failed to process "${input}": ${error instanceof Error ? error.message : String(error)}`);
+			}
+			if (results.length === 0) return void 0;
+			return results.length === 1 ? results[0] : results;
+		}
+	};
+}
+//#endregion
+export { defineSource };

package/dist/lib/sources/arduino-library-properties.d.ts

@@ -0,0 +1,45 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/arduino-library-properties.d.ts
+declare const arduinoLibraryPropertiesSchema: z.ZodObject<{
+  architectures: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  authors: z.ZodArray<z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+  }, z.core.$strip>>;
+  category: z.ZodOptional<z.ZodEnum<{
+    Communication: "Communication";
+    "Data Processing": "Data Processing";
+    "Data Storage": "Data Storage";
+    "Device Control": "Device Control";
+    Display: "Display";
+    Other: "Other";
+    Sensors: "Sensors";
+    "Signal Input/Output": "Signal Input/Output";
+    Timing: "Timing";
+    Uncategorized: "Uncategorized";
+  }>>;
+  depends: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    versionConstraint: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  includes: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  license: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  maintainer: z.ZodOptional<z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+  }, z.core.$strip>>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  paragraph: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  raw: z.ZodRecord<z.ZodString, z.ZodString>;
+  repository: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  sentence: 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 ArduinoLibraryProperties = z.infer<typeof arduinoLibraryPropertiesSchema>;
+type ArduinoLibraryPropertiesData = OneOrMany<SourceRecord<ArduinoLibraryProperties>> | undefined;
+//#endregion
+export { ArduinoLibraryPropertiesData };

package/dist/lib/sources/arduino-library-properties.js

@@ -0,0 +1,208 @@
+import { getMatches } from "../file-matching.js";
+import { parseProperties } from "../parsers/properties-parser.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, 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 { z } from "zod";
+//#region src/lib/sources/arduino-library-properties.ts
+const arduinoLibraryPropertiesPersonEntrySchema = z.object({
+	email: z.string().optional(),
+	name: z.string()
+});
+const arduinoLibraryPropertiesDependencyEntrySchema = z.object({
+	name: z.string(),
+	versionConstraint: z.string().optional()
+});
+/** Canonical Arduino library categories. */
+const CANONICAL_CATEGORIES = [
+	"Communication",
+	"Data Processing",
+	"Data Storage",
+	"Device Control",
+	"Display",
+	"Other",
+	"Sensors",
+	"Signal Input/Output",
+	"Timing",
+	"Uncategorized"
+];
+/** Map from letters-only lowercase to canonical category form. */
+const CATEGORY_MAP = new Map(CANONICAL_CATEGORIES.map((cat) => [cat.replaceAll(/[^a-z]/gi, "").toLowerCase(), cat]));
+CATEGORY_MAP.set("sensor", "Sensors");
+const arduinoLibraryPropertiesSchema = z.object({
+	architectures: stringArray,
+	authors: z.array(arduinoLibraryPropertiesPersonEntrySchema),
+	category: z.enum(CANONICAL_CATEGORIES).optional(),
+	depends: z.array(arduinoLibraryPropertiesDependencyEntrySchema),
+	email: nonEmptyString,
+	includes: stringArray,
+	license: nonEmptyString,
+	maintainer: arduinoLibraryPropertiesPersonEntrySchema.optional(),
+	name: nonEmptyString,
+	paragraph: nonEmptyString,
+	raw: z.record(z.string(), z.string()),
+	repository: optionalUrl,
+	sentence: nonEmptyString,
+	url: optionalUrl,
+	version: nonEmptyString
+});
+/**
+* Parse an Arduino `library.properties` content string into a structured object.
+*/
+function parse(content) {
+	const raw = parseProperties(content);
+	const includesValue = get(raw, "includes");
+	return arduinoLibraryPropertiesSchema.parse({
+		architectures: splitCommaSeparated(get(raw, "architectures") ?? "*"),
+		authors: parsePersonList(get(raw, "author") ?? ""),
+		category: normalizeCategory(get(raw, "category")),
+		depends: parseDependencies(get(raw, "depends") ?? get(raw, "dependencies") ?? ""),
+		email: nonEmpty(get(raw, "email")),
+		includes: includesValue ? splitCommaSeparated(includesValue) : [],
+		license: nonEmpty(get(raw, "license")),
+		maintainer: parsePersonList(get(raw, "maintainer") ?? "")[0],
+		name: nonEmpty(get(raw, "name")),
+		paragraph: nonEmpty(get(raw, "paragraph")),
+		raw,
+		repository: nonEmpty(get(raw, "repository")),
+		sentence: nonEmpty(get(raw, "sentence")),
+		url: nonEmpty(get(raw, "url")),
+		version: nonEmpty(get(raw, "version"))
+	});
+}
+/** Helper to get a value from the raw record. */
+function get(raw, key) {
+	return raw[key];
+}
+/** Return a trimmed string, or undefined if empty/whitespace-only. */
+function nonEmpty(value) {
+	if (value === void 0) return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/**
+* Normalize a category string to the canonical Arduino category.
+* Strips all non-letter characters, lowercases, and matches against the canonical map.
+* For comma-separated values (e.g. "Sensors, Timing"), takes the first valid match.
+*/
+function normalizeCategory(value) {
+	if (value === void 0) return void 0;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return void 0;
+	for (const part of trimmed.split(",")) {
+		const key = part.replaceAll(/[^a-z]/gi, "").toLowerCase();
+		if (key.length === 0) continue;
+		const canonical = CATEGORY_MAP.get(key);
+		if (canonical) return canonical;
+	}
+}
+/**
+* Parse a comma-separated list of `Name <email>` entries into PersonEntry[].
+*/
+function parsePersonList(value) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return [];
+	const results = [];
+	for (const entry of trimmed.split(",")) {
+		const trimmedEntry = entry.trim();
+		const bracketIndex = trimmedEntry.indexOf("<");
+		if (bracketIndex !== -1) {
+			const closeBracket = trimmedEntry.indexOf(">", bracketIndex);
+			if (closeBracket !== -1) {
+				const name = trimmedEntry.slice(0, bracketIndex).trim();
+				const email = trimmedEntry.slice(bracketIndex + 1, closeBracket).trim();
+				if (name.length > 0 || email.length > 0) results.push({
+					email: email.length > 0 ? email : void 0,
+					name
+				});
+				continue;
+			}
+		}
+		if (trimmedEntry.length > 0) results.push({
+			email: void 0,
+			name: trimmedEntry
+		});
+	}
+	return results;
+}
+/**
+* Parse a comma-separated list of dependencies with optional version constraints.
+* e.g. "ArduinoHttpClient (>=1.0.0), ArduinoJson" →
+*   [{ name: "ArduinoHttpClient", versionConstraint: ">=1.0.0" }, ...]
+*/
+function parseDependencies(value) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return [];
+	const results = [];
+	for (const entry of trimmed.split(",")) {
+		const trimmedEntry = entry.trim();
+		if (trimmedEntry.length === 0) continue;
+		const parenIndex = trimmedEntry.indexOf("(");
+		if (parenIndex !== -1) {
+			const closeParen = trimmedEntry.indexOf(")", parenIndex);
+			if (closeParen !== -1) {
+				const name = trimmedEntry.slice(0, parenIndex).trim();
+				const constraint = trimmedEntry.slice(parenIndex + 1, closeParen).trim();
+				if (name.length > 0) {
+					results.push({
+						name,
+						versionConstraint: constraint.length > 0 ? constraint : void 0
+					});
+					continue;
+				}
+			}
+		}
+		results.push({
+			name: trimmedEntry,
+			versionConstraint: void 0
+		});
+	}
+	return results;
+}
+/**
+* Arduino-specific fields that distinguish library.properties from
+* Processing's identically-named format.
+*/
+const ARDUINO_SPECIFIC_FIELDS = new Set([
+	"architectures",
+	"depends",
+	"dot_a_linkage",
+	"maintainer"
+]);
+/** Processing-exclusive fields that rule out Arduino. */
+const PROCESSING_EXCLUSIVE_FIELDS = new Set([
+	"authors",
+	"minrevision",
+	"prettyversion"
+]);
+/**
+* Validate that a library.properties file is Arduino (not Processing).
+* Requires name=, version=, author= and either an Arduino-specific field
+* or no Processing-exclusive fields.
+*/
+function isArduinoLibraryProperties(content) {
+	const raw = parseProperties(content);
+	const keys = new Set(Object.keys(raw));
+	if (!keys.has("name") || !keys.has("version") || !keys.has("author")) return false;
+	for (const field of ARDUINO_SPECIFIC_FIELDS) if (keys.has(field)) return true;
+	for (const field of PROCESSING_EXCLUSIVE_FIELDS) if (keys.has(field)) return false;
+	return true;
+}
+const arduinoLibraryPropertiesSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["library.properties"]);
+	},
+	key: "arduinoLibraryProperties",
+	async parse(input, context) {
+		const content = await readFile(resolve(context.options.path, input), "utf8");
+		if (isArduinoLibraryProperties(content)) return {
+			data: parse(content),
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { arduinoLibraryPropertiesSource };

package/dist/lib/sources/cinder-cinderblock-xml.d.ts

@@ -0,0 +1,21 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/cinder-cinderblock-xml.d.ts
+declare const cinderCinderblockSchema: z.ZodObject<{
+  author: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  git: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  id: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  library: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  license: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  requires: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  summary: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  supports: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<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 CinderCinderblock = z.infer<typeof cinderCinderblockSchema>;
+type CinderCinderblockXmlData = OneOrMany<SourceRecord<CinderCinderblock>> | undefined;
+//#endregion
+export { CinderCinderblockXmlData };

package/dist/lib/sources/cinder-cinderblock-xml.js

@@ -0,0 +1,134 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, stringArray } from "../utilities/schema-primitives.js";
+import { ensureArray, 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 { XMLParser } from "fast-xml-parser";
+//#region src/lib/sources/cinder-cinderblock-xml.ts
+/**
+* Source and parser for Cinder `cinderblock.xml` files.
+*
+* CinderBlock is a package format for the Cinder C++ creative coding framework.
+* Metadata lives primarily in attributes on the `<block>` element, with child
+* elements for OS support (`<supports>`) and dependencies (`<requires>`).
+*
+* Uses `fast-xml-parser` with attribute parsing enabled.
+*/
+const cinderCinderblockSchema = z.object({
+	author: stringArray,
+	git: optionalUrl,
+	id: nonEmptyString,
+	library: optionalUrl,
+	license: nonEmptyString,
+	name: nonEmptyString,
+	requires: stringArray,
+	summary: nonEmptyString,
+	supports: stringArray,
+	url: optionalUrl,
+	version: nonEmptyString
+});
+/**
+* Map CinderBlock OS identifiers to human-readable OS names.
+*/
+const OS_MAP = {
+	ios: "iOS",
+	linux: "Linux",
+	macosx: "macOS",
+	msw: "Windows"
+};
+/**
+* Parse a `cinderblock.xml` content string into a structured object.
+* Returns undefined if the XML is malformed or missing the expected structure.
+*/
+function parse(content) {
+	const parser = new XMLParser({
+		attributeNamePrefix: "@_",
+		ignoreAttributes: false,
+		parseTagValue: false
+	});
+	let data;
+	try {
+		const parsed = parser.parse(content);
+		if (!is.plainObject(parsed)) return void 0;
+		data = parsed;
+	} catch {
+		return;
+	}
+	if (!is.plainObject(data.cinder)) return void 0;
+	const { cinder } = data;
+	if (!is.plainObject(cinder.block)) return void 0;
+	const { block } = cinder;
+	return cinderCinderblockSchema.parse({
+		author: splitCommaSeparated(getAttribute(block, "author")),
+		git: getAttribute(block, "git"),
+		id: getAttribute(block, "id"),
+		library: getAttribute(block, "library") ?? getAttribute(block, "libraryUrl"),
+		license: getAttribute(block, "license"),
+		name: getAttribute(block, "name"),
+		requires: parseDependencies(block),
+		summary: getAttribute(block, "summary"),
+		supports: parseOperatingSystems(block),
+		url: getAttribute(block, "url"),
+		version: getAttribute(block, "version")
+	});
+}
+/**
+* Get a trimmed string attribute from a parsed XML element.
+* fast-xml-parser stores attributes with the `@_` prefix.
+*/
+function getAttribute(element, name) {
+	const value = element[`@_${name}`];
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/**
+* Extract deduplicated, mapped operating system names from `<supports os="...">` elements.
+*/
+function parseOperatingSystems(block) {
+	const results = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const support of ensureArray(block.supports)) {
+		if (!is.plainObject(support)) continue;
+		const os = getAttribute(support, "os");
+		if (os) {
+			const mapped = OS_MAP[os.toLowerCase()] ?? os;
+			if (!seen.has(mapped)) {
+				seen.add(mapped);
+				results.push(mapped);
+			}
+		}
+	}
+	return results;
+}
+/**
+* Extract software dependencies from `<requires>` elements.
+*/
+function parseDependencies(block) {
+	const results = [];
+	for (const dep of ensureArray(block.requires)) {
+		if (typeof dep !== "string") continue;
+		const trimmed = dep.trim();
+		if (trimmed.length > 0) results.push(trimmed);
+	}
+	return results;
+}
+const cinderCinderblockXmlSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["cinderblock.xml"]);
+	},
+	key: "cinderCinderblockXml",
+	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 { cinderCinderblockXmlSource };

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

@@ -0,0 +1,14 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { Language, LanguageInfo } from "@kitschpatrol/tokei";
+
+//#region src/lib/sources/code-stats.d.ts
+type CodeStatsTotals = Omit<LanguageInfo, 'language' | 'reports'> & {
+  languages: Language[];
+};
+type CodeStatsFields = {
+  /** Per-language line count perLanguage, sorted by lines of code descending. */perLanguage?: LanguageInfo[]; /** Aggregate line counts across all languages. */
+  total?: CodeStatsTotals;
+};
+type CodeStatsData = OneOrMany<SourceRecord<CodeStatsFields>> | undefined;
+//#endregion
+export { CodeStatsData };

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

@@ -0,0 +1,40 @@
+import { log } from "../log.js";
+import { getWorkspaces } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { tokei } from "@kitschpatrol/tokei";
+//#region src/lib/sources/code-stats.ts
+async function getStatistics(directory, options) {
+	const perLanguage = (await tokei({
+		include: [directory],
+		noIgnore: !options.respectIgnored,
+		noIgnoreDot: !options.respectIgnored,
+		noIgnoreVcs: !options.respectIgnored
+	})).toSorted((a, b) => b.code - a.code);
+	return {
+		data: {
+			perLanguage,
+			total: {
+				blanks: perLanguage.reduce((sum, entry) => sum + entry.blanks, 0),
+				code: perLanguage.reduce((sum, entry) => sum + entry.code, 0),
+				comments: perLanguage.reduce((sum, entry) => sum + entry.comments, 0),
+				files: perLanguage.reduce((sum, entry) => sum + entry.files, 0),
+				languages: perLanguage.map((entry) => entry.language),
+				lines: perLanguage.reduce((sum, entry) => sum + entry.lines, 0)
+			}
+		},
+		source: directory
+	};
+}
+const codeStatsSource = defineSource({
+	async discover(context) {
+		return [context.options.path, ...getWorkspaces(context.options.path, context.options.workspaces)];
+	},
+	key: "codeStats",
+	async parse(input, context) {
+		log.debug("Extracting lines of code via tokei...");
+		return getStatistics(input, context.options);
+	},
+	phase: 1
+});
+//#endregion
+export { codeStatsSource };