@decohere/ci-tools 0.0.1-dev.10

package/src/github/create-issue.mjs

@@ -0,0 +1,173 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+
+function parseArgs(argv) {
+	const args = argv.slice(2);
+	const flags = {
+		repo: process.env.GITHUB_REPOSITORY ?? "typesmiths/decohere",
+		type: "Task",
+		typeId: undefined,
+		title: undefined,
+		bodyFile: undefined,
+		allowDuplicate: false,
+	};
+
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--allow-duplicate") {
+			flags.allowDuplicate = true;
+			continue;
+		}
+		const next = args[index + 1];
+		if (next == null) throw new Error(`Missing value for ${arg}`);
+		switch (arg) {
+			case "--repo":
+				flags.repo = next;
+				index += 1;
+				break;
+			case "--type":
+				flags.type = next;
+				index += 1;
+				break;
+			case "--type-id":
+				flags.typeId = next;
+				index += 1;
+				break;
+			case "--title":
+				flags.title = next;
+				index += 1;
+				break;
+			case "--body-file":
+				flags.bodyFile = next;
+				index += 1;
+				break;
+			default:
+				throw new Error(`Unknown argument: ${arg}`);
+		}
+	}
+
+	if (!flags.title) throw new Error("Missing required argument: --title");
+	if (!flags.bodyFile) throw new Error("Missing required argument: --body-file");
+	if (!existsSync(flags.bodyFile)) throw new Error(`Body file not found: ${flags.bodyFile}`);
+	return flags;
+}
+
+function runGh(args) {
+	const result = spawnSync("gh", args, { encoding: "utf8", env: process.env });
+	if (result.status !== 0)
+		throw new Error(result.stderr || result.stdout || `gh command failed: ${args.join(" ")}`);
+	return result.stdout;
+}
+
+function runGhJson(args) {
+	return JSON.parse(runGh(args));
+}
+
+function splitRepo(repo) {
+	const [owner, name] = repo.split("/");
+	if (!owner || !name) throw new Error(`Invalid repo format: ${repo}. Expected owner/name`);
+	return { owner, name };
+}
+
+function findExistingIssue(repo, title) {
+	const output = runGhJson([
+		"issue",
+		"list",
+		"--repo",
+		repo,
+		"--state",
+		"all",
+		"--limit",
+		"200",
+		"--search",
+		`${title} in:title`,
+		"--json",
+		"number,title,state,url",
+	]);
+	return output.find((issue) => issue.title === title);
+}
+
+function getRepositoryMetadata(repo, typeName) {
+	const { owner, name } = splitRepo(repo);
+	const query = `query($owner:String!, $name:String!) { repository(owner:$owner, name:$name) { id issueTypes(first:20) { nodes { id name } } } }`;
+	const response = runGhJson([
+		"api",
+		"graphql",
+		"-f",
+		`query=${query}`,
+		"-f",
+		`owner=${owner}`,
+		"-f",
+		`name=${name}`,
+	]);
+	const repository = response?.data?.repository;
+	if (!repository?.id) throw new Error(`Repository not found: ${repo}`);
+	const typeMatch = repository.issueTypes?.nodes?.find((node) => node.name === typeName);
+	if (!typeMatch) {
+		const available = (repository.issueTypes?.nodes ?? []).map((node) => node.name).join(", ");
+		throw new Error(`Issue type "${typeName}" not found. Available: ${available}`);
+	}
+	return { repositoryId: repository.id, issueTypeId: typeMatch.id };
+}
+
+function createIssue(repositoryId, issueTypeId, title, body) {
+	const mutation = `mutation($repositoryId:ID!, $issueTypeId:ID!, $title:String!, $body:String!) { createIssue(input:{repositoryId:$repositoryId, issueTypeId:$issueTypeId, title:$title, body:$body}) { issue { number title url state } } }`;
+	const response = runGhJson([
+		"api",
+		"graphql",
+		"-f",
+		`query=${mutation}`,
+		"-f",
+		`repositoryId=${repositoryId}`,
+		"-f",
+		`issueTypeId=${issueTypeId}`,
+		"-f",
+		`title=${title}`,
+		"-f",
+		`body=${body}`,
+	]);
+	return response?.data?.createIssue?.issue;
+}
+
+const args = parseArgs(process.argv);
+const body = readFileSync(args.bodyFile, "utf8");
+
+if (!args.allowDuplicate) {
+	const existing = findExistingIssue(args.repo, args.title);
+	if (existing) {
+		console.log(
+			`Existing issue found (duplicate prevented): #${existing.number} ${existing.url}`,
+		);
+		process.exit(0);
+	}
+}
+
+let metadata;
+if (args.typeId) {
+	const { owner, name } = splitRepo(args.repo);
+	const query = `query($owner:String!, $name:String!) { repository(owner:$owner, name:$name) { id } }`;
+	const response = runGhJson([
+		"api",
+		"graphql",
+		"-f",
+		`query=${query}`,
+		"-f",
+		`owner=${owner}`,
+		"-f",
+		`name=${name}`,
+	]);
+	const repositoryId = response?.data?.repository?.id;
+	if (!repositoryId) throw new Error(`Repository not found: ${args.repo}`);
+	metadata = { repositoryId, issueTypeId: args.typeId };
+} else {
+	metadata = getRepositoryMetadata(args.repo, args.type);
+}
+
+const createdIssue = createIssue(
+	metadata.repositoryId,
+	metadata.issueTypeId,
+	args.title,
+	body,
+);
+if (!createdIssue) throw new Error("Issue creation failed: API response missing issue data");
+console.log(`Created issue: #${createdIssue.number} ${createdIssue.url}`);

package/src/github/create-or-update-pr.mjs

@@ -0,0 +1,143 @@
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+function getArg(name, fallback) {
+	const equals = process.argv.find((arg) => arg.startsWith(`--${name}=`));
+	if (equals) return equals.slice(name.length + 3);
+	const index = process.argv.indexOf(`--${name}`);
+	if (index >= 0) return process.argv[index + 1];
+	return fallback;
+}
+
+function hasFlag(name) {
+	return process.argv.includes(`--${name}`);
+}
+
+function run(command) {
+	return execSync(command, { encoding: "utf8" }).trim();
+}
+
+function parseRepoFromRemoteUrl(url) {
+	const sshMatch = url.match(/github\.com:([^/]+)\/([^/.]+)(?:\.git)?$/);
+	if (sshMatch) return { owner: sshMatch[1], repo: sshMatch[2] };
+	const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.]+)(?:\.git)?$/);
+	if (httpsMatch) return { owner: httpsMatch[1], repo: httpsMatch[2] };
+	throw new Error(`Unable to parse GitHub owner/repo from remote URL: ${url}`);
+}
+
+async function request(apiBaseUrl, token, method, path, body) {
+	const response = await fetch(`${apiBaseUrl}${path}`, {
+		method,
+		headers: {
+			Authorization: `Bearer ${token}`,
+			Accept: "application/vnd.github+json",
+			"X-GitHub-Api-Version": "2022-11-28",
+			"Content-Type": "application/json",
+		},
+		body: body == null ? undefined : JSON.stringify(body),
+	});
+	if (!response.ok) {
+		const message = await response.text();
+		throw new Error(`GitHub API ${method} ${path} failed (${response.status}): ${message}`);
+	}
+	return response.status === 204 ? undefined : response.json();
+}
+
+if (hasFlag("help")) {
+	console.log(`Usage: node create-or-update-pr.mjs [options]
+
+Required:
+  --title <title>                PR title
+  --body <markdown>              PR body markdown
+    or
+  --body-file <path>             Read PR body markdown from file
+
+Optional:
+  --base <branch>                Base branch (default: main)
+  --head <branch>                Head branch (default: current git branch)
+  --draft                        Create as draft
+  --labels <a,b,c>               Apply labels
+  --reviewers <u1,u2>            Request reviewers
+  --dry-run                      Print intended operation without calling API
+  --help                         Show this help
+
+Auth: Set GITHUB_TOKEN or GH_TOKEN
+`);
+	process.exit(0);
+}
+
+const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+if (token == null || token.length === 0) throw new Error("Missing GITHUB_TOKEN or GH_TOKEN");
+
+const apiBaseUrl = process.env.GITHUB_API_URL ?? "https://api.github.com";
+const base = getArg("base", "main");
+const head = getArg("head", run("git rev-parse --abbrev-ref HEAD"));
+const title = getArg("title");
+const bodyFile = getArg("body-file");
+const body = getArg("body", bodyFile ? readFileSync(bodyFile, "utf8") : undefined);
+const draft = hasFlag("draft");
+const dryRun = hasFlag("dry-run");
+const labels = (getArg("labels") ?? "")
+	.split(",")
+	.map((v) => v.trim())
+	.filter(Boolean);
+const reviewers = (getArg("reviewers") ?? "")
+	.split(",")
+	.map((v) => v.trim())
+	.filter(Boolean);
+
+if (!title) throw new Error("Missing required argument: --title");
+if (!body) throw new Error("Missing required argument: --body or --body-file");
+
+const remoteUrl = run("git config --get remote.origin.url");
+const parsedRepo = parseRepoFromRemoteUrl(remoteUrl);
+const owner = getArg("owner", parsedRepo.owner);
+const repo = getArg("repo", parsedRepo.repo);
+
+const findPath = `/repos/${owner}/${repo}/pulls?state=open&head=${encodeURIComponent(`${owner}:${head}`)}&base=${encodeURIComponent(base)}`;
+
+if (dryRun) {
+	console.log(
+		JSON.stringify({ owner, repo, base, head, title, draft, labels, reviewers }, null, 2),
+	);
+	process.exit(0);
+}
+
+const existing = await request(apiBaseUrl, token, "GET", findPath);
+const pr = existing[0]
+	? await request(
+			apiBaseUrl,
+			token,
+			"PATCH",
+			`/repos/${owner}/${repo}/pulls/${existing[0].number}`,
+			{ title, body, base },
+		)
+	: await request(apiBaseUrl, token, "POST", `/repos/${owner}/${repo}/pulls`, {
+			title,
+			body,
+			base,
+			head,
+			draft,
+		});
+
+if (labels.length > 0) {
+	await request(
+		apiBaseUrl,
+		token,
+		"POST",
+		`/repos/${owner}/${repo}/issues/${pr.number}/labels`,
+		{ labels },
+	);
+}
+
+if (reviewers.length > 0) {
+	await request(
+		apiBaseUrl,
+		token,
+		"POST",
+		`/repos/${owner}/${repo}/pulls/${pr.number}/requested_reviewers`,
+		{ reviewers },
+	);
+}
+
+console.log(`${existing[0] ? "Updated" : "Created"} PR #${pr.number}: ${pr.html_url}`);

package/src/github/ensure-metadata.mjs

@@ -0,0 +1,295 @@
+import { spawnSync } from "node:child_process";
+
+function parseArgs(argv) {
+	const args = argv.slice(2);
+	const flags = {
+		repo: process.env.GITHUB_REPOSITORY ?? "typesmiths/decohere",
+		project: "Ark",
+		sprintField: "Sprint",
+		estimateField: "Estimate (days)",
+		iteration: undefined,
+		estimate: undefined,
+		apply: false,
+	};
+
+	let issueNumber;
+	for (let i = 0; i < args.length; i += 1) {
+		const arg = args[i];
+		if (!arg.startsWith("--") && issueNumber == null) {
+			issueNumber = Number(arg);
+			continue;
+		}
+		if (arg === "--apply") {
+			flags.apply = true;
+			continue;
+		}
+		const next = args[i + 1];
+		if (next == null) throw new Error(`Missing value for ${arg}`);
+		switch (arg) {
+			case "--repo":
+				flags.repo = next;
+				i += 1;
+				break;
+			case "--project":
+				flags.project = next;
+				i += 1;
+				break;
+			case "--sprint-field":
+				flags.sprintField = next;
+				i += 1;
+				break;
+			case "--estimate-field":
+				flags.estimateField = next;
+				i += 1;
+				break;
+			case "--iteration":
+				flags.iteration = next;
+				i += 1;
+				break;
+			case "--estimate": {
+				const value = Number.parseFloat(next);
+				if (!Number.isFinite(value) || value < 0)
+					throw new Error(`Invalid --estimate value: ${next}`);
+				flags.estimate = value;
+				i += 1;
+				break;
+			}
+			default:
+				throw new Error(`Unknown argument: ${arg}`);
+		}
+	}
+
+	if (!Number.isInteger(issueNumber) || issueNumber <= 0) {
+		throw new Error(
+			"Usage: node ensure-metadata.mjs <issue-number> [--repo owner/name] [--project Ark] [--apply]",
+		);
+	}
+
+	return { issueNumber, ...flags };
+}
+
+function runGh(args) {
+	const result = spawnSync("gh", args, { encoding: "utf8", env: process.env });
+	if (result.status !== 0)
+		throw new Error(result.stderr || result.stdout || `gh command failed: ${args.join(" ")}`);
+	return result.stdout;
+}
+
+function runGhJson(args) {
+	return JSON.parse(runGh(args));
+}
+
+function splitRepo(repo) {
+	const [owner, name] = repo.split("/");
+	if (!owner || !name) throw new Error(`Invalid repo format: ${repo}. Expected owner/name`);
+	return { owner, name };
+}
+
+function getIssue(repo, issueNumber) {
+	const { owner, name } = splitRepo(repo);
+	const query = `query($owner:String!, $name:String!, $number:Int!) { repository(owner:$owner, name:$name) { issue(number:$number) { id number title state projectItems(first:50) { nodes { id project { id title } fieldValues(first:50) { nodes { ... on ProjectV2ItemFieldNumberValue { number field { ... on ProjectV2FieldCommon { name } } } ... on ProjectV2ItemFieldIterationValue { title iterationId field { ... on ProjectV2FieldCommon { name } } } ... on ProjectV2ItemFieldSingleSelectValue { name optionId field { ... on ProjectV2FieldCommon { name } } } } } } } } } }`;
+	const response = runGhJson([
+		"api",
+		"graphql",
+		"-f",
+		`query=${query}`,
+		"-f",
+		`owner=${owner}`,
+		"-f",
+		`name=${name}`,
+		"-F",
+		`number=${issueNumber}`,
+	]);
+	const issue = response?.data?.repository?.issue;
+	if (!issue) throw new Error(`Issue #${issueNumber} not found in ${repo}`);
+	return issue;
+}
+
+function getProjectByTitle(org, projectTitle) {
+	const query = `query($org:String!) { organization(login:$org) { projectsV2(first:50) { nodes { id title fields(first:50) { nodes { ... on ProjectV2Field { id name } ... on ProjectV2IterationField { id name configuration { iterations { id title } } } ... on ProjectV2SingleSelectField { id name options { id name } } } } } } } }`;
+	const response = runGhJson(["api", "graphql", "-f", `query=${query}`, "-f", `org=${org}`]);
+	const projects = response?.data?.organization?.projectsV2?.nodes ?? [];
+	const project = projects.find((p) => p.title === projectTitle);
+	if (!project) throw new Error(`Project "${projectTitle}" not found for org "${org}"`);
+	return project;
+}
+
+function addIssueToProject(projectId, issueId) {
+	const mutation = `mutation($project:ID!, $content:ID!) { addProjectV2ItemById(input:{projectId:$project, contentId:$content}) { item { id } } }`;
+	runGh([
+		"api",
+		"graphql",
+		"-f",
+		`query=${mutation}`,
+		"-f",
+		`project=${projectId}`,
+		"-f",
+		`content=${issueId}`,
+	]);
+}
+
+function getProjectItem(issue, projectTitle) {
+	return issue.projectItems?.nodes?.find((item) => item.project?.title === projectTitle);
+}
+
+function getFieldValue(projectItem, fieldName) {
+	return projectItem?.fieldValues?.nodes?.find((node) => node?.field?.name === fieldName);
+}
+
+function computeMissing(issue, projectTitle, sprintFieldName, estimateFieldName) {
+	const projectItem = getProjectItem(issue, projectTitle);
+	const sprintValue = projectItem
+		? getFieldValue(projectItem, sprintFieldName)?.title
+		: undefined;
+	const estimateValue = projectItem
+		? getFieldValue(projectItem, estimateFieldName)?.number
+		: undefined;
+	return {
+		project: projectItem == null,
+		sprint: sprintValue == null,
+		estimate: estimateValue == null,
+		sprintValue,
+		estimateValue,
+	};
+}
+
+function getRequiredField(project, fieldName) {
+	const field = (project?.fields?.nodes ?? []).find((node) => node?.name === fieldName);
+	if (!field?.id)
+		throw new Error(`Field "${fieldName}" not found on project "${project.title}"`);
+	return field;
+}
+
+function setProjectItemNumberField(projectId, itemId, fieldId, value) {
+	const mutation = `mutation($project:ID!, $item:ID!, $field:ID!, $value:Float!) { updateProjectV2ItemFieldValue(input:{projectId:$project,itemId:$item,fieldId:$field,value:{number:$value}}) { projectV2Item { id } } }`;
+	runGh([
+		"api",
+		"graphql",
+		"-f",
+		`query=${mutation}`,
+		"-f",
+		`project=${projectId}`,
+		"-f",
+		`item=${itemId}`,
+		"-f",
+		`field=${fieldId}`,
+		"-F",
+		`value=${value}`,
+	]);
+}
+
+function setProjectItemIterationField(projectId, itemId, fieldId, iterationId) {
+	const mutation = `mutation($project:ID!, $item:ID!, $field:ID!, $iterationId:String!) { updateProjectV2ItemFieldValue(input:{projectId:$project,itemId:$item,fieldId:$field,value:{iterationId:$iterationId}}) { projectV2Item { id } } }`;
+	runGh([
+		"api",
+		"graphql",
+		"-f",
+		`query=${mutation}`,
+		"-f",
+		`project=${projectId}`,
+		"-f",
+		`item=${itemId}`,
+		"-f",
+		`field=${fieldId}`,
+		"-f",
+		`iterationId=${iterationId}`,
+	]);
+}
+
+function setProjectItemSingleSelectField(projectId, itemId, fieldId, optionId) {
+	const mutation = `mutation($project:ID!, $item:ID!, $field:ID!, $optionId:String!) { updateProjectV2ItemFieldValue(input:{projectId:$project,itemId:$item,fieldId:$field,value:{singleSelectOptionId:$optionId}}) { projectV2Item { id } } }`;
+	runGh([
+		"api",
+		"graphql",
+		"-f",
+		`query=${mutation}`,
+		"-f",
+		`project=${projectId}`,
+		"-f",
+		`item=${itemId}`,
+		"-f",
+		`field=${fieldId}`,
+		"-f",
+		`optionId=${optionId}`,
+	]);
+}
+
+function applySprintValue(project, projectId, itemId, sprintFieldName, iterationName) {
+	const sprintField = getRequiredField(project, sprintFieldName);
+	if (sprintField?.configuration?.iterations) {
+		const iteration = sprintField.configuration.iterations.find(
+			(v) => v.title === iterationName,
+		);
+		if (!iteration)
+			throw new Error(`Iteration "${iterationName}" not found in field "${sprintFieldName}"`);
+		setProjectItemIterationField(projectId, itemId, sprintField.id, iteration.id);
+		return;
+	}
+	if (sprintField?.options) {
+		const option = sprintField.options.find((v) => v.name === iterationName);
+		if (!option)
+			throw new Error(`Option "${iterationName}" not found in field "${sprintFieldName}"`);
+		setProjectItemSingleSelectField(projectId, itemId, sprintField.id, option.id);
+		return;
+	}
+	throw new Error(`Field "${sprintFieldName}" is not an iteration/single-select field`);
+}
+
+function printSummary(issue, missing, projectTitle, sprintFieldName, estimateFieldName) {
+	console.log(`#${issue.number} ${issue.title}`);
+	console.log(`- state: ${issue.state}`);
+	console.log(`- sprint (${sprintFieldName}): ${missing.sprintValue ?? "none (backlog)"}`);
+	console.log(`- estimate (${estimateFieldName}): ${missing.estimateValue ?? "none"}`);
+	console.log(
+		`- project assignment (${projectTitle}): ${missing.project ? "missing" : "present"}`,
+	);
+}
+
+const args = parseArgs(process.argv);
+const { owner } = splitRepo(args.repo);
+const issue = getIssue(args.repo, args.issueNumber);
+let missing = computeMissing(issue, args.project, args.sprintField, args.estimateField);
+
+let project;
+if (args.apply) {
+	if (missing.project) {
+		project = getProjectByTitle(owner, args.project);
+		addIssueToProject(project.id, issue.id);
+	}
+
+	let refreshed = getIssue(args.repo, args.issueNumber);
+	let refreshedItem = getProjectItem(refreshed, args.project);
+	if (!project) project = getProjectByTitle(owner, args.project);
+	if (!refreshedItem)
+		throw new Error(
+			`Issue #${args.issueNumber} is still not assigned to project "${args.project}"`,
+		);
+
+	if (missing.sprint && args.iteration) {
+		applySprintValue(project, project.id, refreshedItem.id, args.sprintField, args.iteration);
+		refreshed = getIssue(args.repo, args.issueNumber);
+		refreshedItem = getProjectItem(refreshed, args.project);
+	}
+
+	if (missing.estimate) {
+		if (args.estimate == null)
+			throw new Error("Issue is missing estimate. Re-run with --estimate <days> --apply");
+		const estimateField = getRequiredField(project, args.estimateField);
+		setProjectItemNumberField(project.id, refreshedItem.id, estimateField.id, args.estimate);
+	}
+
+	const finalIssue = getIssue(args.repo, args.issueNumber);
+	missing = computeMissing(finalIssue, args.project, args.sprintField, args.estimateField);
+	printSummary(finalIssue, missing, args.project, args.sprintField, args.estimateField);
+} else {
+	printSummary(issue, missing, args.project, args.sprintField, args.estimateField);
+}
+
+if (missing.project || missing.estimate) {
+	console.error(
+		"Issue metadata requirements not met (project + estimate; sprint optional/backlog).",
+	);
+	process.exit(2);
+}
+
+console.log("Issue metadata requirements satisfied.");