metascope 0.1.0 → 0.2.0

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

@@ -0,0 +1,130 @@
+import { log } from "../log.js";
+import { getMatches } from "../file-matching.js";
+import { batchMap } from "../utilities/formatting.js";
+import { defineSource } from "../source.js";
+import { stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { simpleGit } from "simple-git";
+//#region src/lib/sources/git-stats.ts
+const gitStatsSource = defineSource({
+	async discover(context) {
+		return (await getMatches(context.options, [".git/config"])).map((value) => resolve(value, "../../"));
+	},
+	key: "gitStats",
+	async parse(input, context) {
+		log.debug("Extracting git statistics metadata...");
+		const git = simpleGit(input);
+		const [statusResult, logResult, branchResult, tagResult, commitDateFirst, trackedFiles, remotes, submoduleCount, hasLfs] = await Promise.all([
+			git.status(),
+			git.log(),
+			git.branch(),
+			git.tags(),
+			git.raw([
+				"rev-list",
+				"--max-parents=0",
+				"HEAD",
+				"--format=%aI"
+			]).then((output) => {
+				return output.trim().split("\n").filter((line) => !line.startsWith("commit ")).at(-1) ?? void 0;
+			}),
+			git.raw(["ls-files"]).then((output) => output.trim().split("\n").filter(Boolean)),
+			git.getRemotes(),
+			git.raw(["submodule", "status"]).then((output) => {
+				const count = output.trim().split("\n").filter(Boolean).length;
+				return count > 0 ? count : void 0;
+			}).catch(() => void 0),
+			git.raw(["lfs", "ls-files"]).then((output) => output.trim().length > 0 ? true : void 0).catch(() => void 0)
+		]);
+		const trackedSizeBytes = (await batchMap(trackedFiles, async (file) => {
+			try {
+				return (await stat(join(context.options.path, file))).size;
+			} catch {
+				return 0;
+			}
+		})).reduce((sum, size) => sum + size, 0);
+		const contributors = new Set(logResult.all.map((commit) => commit.author_email));
+		let tagDateLatest;
+		const tagNameLatest = tagResult.latest ?? void 0;
+		if (tagNameLatest) try {
+			tagDateLatest = (await git.raw([
+				"log",
+				"-1",
+				"--format=%aI",
+				tagNameLatest
+			])).trim() || void 0;
+		} catch {}
+		const versionTagPattern = /^v?\d+(?:\.\d+){1,2}$/;
+		let tagReleaseCount;
+		let tagVersionLatest;
+		let tagVersionDateLatest;
+		try {
+			const versionTags = (await git.raw(["tag", "--sort=-creatordate"])).trim().split("\n").filter(Boolean).filter((tag) => versionTagPattern.test(tag));
+			tagReleaseCount = versionTags.length > 0 ? versionTags.length : void 0;
+			const match = versionTags[0];
+			if (match) {
+				const tagDate = await git.raw([
+					"log",
+					"-1",
+					"--format=%aI",
+					match
+				]);
+				tagVersionLatest = match.replace(/^v/, "");
+				tagVersionDateLatest = tagDate.trim() || void 0;
+			}
+		} catch {}
+		const remoteStatusEntries = await Promise.all(remotes.map(async (remote) => {
+			for (const branch of ["main", "master"]) {
+				const reference = `${remote.name}/${branch}`;
+				try {
+					const [ahead, behind] = (await git.raw([
+						"rev-list",
+						"--left-right",
+						"--count",
+						`HEAD...${reference}`
+					])).trim().split("	").map(Number);
+					return [remote.name, {
+						ahead,
+						behind
+					}];
+				} catch {}
+			}
+		}));
+		const remoteStatus = {};
+		for (const entry of remoteStatusEntries) if (entry) remoteStatus[entry[0]] = entry[1];
+		const remoteStatusValues = Object.values(remoteStatus);
+		const totalAhead = remoteStatusValues.length > 0 ? remoteStatusValues.reduce((sum, s) => sum + s.ahead, 0) : void 0;
+		const totalBehind = remoteStatusValues.length > 0 ? remoteStatusValues.reduce((sum, s) => sum + s.behind, 0) : void 0;
+		return {
+			data: {
+				branchCount: branchResult.all.length,
+				branchCurrent: branchResult.current,
+				commitCount: logResult.total,
+				commitDateFirst,
+				commitDateLast: logResult.latest?.date ?? void 0,
+				contributorCount: contributors.size,
+				hasLfs,
+				isClean: statusResult.isClean(),
+				isDirty: !statusResult.isClean(),
+				isRemoteAhead: Object.values(remoteStatus).some((s) => s.behind > 0) || void 0,
+				remoteCount: remotes.length,
+				remoteStatus: Object.keys(remoteStatus).length > 0 ? remoteStatus : void 0,
+				submoduleCount,
+				tagCount: tagResult.all.length,
+				tagDateLatest,
+				tagNameLatest,
+				tagReleaseCount,
+				tagVersionDateLatest,
+				tagVersionLatest,
+				totalAhead,
+				totalBehind,
+				trackedFileCount: trackedFiles.length,
+				trackedSizeBytes,
+				uncommittedFileCount: statusResult.files.length
+			},
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { gitStatsSource };

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

@@ -0,0 +1,94 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+
+//#region src/lib/sources/github.d.ts
+type GitHubInfo = {
+  /** ISO 8601 date when the repo was archived, if applicable. */archivedAt?: string; /** Name of the repository's code of conduct. */
+  codeOfConduct?: string; /** Commits the default branch is ahead of the upstream fork parent. */
+  commitsAheadUpstream?: number; /** Commits the default branch is behind the upstream fork parent. */
+  commitsBehindUpstream?: number; /** Number of contributors to the repository. */
+  contributorCount?: number; /** ISO 8601 date when the repo was created. */
+  createdAt?: string; /** GitHub's internal numeric repository ID. */
+  databaseId?: number; /** Name of the default branch (e.g. "main"). */
+  defaultBranch?: string; /** Repository description. */
+  description?: string; /** Total number of discussions. */
+  discussionCount?: number; /** Repository disk usage in bytes. */
+  diskUsageBytes?: number; /** Number of forks. */
+  forkCount?: number; /** URL of the upstream repository this was forked from. */
+  forkedFrom?: string; /** Funding links configured on the repository. */
+  fundingLinks?: Array<{
+    platform: string;
+    url: string;
+  }>; /** Whether a CONTRIBUTING file exists. */
+  hasContributing?: boolean; /** Whether discussions are enabled. */
+  hasDiscussionsEnabled?: boolean; /** Whether issues are enabled. */
+  hasIssuesEnabled?: boolean; /** Whether the repo uses Git LFS (detected via .gitattributes). */
+  hasLfs?: boolean; /** Whether GitHub Pages is enabled. */
+  hasPages?: boolean; /** Whether projects are enabled. */
+  hasProjectsEnabled?: boolean; /** Whether sponsorships are enabled. */
+  hasSponsorshipsEnabled?: boolean; /** Whether vulnerability alerts are enabled. */
+  hasVulnerabilityAlertsEnabled?: boolean; /** Whether the wiki is enabled. */
+  hasWikiEnabled?: boolean; /** Homepage URL set on the repository. */
+  homepageUrl?: string; /** Whether the repository is archived. */
+  isArchived?: boolean; /** Whether the repository is disabled. */
+  isDisabled?: boolean; /** Whether the repository is a fork. */
+  isFork?: boolean; /** Whether the repository belongs to an organization. */
+  isInOrganization?: boolean; /** Whether the repository is a mirror. */
+  isMirror?: boolean; /** Whether the repository is private. */
+  isPrivate?: boolean; /** Whether a security policy is enabled. */
+  isSecurityPolicyEnabled?: boolean; /** Number of closed issues. */
+  issueCountClosed?: number; /** Number of open issues. */
+  issueCountOpen?: number; /** Whether the repository is a template. */
+  isTemplate?: boolean; /** Languages used in the repo, keyed by name with size in bytes. */
+  languages?: Record<string, number>;
+  /** License identifier (unused; codemeta provides this). */
+  /** SPDX license key (e.g. "mit"). */
+  licenseKey?: string; /** Human-readable license name. */
+  licenseName?: string; /** SPDX license identifier (e.g. "MIT"). */
+  licenseSpdxId?: string; /** URL to the license text. */
+  licenseUrl?: string; /** URL of the upstream mirror, if applicable. */
+  mirrorUrl?: string; /** Repository name. */
+  name?: string; /** Full "owner/repo" identifier. */
+  nameWithOwner?: string; /** URL to the repository's Open Graph image. */
+  openGraphImageUrl?: string; /** GitHub username of the repository owner. */
+  ownerLogin?: string; /** Owner type, e.g. "User" or "Organization". */
+  ownerType?: string; /** Full "owner/repo" of the parent fork source. */
+  parentNameWithOwner?: string; /** Primary programming language of the repository. */
+  primaryLanguage?: string; /** Number of closed pull requests. */
+  pullRequestCountClosed?: number; /** Number of merged pull requests. */
+  pullRequestCountMerged?: number; /** Number of open pull requests. */
+  pullRequestCountOpen?: number; /** ISO 8601 date of the most recent push. */
+  pushedAt?: string; /** Total number of releases. */
+  releaseCount?: number; /** ISO 8601 date of the latest release. */
+  releaseDateLatest?: string; /** Total download count across latest release assets. */
+  releaseDownloadCount?: number; /** Tag name of the latest release. */
+  releaseVersionLatest?: string; /** URL to the security policy. */
+  securityPolicyUrl?: string; /** Repository merge and branch settings. */
+  settings?: {
+    /** Whether "Update branch" button is enabled. */allowUpdateBranch?: boolean; /** Whether auto-merge is allowed. */
+    autoMergeAllowed?: boolean; /** Whether branches are deleted after merge. */
+    deleteBranchOnMerge?: boolean; /** Whether forking is allowed. */
+    forkingAllowed?: boolean; /** Whether merge commits are allowed. */
+    mergeCommitAllowed?: boolean; /** Template for merge commit messages. */
+    mergeCommitMessage?: string; /** Template for merge commit titles. */
+    mergeCommitTitle?: string; /** Whether rebase merging is allowed. */
+    rebaseMergeAllowed?: boolean; /** Whether squash merging is allowed. */
+    squashMergeAllowed?: boolean; /** Template for squash merge commit messages. */
+    squashMergeCommitMessage?: string; /** Template for squash merge commit titles. */
+    squashMergeCommitTitle?: string; /** Whether web-based commits require sign-off. */
+    webCommitSignoffRequired?: boolean;
+  }; /** SSH clone URL. */
+  sshUrl?: string; /** Number of stars. */
+  stargazerCount?: number; /** Number of git submodules (detected via .gitmodules). */
+  submoduleCount?: number; /** URL of the template repository this was created from. */
+  templateFrom?: string; /** Repository topics. */
+  topics?: string[]; /** ISO 8601 date the repo was last updated. */
+  updatedAt?: string; /** GitHub URL of the repository. */
+  url?: string; /** Whether a custom Open Graph image is set. */
+  usesCustomOpenGraphImage?: boolean; /** Repository visibility (e.g. "PUBLIC", "PRIVATE"). */
+  visibility?: string; /** Number of open vulnerability alerts. */
+  vulnerabilityAlertCount?: number; /** Number of watchers. */
+  watcherCount?: number;
+};
+type GitHubData = OneOrMany<SourceRecord<GitHubInfo>> | undefined;
+//#endregion
+export { GitHubData };

package/dist/lib/sources/github.js

@@ -0,0 +1,399 @@
+import { log } from "../log.js";
+import { defineSource } from "../source.js";
+import { ensureArray } from "../utilities/template-helpers.js";
+import { gitConfigSource } from "./git-config.js";
+import { z } from "zod";
+import gitUrlParse from "git-url-parse";
+import { Octokit } from "octokit";
+//#region src/lib/sources/github.ts
+const gitHubRepoSchema = z.object({ repository: z.object({
+	allowUpdateBranch: z.boolean(),
+	archivedAt: z.string().nullable(),
+	autoMergeAllowed: z.boolean(),
+	closedIssues: z.object({ totalCount: z.number() }),
+	closedPullRequests: z.object({ totalCount: z.number() }),
+	codeOfConduct: z.object({ name: z.string() }).nullable(),
+	contributingGuidelines: z.object({ body: z.string() }).nullable(),
+	contributorCount: z.number().optional(),
+	createdAt: z.string(),
+	databaseId: z.number(),
+	defaultBranchRef: z.object({ name: z.string() }).nullable(),
+	deleteBranchOnMerge: z.boolean(),
+	description: z.string().nullable(),
+	discussions: z.object({ totalCount: z.number() }),
+	diskUsage: z.number().nullable(),
+	forkCount: z.number(),
+	forkingAllowed: z.boolean(),
+	fundingLinks: z.array(z.object({
+		platform: z.string(),
+		url: z.string()
+	})),
+	gitattributes: z.object({ text: z.string().nullable() }).nullable(),
+	gitmodules: z.object({ text: z.string().nullable() }).nullable(),
+	hasDiscussionsEnabled: z.boolean(),
+	hasIssuesEnabled: z.boolean(),
+	hasProjectsEnabled: z.boolean(),
+	hasSponsorshipsEnabled: z.boolean(),
+	hasVulnerabilityAlertsEnabled: z.boolean(),
+	hasWikiEnabled: z.boolean(),
+	homepageUrl: z.string().nullable(),
+	isArchived: z.boolean(),
+	isDisabled: z.boolean(),
+	isFork: z.boolean(),
+	isInOrganization: z.boolean(),
+	isMirror: z.boolean(),
+	isPrivate: z.boolean(),
+	isSecurityPolicyEnabled: z.boolean(),
+	isTemplate: z.boolean(),
+	languages: z.object({ edges: z.array(z.object({
+		node: z.object({ name: z.string() }),
+		size: z.number()
+	})) }).nullable(),
+	latestRelease: z.object({
+		createdAt: z.string(),
+		releaseAssets: z.object({ nodes: z.array(z.object({ downloadCount: z.number() })) }),
+		tagName: z.string()
+	}).nullable(),
+	licenseInfo: z.object({
+		key: z.string(),
+		name: z.string(),
+		spdxId: z.string().nullable(),
+		url: z.string().nullable()
+	}).nullable(),
+	mergeCommitAllowed: z.boolean(),
+	mergeCommitMessage: z.string(),
+	mergeCommitTitle: z.string(),
+	mergedPullRequests: z.object({ totalCount: z.number() }),
+	mirrorUrl: z.string().nullable(),
+	name: z.string(),
+	nameWithOwner: z.string(),
+	openGraphImageUrl: z.string(),
+	openIssues: z.object({ totalCount: z.number() }),
+	openPullRequests: z.object({ totalCount: z.number() }),
+	owner: z.object({
+		__typename: z.string(),
+		login: z.string()
+	}),
+	parent: z.object({
+		defaultBranchRef: z.object({ name: z.string() }).nullable(),
+		name: z.string(),
+		nameWithOwner: z.string(),
+		owner: z.object({ login: z.string() }),
+		url: z.string()
+	}).nullable(),
+	primaryLanguage: z.object({ name: z.string() }).nullable(),
+	pushedAt: z.string().nullable(),
+	rebaseMergeAllowed: z.boolean(),
+	releases: z.object({ totalCount: z.number() }),
+	repositoryTopics: z.object({ nodes: z.array(z.object({ topic: z.object({ name: z.string() }) })) }),
+	securityPolicyUrl: z.string().nullable(),
+	squashMergeAllowed: z.boolean(),
+	squashMergeCommitMessage: z.string(),
+	squashMergeCommitTitle: z.string(),
+	sshUrl: z.string(),
+	stargazerCount: z.number(),
+	templateRepository: z.object({
+		name: z.string(),
+		owner: z.object({ login: z.string() }),
+		url: z.string()
+	}).nullable(),
+	updatedAt: z.string(),
+	url: z.string(),
+	usesCustomOpenGraphImage: z.boolean(),
+	visibility: z.string(),
+	vulnerabilityAlerts: z.object({ totalCount: z.number() }).nullable(),
+	watchers: z.object({ totalCount: z.number() }),
+	webCommitSignoffRequired: z.boolean()
+}) });
+/**
+* Extract a GitHub owner/repo from git config remote URLs.
+* Prefers the "origin" remote, falls back to the first GitHub remote found.
+*/
+function getGitHubRemoteFromConfig(remotes) {
+	if (!remotes) return void 0;
+	const sorted = Object.entries(remotes).toSorted(([a], [b]) => {
+		if (a === "origin") return -1;
+		if (b === "origin") return 1;
+		return 0;
+	});
+	for (const [, remote] of sorted) {
+		const { url } = remote;
+		if (!url) continue;
+		try {
+			const parsed = gitUrlParse(url);
+			if (parsed.source === "github.com" && parsed.owner && parsed.name) return {
+				owner: parsed.owner,
+				repo: parsed.name
+			};
+		} catch {}
+	}
+}
+const graphqlQuery = `
+	query($owner: String!, $repo: String!) {
+		repository(owner: $owner, name: $repo) {
+			name
+			nameWithOwner
+			owner { __typename login }
+			url
+			description
+			homepageUrl
+			createdAt
+			updatedAt
+			pushedAt
+			archivedAt
+			databaseId
+			isArchived
+			isDisabled
+			isFork
+			isInOrganization
+			isMirror
+			isPrivate
+			isTemplate
+			visibility
+			diskUsage
+			stargazerCount
+			forkCount
+			sshUrl
+			hasWikiEnabled
+			hasDiscussionsEnabled
+			hasIssuesEnabled
+			hasProjectsEnabled
+			hasSponsorshipsEnabled
+			hasVulnerabilityAlertsEnabled
+			isSecurityPolicyEnabled
+			securityPolicyUrl
+			openGraphImageUrl
+			usesCustomOpenGraphImage
+			autoMergeAllowed
+			allowUpdateBranch
+			deleteBranchOnMerge
+			forkingAllowed
+			mergeCommitAllowed
+			mergeCommitMessage
+			mergeCommitTitle
+			mirrorUrl
+			rebaseMergeAllowed
+			squashMergeAllowed
+			squashMergeCommitMessage
+			squashMergeCommitTitle
+			webCommitSignoffRequired
+			codeOfConduct { name }
+			contributingGuidelines { body }
+			fundingLinks { platform url }
+			licenseInfo { key name spdxId url }
+			defaultBranchRef { name }
+			primaryLanguage { name }
+			parent {
+				owner { login }
+				name
+				nameWithOwner
+				url
+				defaultBranchRef { name }
+			}
+			templateRepository {
+				owner { login }
+				name
+				url
+			}
+			gitattributes: object(expression: "HEAD:.gitattributes") {
+				... on Blob { text }
+			}
+			gitmodules: object(expression: "HEAD:.gitmodules") {
+				... on Blob { text }
+			}
+			openIssues: issues(states: OPEN) { totalCount }
+			closedIssues: issues(states: CLOSED) { totalCount }
+			openPullRequests: pullRequests(states: OPEN) { totalCount }
+			closedPullRequests: pullRequests(states: CLOSED) { totalCount }
+			mergedPullRequests: pullRequests(states: MERGED) { totalCount }
+			discussions { totalCount }
+			vulnerabilityAlerts(states: OPEN) { totalCount }
+			watchers { totalCount }
+			releases { totalCount }
+			latestRelease {
+				tagName
+				createdAt
+				releaseAssets(first: 100) {
+					nodes { downloadCount }
+				}
+			}
+			repositoryTopics(first: 50) {
+				nodes { topic { name } }
+			}
+			languages(first: 20, orderBy: { field: SIZE, direction: DESC }) {
+				edges {
+					node { name }
+					size
+				}
+			}
+		}
+	}
+`;
+async function checkHasPages(octokit, owner, repo) {
+	try {
+		return (await octokit.rest.repos.get({
+			owner,
+			repo
+		})).data.has_pages;
+	} catch {
+		return false;
+	}
+}
+async function getUpstreamComparison(octokit, owner, repo, defaultBranch, parent) {
+	const parentBranch = parent.defaultBranchRef?.name;
+	if (!parentBranch) return void 0;
+	try {
+		const response = await octokit.rest.repos.compareCommitsWithBasehead({
+			basehead: `${parent.owner.login}:${parentBranch}...${owner}:${defaultBranch}`,
+			owner,
+			repo
+		});
+		return {
+			ahead: response.data.ahead_by,
+			behind: response.data.behind_by
+		};
+	} catch {
+		return;
+	}
+}
+function countSubmodules(gitmodulesText) {
+	if (!gitmodulesText) return 0;
+	return gitmodulesText.match(/\[submodule\s/g)?.length ?? 0;
+}
+function detectLfs(gitattributesText) {
+	if (!gitattributesText) return false;
+	return gitattributesText.includes("filter=lfs");
+}
+function extractLanguages(data) {
+	const languages = {};
+	if (data.languages?.edges) for (const edge of data.languages.edges) languages[edge.node.name] = edge.size;
+	return languages;
+}
+function mapRepoData(data, extras) {
+	const releaseDownloadCount = (data.latestRelease?.releaseAssets.nodes.reduce((sum, asset) => sum + asset.downloadCount, 0) ?? 0) || void 0;
+	return {
+		archivedAt: data.archivedAt ?? void 0,
+		codeOfConduct: data.codeOfConduct?.name ?? void 0,
+		commitsAheadUpstream: extras.commitsAheadUpstream,
+		commitsBehindUpstream: extras.commitsBehindUpstream,
+		contributorCount: data.contributorCount,
+		createdAt: data.createdAt,
+		databaseId: data.databaseId,
+		defaultBranch: data.defaultBranchRef?.name ?? void 0,
+		description: data.description ?? void 0,
+		discussionCount: data.discussions.totalCount,
+		diskUsageBytes: data.diskUsage === null ? void 0 : data.diskUsage * 1e3,
+		forkCount: data.forkCount,
+		forkedFrom: data.parent?.url ?? void 0,
+		fundingLinks: data.fundingLinks.length > 0 ? data.fundingLinks.map((link) => ({
+			platform: link.platform,
+			url: link.url
+		})) : void 0,
+		hasContributing: data.contributingGuidelines !== null,
+		hasDiscussionsEnabled: data.hasDiscussionsEnabled,
+		hasIssuesEnabled: data.hasIssuesEnabled,
+		hasLfs: detectLfs(data.gitattributes?.text ?? void 0),
+		hasPages: extras.hasPages,
+		hasProjectsEnabled: data.hasProjectsEnabled,
+		hasSponsorshipsEnabled: data.hasSponsorshipsEnabled,
+		hasVulnerabilityAlertsEnabled: data.hasVulnerabilityAlertsEnabled,
+		hasWikiEnabled: data.hasWikiEnabled,
+		homepageUrl: data.homepageUrl === "" ? void 0 : data.homepageUrl ?? void 0,
+		isArchived: data.isArchived,
+		isDisabled: data.isDisabled,
+		isFork: data.isFork,
+		isInOrganization: data.isInOrganization,
+		isMirror: data.isMirror,
+		isPrivate: data.isPrivate,
+		isSecurityPolicyEnabled: data.isSecurityPolicyEnabled,
+		issueCountClosed: data.closedIssues.totalCount,
+		issueCountOpen: data.openIssues.totalCount,
+		isTemplate: data.isTemplate,
+		languages: extractLanguages(data),
+		licenseKey: data.licenseInfo?.key ?? void 0,
+		licenseName: data.licenseInfo?.name ?? void 0,
+		licenseSpdxId: data.licenseInfo?.spdxId === "NOASSERTION" ? void 0 : data.licenseInfo?.spdxId ?? void 0,
+		licenseUrl: data.licenseInfo?.url ?? void 0,
+		mirrorUrl: data.mirrorUrl ?? void 0,
+		name: data.name,
+		nameWithOwner: data.nameWithOwner,
+		openGraphImageUrl: data.openGraphImageUrl,
+		ownerLogin: data.owner.login,
+		ownerType: data.owner.__typename,
+		parentNameWithOwner: data.parent?.nameWithOwner ?? void 0,
+		primaryLanguage: data.primaryLanguage?.name ?? void 0,
+		pullRequestCountClosed: data.closedPullRequests.totalCount,
+		pullRequestCountMerged: data.mergedPullRequests.totalCount,
+		pullRequestCountOpen: data.openPullRequests.totalCount,
+		pushedAt: data.pushedAt ?? void 0,
+		releaseCount: data.releases.totalCount || void 0,
+		releaseDateLatest: data.latestRelease?.createdAt ?? void 0,
+		releaseDownloadCount,
+		releaseVersionLatest: data.latestRelease?.tagName ?? void 0,
+		securityPolicyUrl: data.securityPolicyUrl ?? void 0,
+		settings: {
+			allowUpdateBranch: data.allowUpdateBranch,
+			autoMergeAllowed: data.autoMergeAllowed,
+			deleteBranchOnMerge: data.deleteBranchOnMerge,
+			forkingAllowed: data.forkingAllowed,
+			mergeCommitAllowed: data.mergeCommitAllowed,
+			mergeCommitMessage: data.mergeCommitMessage,
+			mergeCommitTitle: data.mergeCommitTitle,
+			rebaseMergeAllowed: data.rebaseMergeAllowed,
+			squashMergeAllowed: data.squashMergeAllowed,
+			squashMergeCommitMessage: data.squashMergeCommitMessage,
+			squashMergeCommitTitle: data.squashMergeCommitTitle,
+			webCommitSignoffRequired: data.webCommitSignoffRequired
+		},
+		sshUrl: data.sshUrl,
+		stargazerCount: data.stargazerCount,
+		submoduleCount: countSubmodules(data.gitmodules?.text ?? void 0),
+		templateFrom: data.templateRepository?.url ?? void 0,
+		topics: data.repositoryTopics.nodes.map((n) => n.topic.name),
+		updatedAt: data.updatedAt,
+		url: data.url,
+		usesCustomOpenGraphImage: data.usesCustomOpenGraphImage,
+		visibility: data.visibility,
+		vulnerabilityAlertCount: data.vulnerabilityAlerts?.totalCount ?? void 0,
+		watcherCount: data.watchers.totalCount
+	};
+}
+const githubSource = defineSource({
+	async discover(context) {
+		let gitRemotes = ensureArray(context.metadata?.gitConfig).map((config) => config.data.remote).filter((remote) => remote !== void 0);
+		if (gitRemotes.length === 0 && !context.completedSources?.has("gitConfig")) {
+			log.warn(`Missing gitConfig in source context metadata for ${context.options.path}, extracting it now...`);
+			gitRemotes = ensureArray(await gitConfigSource.extract(context)).map((config) => config.data.remote).filter((remote) => remote !== void 0);
+		}
+		return [...new Set(gitRemotes.map((config) => getGitHubRemoteFromConfig(config)).filter((remote) => remote !== void 0).map((remote) => `${remote.owner}/${remote.repo}`))];
+	},
+	key: "github",
+	async parse(input, context) {
+		log.debug("Extracting GitHub metadata...");
+		const [owner, repo] = input.split("/");
+		const octokit = new Octokit(context.options.credentials?.githubToken ? { auth: context.options.credentials.githubToken } : void 0);
+		const [graphqlResult, hasPages] = await Promise.all([octokit.graphql(graphqlQuery, {
+			owner,
+			repo
+		}), checkHasPages(octokit, owner, repo)]);
+		const data = gitHubRepoSchema.parse(graphqlResult).repository;
+		let commitsAheadUpstream;
+		let commitsBehindUpstream;
+		if (data.isFork && data.parent && data.defaultBranchRef) {
+			const comparison = await getUpstreamComparison(octokit, owner, repo, data.defaultBranchRef.name, data.parent);
+			commitsAheadUpstream = comparison?.ahead;
+			commitsBehindUpstream = comparison?.behind;
+		}
+		return {
+			data: mapRepoData(data, {
+				commitsAheadUpstream,
+				commitsBehindUpstream,
+				hasPages
+			}),
+			source: `https://github.com/${owner}/${repo}`
+		};
+	},
+	phase: 2
+});
+//#endregion
+export { githubSource };

package/dist/lib/sources/go-go-mod.d.ts

@@ -0,0 +1,19 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/go-go-mod.d.ts
+declare const goModDataSchema: z.ZodObject<{
+  dependencies: z.ZodArray<z.ZodObject<{
+    module: z.ZodString;
+    version: z.ZodString;
+  }, z.core.$strip>>;
+  go_version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  module: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  repository_url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  tool_dependencies: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** Parsed go.mod metadata */
+type GoMod = z.infer<typeof goModDataSchema>;
+type GoGoModData = OneOrMany<SourceRecord<GoMod>> | undefined;
+//#endregion
+export { GoGoModData };

package/dist/lib/sources/go-go-mod.js

@@ -0,0 +1,38 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, stringArray } from "../utilities/schema-primitives.js";
+import { parseGoMod } from "../parsers/go-mod-parser.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+//#region src/lib/sources/go-go-mod.ts
+const goModDependencySchema = z.object({
+	module: z.string(),
+	version: z.string()
+});
+const goModDataSchema = z.object({
+	dependencies: z.array(goModDependencySchema),
+	go_version: nonEmptyString,
+	module: nonEmptyString,
+	repository_url: optionalUrl,
+	tool_dependencies: stringArray
+});
+/** Parse a go.mod file string and validate through the schema. */
+function parse(content) {
+	return goModDataSchema.parse(parseGoMod(content));
+}
+const goGoModSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["go.mod"]);
+	},
+	key: "goGoMod",
+	async parse(input, context) {
+		return {
+			data: parse(await readFile(resolve(context.options.path, input), "utf8")),
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { goGoModSource };