atlass 1.10.0 → 1.11.0

package/README.md

@@ -97,6 +97,31 @@ body sent is everything between the H1 and `## Comments`.
 - Confluence uploads local images referenced in the body as attachments. Jira
   update does not support image changes yet.
 
+## Create
+
+```bash
+atlass jira create                              # prompts for everything
+atlass jira create BSC Bug --summary "Login loops" --priority High --label auth
+atlass jira create BSC Task -s "Rotate keys" --description-file notes.md --assignee me
+atlass jira create BSC Defect -s "..." --component API --field severity=S2 --dry-run
+atlass jira fields BSC                          # issue types you can create
+atlass jira fields BSC Defect                   # the create form for one type
+```
+
+With no field flags on a terminal, `create` walks through the create screen:
+required fields, a pick list of optional ones, then a review and confirm.
+Multi-line fields open `$EDITOR` for Markdown.
+
+Any field flag, `--no-input`, or a non-terminal switches to strict mode:
+nothing is prompted, and the command fails before creating anything if a
+required field is missing, a value is not allowed, or a field is not on the
+create screen. `--field NAME=VALUE` takes the display name or id. Multi-value
+fields take commas or repeated flags; cascading selects take `Parent > Child`;
+assignees take `me`, an account id, or a name matching one assignable user.
+
+`--dry-run` prints the resolved payload. `--json` prints the created key, id,
+and URL. `jira fields` shows what each field expects.
+
 ## List
 
 ```bash

package/dist/bitbucket.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as buildStandalone, r as fail } from "./build-Colq1d4N.mjs";
+import { n as buildStandalone, r as fail } from "./build-wKtbjBhd.mjs";
 //#region src/bitbucket.ts
 buildStandalone("bitbucket").parseAsync().catch(fail);
 //#endregion

package/dist/{build-Colq1d4N.mjs → build-wKtbjBhd.mjs}

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { checkbox, confirm, input, password } from "@inquirer/prompts";
+import { checkbox, confirm, editor, input, password, search, select } from "@inquirer/prompts";
 import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
@@ -58,6 +58,16 @@ var AtlassianClient = class {
 	async getJson(path) {
 		return (await this.request(path, { headers: { Accept: "application/json" } })).json();
 	}
+	async postJson(path, body) {
+		return (await this.request(path, {
+			method: "POST",
+			headers: {
+				Accept: "application/json",
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(body)
+		})).json();
+	}
 	async putJson(path, body) {
 		return (await this.request(path, {
 			method: "PUT",
@@ -103,9 +113,14 @@ function pathAndQuery(absoluteUrl) {
 }
 var HttpError = class extends Error {
 	status;
-	constructor(status, message) {
+	jira;
+	constructor(status, message, jira = {
+		errorMessages: [],
+		errors: {}
+	}) {
 		super(message);
 		this.status = status;
+		this.jira = jira;
 		this.name = "HttpError";
 	}
 };
@@ -114,17 +129,26 @@ function httpError(status, path, body = "") {
 	if (status === 404) return new HttpError(status, `Not found (404): ${path}`);
 	if (status === 409) return new HttpError(status, `Conflict (409): ${extractErrorMessage(body) || "the page changed on the server"}`);
 	if (status === 413) return new HttpError(status, "Payload too large (413): the page or an attachment exceeds the size limit.");
-	if (status === 400) return new HttpError(status, `Bad request (400): ${extractErrorMessage(body) || path}`);
-	return new HttpError(status, `Request failed (${status}): ${extractErrorMessage(body) || path}`);
+	if (status === 400) return new HttpError(status, `Bad request (400): ${extractErrorMessage(body) || path}`, jiraErrors(body));
+	return new HttpError(status, `Request failed (${status}): ${extractErrorMessage(body) || path}`, jiraErrors(body));
 }
 function extractErrorMessage(body) {
 	if (!body) return "";
 	const json = tryParseJson(body);
-	if (json?.errorMessages?.length) return json.errorMessages.join("; ");
+	const { errorMessages, errors } = jiraErrors(body);
+	const fromJira = [...errorMessages, ...Object.entries(errors).map(([f, m]) => `${f}: ${m}`)];
+	if (fromJira.length) return fromJira.join("; ");
 	if (json?.message) return json.message;
 	if (json?.error?.message) return json.error.message;
 	return body.slice(0, 300);
 }
+function jiraErrors(body) {
+	const json = tryParseJson(body);
+	return {
+		errorMessages: json?.errorMessages ?? [],
+		errors: json?.errors ?? {}
+	};
+}
 function tryParseJson(text) {
 	try {
 		return JSON.parse(text);
@@ -1015,6 +1039,14 @@ async function resolveRef(arg, kind) {
 	return ref;
 }
 //#endregion
+//#region src/util/link.ts
+const OSC8 = "\x1B]8;;";
+const BEL = "\x07";
+function hyperlink(text, url) {
+	if (!kleur.enabled || !url) return text;
+	return `${OSC8}${url}${BEL}${text}${OSC8}${BEL}`;
+}
+//#endregion
 //#region src/commands/search-run.ts
 function alignedRows(items, nowMs, cells) {
 	const rows = items.map((item) => ({
@@ -1028,6 +1060,7 @@ function alignedRows(items, nowMs, cells) {
 	const ageWidth = width((row) => row.age);
 	return rows.map((row) => ({
 		id: row.id,
+		url: row.url,
 		fixedColumns: `${row.id.padEnd(idWidth)}  ${row.color(row.label.padEnd(labelWidth))}  ${row.age.padEnd(ageWidth)}`,
 		freeText: row.text,
 		json: row.json
@@ -1085,10 +1118,11 @@ async function copySelected(rows, noun, copyOne) {
 	if (failures.length === 0) console.log(summary);
 	else console.log(`${summary}, failed ${failures.length}: ${failures.join(", ")}`);
 }
-function formatRow(row) {
-	const room = (process.stdout.columns ?? 80) - stripVTControlCharacters(row.fixedColumns).length - 2;
+function formatRow(row, width = process.stdout.columns ?? 80) {
+	const room = width - stripVTControlCharacters(row.fixedColumns).length - 2;
 	const text = room > 0 ? truncate(row.freeText, room) : "";
-	return text ? `${row.fixedColumns}  ${text}` : row.fixedColumns;
+	const columns = hyperlink(row.id, row.url) + row.fixedColumns.slice(row.id.length);
+	return text ? `${columns}  ${hyperlink(text, row.url)}` : columns;
 }
 function truncate(text, max) {
 	const clean = text.replace(/\s+/g, " ").trim();
@@ -2089,6 +2123,7 @@ async function listPages(filter, empty, options) {
 function formatPageRows(pages, nowMs) {
 	return alignedRows(pages, nowMs, (p) => ({
 		id: p.id,
+		url: p.url,
 		label: p.space,
 		color: colorForSpace(p.space),
 		text: p.title
@@ -2328,6 +2363,731 @@ async function fetchComments(client, key) {
 		body: c.body ?? null
 	}));
 }
+const CREATEMETA_PAGE_SIZE = 200;
+async function fetchCreateIssueTypes(client, project) {
+	return (await pageCreateMeta(client, project, "", (page) => page.issueTypes ?? [])).map((t) => ({
+		id: t.id,
+		name: t.name,
+		description: t.description ?? "",
+		subtask: t.subtask ?? false
+	}));
+}
+async function fetchCreateFields(client, project, issueTypeId) {
+	return (await pageCreateMeta(client, project, `/${encodeURIComponent(issueTypeId)}`, (page) => page.fields ?? [])).map((f) => ({
+		...f,
+		name: decodeEntities(f.name),
+		allowedValues: f.allowedValues?.map(decodeAllowedValue)
+	}));
+}
+function decodeAllowedValue(v) {
+	return {
+		...v,
+		name: v.name === void 0 ? void 0 : decodeEntities(v.name),
+		value: v.value === void 0 ? void 0 : decodeEntities(v.value),
+		children: v.children?.map(decodeAllowedValue)
+	};
+}
+async function pageCreateMeta(client, project, suffix, items) {
+	const base = `/rest/api/3/issue/createmeta/${encodeURIComponent(project)}/issuetypes${suffix}`;
+	const all = [];
+	for (let startAt = 0;;) {
+		let page;
+		try {
+			page = await client.getJson(`${base}?startAt=${startAt}&maxResults=${CREATEMETA_PAGE_SIZE}`);
+		} catch (err) {
+			if (err instanceof HttpError && err.status === 404) throw new Error(`No project found with key "${project}".`);
+			throw err;
+		}
+		const values = items(page);
+		all.push(...values);
+		startAt += values.length;
+		if (values.length === 0 || startAt >= (page.total ?? 0)) return all;
+	}
+}
+async function createIssue(client, site, fields) {
+	const res = await client.postJson("/rest/api/3/issue?updateHistory=true", { fields });
+	return {
+		id: res.id,
+		key: res.key,
+		url: browseUrl(site, res.key)
+	};
+}
+async function searchAssignableUsers(client, project, query) {
+	const params = new URLSearchParams({
+		project,
+		query,
+		maxResults: "20"
+	});
+	return (await client.getJson(`/rest/api/3/user/assignable/search?${params.toString()}`)).map(toJiraUser);
+}
+async function fetchMyself(client) {
+	return toJiraUser(await client.getJson("/rest/api/3/myself"));
+}
+function toJiraUser(u) {
+	return {
+		accountId: u.accountId,
+		displayName: u.displayName ?? "",
+		email: u.emailAddress ?? "",
+		active: u.active ?? true
+	};
+}
+//#endregion
+//#region src/create/encode.ts
+const SERVER_FILLED = new Set([
+	"project",
+	"issuetype",
+	"reporter"
+]);
+function requiredFields(meta) {
+	return meta.filter((f) => f.required && !f.hasDefaultValue && !SERVER_FILLED.has(f.fieldId));
+}
+function findField(meta, name) {
+	const needle = name.trim().toLowerCase();
+	const byId = meta.find((f) => f.fieldId === name.trim());
+	if (byId) return { field: byId };
+	const byName = meta.filter((f) => f.name.toLowerCase() === needle);
+	if (byName.length === 1) return { field: byName[0] };
+	if (byName.length > 1) return { ambiguous: byName };
+	return { unknown: true };
+}
+function assign(meta, inputs, problems) {
+	const byField = /* @__PURE__ */ new Map();
+	for (const input of inputs) {
+		const match = findField(meta, input.name);
+		if ("unknown" in match) {
+			problems.push(`"${input.name.trim()}" is not on this create screen.`);
+			continue;
+		}
+		if ("ambiguous" in match) {
+			const ids = match.ambiguous.map((f) => f.fieldId).join(", ");
+			problems.push(`"${input.name.trim()}" matches more than one field; use the id: ${ids}.`);
+			continue;
+		}
+		const existing = byField.get(match.field.fieldId);
+		if (!existing) byField.set(match.field.fieldId, {
+			field: match.field,
+			values: [...input.values],
+			source: input.source
+		});
+		else if (existing.source !== input.source) problems.push(`${match.field.name} was given by both ${existing.source} and ${input.source}.`);
+		else existing.values.push(...input.values);
+	}
+	return [...byField.values()];
+}
+async function encodeCreate(meta, inputs, resolveUser) {
+	const problems = [];
+	const fields = {};
+	const assignments = assign(meta, inputs, problems);
+	for (const a of assignments) {
+		const encoded = await encodeField(a.field, a.values, resolveUser);
+		if ("problem" in encoded) problems.push(encoded.problem);
+		else fields[a.field.fieldId] = encoded.value;
+	}
+	const set = new Set(assignments.map((a) => a.field.fieldId));
+	return {
+		fields,
+		missing: requiredFields(meta).filter((f) => !set.has(f.fieldId)),
+		problems
+	};
+}
+function isMultiLine(schema) {
+	return schema.system === "description" || schema.system === "environment" || (schema.custom?.endsWith(":textarea") ?? false);
+}
+function isLabels(schema) {
+	return schema.system === "labels" || (schema.custom?.endsWith(":labels") ?? false);
+}
+async function encodeField(field, values, resolveUser) {
+	const { schema } = field;
+	if (schema.type === "array") {
+		const items = schema.items ?? "string";
+		const out = [];
+		for (const token of splitCommas(values)) {
+			const encoded = await encodeScalar(field, items, token, resolveUser);
+			if ("problem" in encoded) return encoded;
+			out.push(encoded.value);
+		}
+		return { value: out };
+	}
+	if (values.length !== 1) return { problem: `${field.name} takes one value.` };
+	return encodeScalar(field, schema.type, values[0], resolveUser);
+}
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+const DATETIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?$/i;
+const NAMED_TYPES = new Set([
+	"priority",
+	"version",
+	"component",
+	"securitylevel",
+	"issuetype"
+]);
+async function encodeScalar(field, type, raw, resolveUser) {
+	const fail = (text) => ({ problem: `${field.name} ${text}` });
+	const token = raw.trim();
+	const { schema } = field;
+	if (type === "option-with-child") return matchCascading(field, token);
+	if (field.allowedValues && field.allowedValues.length > 0) return matchAllowed(field, token);
+	switch (type) {
+		case "string":
+			if (isMultiLine(schema)) return { value: markdownToAdf(raw) };
+			if (isLabels(schema) && /\s/.test(token)) return fail(`cannot contain spaces: "${token}".`);
+			return { value: schema.type === "array" ? token : raw };
+		case "number": {
+			const n = Number(token);
+			if (token === "" || Number.isNaN(n)) return fail(`must be a number, not "${token}".`);
+			return { value: n };
+		}
+		case "date":
+			if (!DATE.test(token)) return fail(`must be YYYY-MM-DD, not "${token}".`);
+			return { value: token };
+		case "datetime": {
+			const ms = DATETIME.test(token) ? Date.parse(token) : NaN;
+			if (Number.isNaN(ms)) return fail(`must be an ISO 8601 datetime, not "${token}".`);
+			return { value: formatJiraDateTime(new Date(ms)) };
+		}
+		case "option": return { value: { value: token } };
+		case "project": return { value: { key: token.toUpperCase() } };
+		case "user": try {
+			return { value: { accountId: await resolveUser(token) } };
+		} catch (err) {
+			return { problem: `${field.name}: ${err instanceof Error ? err.message : String(err)}` };
+		}
+		case "group": return { value: { name: token } };
+		case "issuelink": return { value: { key: token.toUpperCase() } };
+		default:
+			if (NAMED_TYPES.has(type)) return { value: { name: token } };
+			return { value: looseValue(raw) };
+	}
+}
+function looseValue(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return raw;
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		return raw;
+	}
+}
+function formatJiraDateTime(date) {
+	const pad = (n, width = 2) => String(n).padStart(width, "0");
+	const offsetMinutes = -date.getTimezoneOffset();
+	const sign = offsetMinutes < 0 ? "-" : "+";
+	const abs = Math.abs(offsetMinutes);
+	const ymd = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+	const hms = `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+	const offset = `${sign}${pad(Math.floor(abs / 60))}${pad(abs % 60)}`;
+	return `${ymd}T${hms}.${pad(date.getMilliseconds(), 3)}${offset}`;
+}
+function splitCommas(values) {
+	return values.flatMap((v) => v.split(",")).map((v) => v.trim()).filter((v) => v.length > 0);
+}
+function allowedLabel(v) {
+	return v.value ?? v.name ?? v.key ?? v.id ?? "";
+}
+function findAllowed(options, token) {
+	const needle = token.toLowerCase();
+	return options.find((v) => v.id === token) ?? options.find((v) => allowedLabel(v).toLowerCase() === needle);
+}
+function allowedList(options) {
+	return options.map(allowedLabel).join(", ");
+}
+function matchAllowed(field, token) {
+	const options = field.allowedValues ?? [];
+	const hit = findAllowed(options, token);
+	if (!hit) return { problem: `${field.name} has no value "${token}"; allowed: ${allowedList(options)}.` };
+	return { value: { id: hit.id } };
+}
+function matchCascading(field, value) {
+	const options = field.allowedValues ?? [];
+	const [parentText = "", childText] = value.split(">").map((s) => s.trim());
+	const parent = findAllowed(options, parentText);
+	if (!parent) return { problem: `${field.name} has no value "${parentText}"; allowed: ${allowedList(options)}.` };
+	if (!childText) return { value: { id: parent.id } };
+	const children = parent.children ?? [];
+	const child = findAllowed(children, childText);
+	if (!child) {
+		const under = allowedLabel(parent);
+		return { problem: `${field.name} has no value "${childText}" under ${under}; allowed: ${allowedList(children)}.` };
+	}
+	return { value: {
+		id: parent.id,
+		child: { id: child.id }
+	} };
+}
+//#endregion
+//#region src/create/format.ts
+const SCALAR_LABELS = {
+	string: "text",
+	number: "number",
+	date: "date",
+	datetime: "datetime",
+	option: "option",
+	"option-with-child": "cascading option",
+	user: "user",
+	group: "group",
+	priority: "priority",
+	issuetype: "issue type",
+	project: "project",
+	version: "version",
+	component: "component",
+	issuelink: "issue key",
+	securitylevel: "security level",
+	timetracking: "time tracking"
+};
+const PLURAL_LABELS = {
+	string: "text list",
+	option: "options",
+	user: "users",
+	group: "groups",
+	version: "versions",
+	component: "components"
+};
+function fieldTypeLabel(schema) {
+	if (isMultiLine(schema)) return "multi-line text";
+	if (isLabels(schema)) return "labels";
+	if (schema.type === "array") {
+		const items = schema.items ?? "string";
+		return PLURAL_LABELS[items] ?? `${SCALAR_LABELS[items] ?? items} list`;
+	}
+	const known = SCALAR_LABELS[schema.type];
+	if (known) return known;
+	return schema.custom?.split(/[:/]/).pop() || schema.type;
+}
+const ALLOWED_SHOWN = 8;
+function allowedSummary(field) {
+	const options = field.allowedValues ?? [];
+	if (options.length === 0) return void 0;
+	const shown = options.slice(0, ALLOWED_SHOWN).map(allowedLabel);
+	const rest = options.length - shown.length;
+	if (rest > 0) shown.push(`+${rest} more`);
+	return `allowed: ${shown.join(", ")}`;
+}
+function defaultSummary(field) {
+	if (!field.hasDefaultValue || field.defaultValue == null) return void 0;
+	return `default: ${valueLabel(field.defaultValue)}`;
+}
+function valueLabel(value) {
+	if (Array.isArray(value)) return value.map(valueLabel).join(", ");
+	if (typeof value === "object" && value !== null) return allowedLabel(value);
+	return String(value);
+}
+const DEDICATED_FLAGS = {
+	summary: "--summary",
+	description: "--description",
+	assignee: "--assignee",
+	priority: "--priority",
+	labels: "--label",
+	components: "--component",
+	parent: "--parent"
+};
+function flagFor(field) {
+	return DEDICATED_FLAGS[field.fieldId] ?? "--field";
+}
+function formatMissingFields(project, type, missing) {
+	const nameWidth = Math.max(...missing.map((f) => f.name.length));
+	const idWidth = Math.max(...missing.map((f) => f.fieldId.length + 2));
+	const rows = missing.map((f) => {
+		const note = allowedSummary(f) ?? fieldTypeLabel(f.schema);
+		return `  ${f.name.padEnd(nameWidth)}  ${`(${f.fieldId})`.padEnd(idWidth)} ${note}`;
+	});
+	const flags = [...new Set(missing.map(flagFor))].join("/");
+	return [
+		`${project} ${type} needs these fields:`,
+		...rows,
+		`Pass them with ${flags}, or run \`jira fields ${project} ${type}\` to see the form.`
+	];
+}
+function formatFieldRows(fields) {
+	const cells = fields.map((f) => ({
+		name: f.name,
+		id: f.fieldId,
+		type: fieldTypeLabel(f.schema),
+		required: f.required ? "required" : "",
+		notes: [defaultSummary(f), allowedSummary(f)].filter((n) => n !== void 0)
+	}));
+	const width = (pick) => Math.max(...cells.map((c) => pick(c).length));
+	const nameWidth = width((c) => c.name);
+	const idWidth = width((c) => c.id);
+	const typeWidth = width((c) => c.type);
+	const requiredWidth = width((c) => c.required);
+	return cells.map((c) => [
+		c.name.padEnd(nameWidth),
+		c.id.padEnd(idWidth),
+		c.type.padEnd(typeWidth),
+		c.required.padEnd(requiredWidth),
+		...c.notes
+	].join("  ").trimEnd());
+}
+function formatIssueTypeRows(types) {
+	const width = Math.max(...types.map((t) => t.name.length));
+	return types.map((t) => {
+		const tail = [t.subtask ? "(subtask)" : "", t.description].filter(Boolean).join(" ");
+		return `${t.name.padEnd(width)}  ${tail}`.trimEnd();
+	});
+}
+//#endregion
+//#region src/create/prompt.ts
+const PROMPT_SOURCE = "prompt";
+async function walkFields(meta, deps) {
+	const firstPass = meta.filter((f) => f.required && !SERVER_FILLED.has(f.fieldId));
+	const inputs = [];
+	for (const field of firstPass) {
+		const answer = await promptField(field, deps, true);
+		if (answer) inputs.push(answer);
+	}
+	const optional = meta.filter((f) => !firstPass.includes(f) && !SERVER_FILLED.has(f.fieldId));
+	if (optional.length === 0) return inputs;
+	const chosen = await checkbox({
+		message: "Set any optional fields?",
+		choices: optional.map((f) => ({
+			name: `${f.name}  (${fieldTypeLabel(f.schema)})`,
+			value: f.fieldId
+		})),
+		pageSize: 15
+	});
+	for (const field of optional.filter((f) => chosen.includes(f.fieldId))) {
+		const answer = await promptField(field, deps, false);
+		if (answer) inputs.push(answer);
+	}
+	return inputs;
+}
+async function promptField(field, deps, required) {
+	const answer = await askValues(field, deps, required);
+	if (answer.values.length === 0) return void 0;
+	return {
+		name: field.fieldId,
+		values: answer.values,
+		source: PROMPT_SOURCE,
+		display: answer.display ?? displayFor(field, answer.values)
+	};
+}
+const SKIP = {
+	name: "(skip)",
+	value: ""
+};
+async function askValues(field, deps, required) {
+	const { schema } = field;
+	const message = `${field.name}:`;
+	const options = field.allowedValues ?? [];
+	if (schema.type === "option-with-child") return askCascading(field, required);
+	if (options.length > 0 && schema.type === "array") {
+		const defaults = new Set(defaultIds(field));
+		return { values: await checkbox({
+			message,
+			choices: options.map((v) => ({
+				...choice(v),
+				checked: defaults.has(v.id ?? "")
+			})),
+			required,
+			pageSize: 15
+		}) };
+	}
+	if (options.length > 0) {
+		const choices = options.map(choice);
+		const picked = await select({
+			message,
+			choices: required ? choices : [SKIP, ...choices],
+			default: defaultIds(field)[0],
+			pageSize: 15
+		});
+		return { values: picked ? [picked] : [] };
+	}
+	if (schema.type === "user") return askUser(field, deps, required);
+	if (isMultiLine(schema)) {
+		const text = await editor({
+			message: `${field.name} (opens your editor, Markdown):`,
+			postfix: ".md",
+			default: primitiveDefault(field),
+			validate: (v) => !required || v.trim().length > 0 ? true : `${field.name} is required.`
+		});
+		return { values: text.trim() ? [text] : [] };
+	}
+	const hint = inputHint(field);
+	const text = await input({
+		message: hint ? `${field.name} (${hint}):` : message,
+		default: primitiveDefault(field),
+		validate: async (v) => {
+			if (v.trim() === "") return required ? `${field.name} is required.` : true;
+			return deps.validate(field, v);
+		}
+	});
+	return { values: text.trim() ? [text] : [] };
+}
+function choice(v) {
+	return {
+		name: allowedLabel(v),
+		value: v.id ?? allowedLabel(v)
+	};
+}
+function inputHint(field) {
+	const type = field.schema.type === "array" ? field.schema.items : field.schema.type;
+	const list = field.schema.type === "array" ? ", comma separated" : "";
+	switch (type) {
+		case "date": return `YYYY-MM-DD${list}`;
+		case "datetime": return `ISO 8601${list}`;
+		case "number": return `number${list}`;
+		case "user": return `name, email, or me${list}`;
+		case "string": return list ? "comma separated" : void 0;
+		default: return fieldTypeLabel(field.schema);
+	}
+}
+function defaultIds(field) {
+	if (!field.hasDefaultValue || field.defaultValue == null) return [];
+	const d = field.defaultValue;
+	return (Array.isArray(d) ? d : [d]).map((v) => v.id).filter((id) => id !== void 0);
+}
+function primitiveDefault(field) {
+	const d = field.defaultValue;
+	if (!field.hasDefaultValue || d == null) return void 0;
+	return typeof d === "string" || typeof d === "number" ? String(d) : void 0;
+}
+async function askCascading(field, required) {
+	const options = field.allowedValues ?? [];
+	const parentChoices = options.map(choice);
+	const parentId = await select({
+		message: `${field.name}:`,
+		choices: required ? parentChoices : [SKIP, ...parentChoices],
+		pageSize: 15
+	});
+	if (!parentId) return { values: [] };
+	const parent = options.find((v) => v.id === parentId);
+	const children = parent?.children ?? [];
+	if (children.length === 0) return { values: [parentId] };
+	const childId = await select({
+		message: `${field.name} > ${allowedLabel(parent)}:`,
+		choices: [{
+			name: "(none)",
+			value: ""
+		}, ...children.map(choice)],
+		pageSize: 15
+	});
+	return { values: [childId ? `${parentId} > ${childId}` : parentId] };
+}
+const ME = {
+	name: "me",
+	value: "me"
+};
+const UNASSIGNED = {
+	name: "(unassigned)",
+	value: ""
+};
+async function askUser(field, deps, required) {
+	const fixed = required ? [ME] : [ME, UNASSIGNED];
+	const seen = /* @__PURE__ */ new Map();
+	const picked = await search({
+		message: `${field.name} (type to search):`,
+		source: async (term) => {
+			if (!term) return fixed;
+			const users = await deps.searchUsers(term);
+			for (const u of users) seen.set(u.accountId, u.displayName);
+			return [...fixed, ...users.filter((u) => u.active).map((u) => ({
+				name: u.email ? `${u.displayName} <${u.email}>` : u.displayName,
+				value: u.accountId
+			}))];
+		},
+		pageSize: 10
+	});
+	if (!picked) return { values: [] };
+	return {
+		values: [picked],
+		display: seen.get(picked) ?? picked
+	};
+}
+function displayFor(field, values) {
+	const options = field.allowedValues ?? [];
+	if (options.length === 0) return isMultiLine(field.schema) ? summarizeText(values[0] ?? "") : values.join(", ");
+	return values.map((v) => v.split(">").map((part) => {
+		const id = part.trim();
+		const hit = options.find((o) => o.id === id) ?? findChild(options, id);
+		return hit ? allowedLabel(hit) : id;
+	}).join(" > ")).join(", ");
+}
+function findChild(options, id) {
+	for (const o of options) {
+		const hit = o.children?.find((c) => c.id === id);
+		if (hit) return hit;
+	}
+}
+function summarizeText(text) {
+	const lines = text.trim().split(/\r?\n/);
+	const first = lines[0] ?? "";
+	const more = lines.length - 1;
+	return more > 0 ? `${first} (+${more} more lines)` : first;
+}
+//#endregion
+//#region src/commands/jira-create.ts
+async function flagInputs(options) {
+	const inputs = [];
+	const one = (name, value, source) => {
+		if (value !== void 0) inputs.push({
+			name,
+			values: [value],
+			source
+		});
+	};
+	one("summary", options.summary, "--summary");
+	one("description", options.description, "--description");
+	if (options.descriptionFile !== void 0) {
+		if (options.description !== void 0) throw new Error("--description and --description-file cannot be used together.");
+		one("description", await readFile(options.descriptionFile, "utf8"), "--description-file");
+	}
+	one("assignee", options.assignee, "--assignee");
+	one("priority", options.priority, "--priority");
+	one("parent", options.parent, "--parent");
+	if (options.label?.length) inputs.push({
+		name: "labels",
+		values: options.label,
+		source: "--label"
+	});
+	if (options.component?.length) inputs.push({
+		name: "components",
+		values: options.component,
+		source: "--component"
+	});
+	for (const raw of options.field ?? []) inputs.push(parseFieldFlag(raw));
+	return inputs;
+}
+function parseFieldFlag(raw) {
+	const eq = raw.indexOf("=");
+	if (eq <= 0) throw new Error(`--field expects NAME=VALUE, got "${raw}".`);
+	return {
+		name: raw.slice(0, eq),
+		values: [raw.slice(eq + 1)],
+		source: "--field"
+	};
+}
+async function jiraCreate(projectArg, typeArg, options) {
+	const inputs = await flagInputs(options);
+	const strict = inputs.length > 0 || options.input === false || !process.stdin.isTTY;
+	const auth = await requireAuth();
+	const client = new AtlassianClient(auth);
+	const project = await resolveProject(client, auth.site, projectArg, strict);
+	const type = await resolveType(project, await fetchCreateIssueTypes(client, project), typeArg, strict);
+	const meta = await fetchCreateFields(client, project, type.id);
+	const resolveUser = userResolver(client, project);
+	if (!strict) inputs.push(...await walkFields(meta, {
+		searchUsers: (query) => searchAssignableUsers(client, project, query),
+		validate: async (field, value) => {
+			return (await encodeCreate([field], [{
+				name: field.fieldId,
+				values: [value],
+				source: "prompt"
+			}], resolveUser)).problems[0] ?? true;
+		}
+	}));
+	const result = await encodeCreate(meta, inputs, resolveUser);
+	if (result.problems.length > 0) throw new Error(result.problems.join("\n"));
+	if (result.missing.length > 0) throw new Error(formatMissingFields(project, type.name, result.missing).join("\n"));
+	const fields = {
+		project: { key: project },
+		issuetype: { id: type.id },
+		...result.fields
+	};
+	if (options.dryRun) {
+		console.log(JSON.stringify({ fields }, null, 2));
+		return;
+	}
+	if (!strict) {
+		for (const line of formatReview(meta, inputs)) console.log(line);
+		if (!await confirm({
+			message: `Create ${project} ${type.name}?`,
+			default: true
+		})) {
+			console.log("Aborted.");
+			return;
+		}
+	}
+	try {
+		const created = await createIssue(client, auth.site, fields);
+		if (options.json) console.log(JSON.stringify(created, null, 2));
+		else console.log(`Created ${created.key}  ${created.url}`);
+	} catch (err) {
+		throw describeRejection(err, meta);
+	}
+}
+function formatReview(meta, inputs) {
+	const width = Math.max(...inputs.map((i) => nameOf(meta, i.name).length));
+	return inputs.map((i) => `${`${nameOf(meta, i.name)}:`.padEnd(width + 1)}  ${i.display ?? i.values.join(", ")}`);
+}
+function nameOf(meta, idOrName) {
+	return meta.find((f) => f.fieldId === idOrName)?.name ?? idOrName;
+}
+function describeRejection(err, meta) {
+	if (!(err instanceof HttpError)) return err;
+	const { errorMessages, errors } = err.jira;
+	const perField = Object.entries(errors).map(([id, msg]) => {
+		const name = nameOf(meta, id);
+		return name === id ? `  ${id}: ${msg}` : `  ${name} (${id}): ${msg}`;
+	});
+	if (errorMessages.length === 0 && perField.length === 0) return err;
+	return new Error([
+		"Jira rejected the issue:",
+		...errorMessages.map((m) => `  ${m}`),
+		...perField
+	].join("\n"));
+}
+async function resolveProject(client, site, arg, strict) {
+	if (arg) return arg.toUpperCase();
+	if (strict) throw new Error("A project key is required, e.g. `jira create BSC Bug --summary ...`.");
+	return search({
+		message: "Project:",
+		source: async (term) => (await listProjects(client, site, term)).map((p) => ({
+			name: `${p.key}  ${p.name}`,
+			value: p.key
+		})),
+		pageSize: 15
+	});
+}
+async function resolveType(project, types, arg, strict) {
+	if (types.length === 0) throw new Error(`You cannot create issues in ${project}.`);
+	if (arg) {
+		const found = matchType(types, arg);
+		if (found) return found;
+		const names = types.map((t) => t.name).join(", ");
+		throw new Error(`${project} has no issue type "${arg}"; available: ${names}.`);
+	}
+	if (strict) throw new Error(`An issue type is required; ${project} has: ${types.map((t) => t.name).join(", ")}.`);
+	return select({
+		message: "Issue type:",
+		choices: types.map((t) => ({
+			name: t.name,
+			value: t,
+			description: t.description
+		})),
+		pageSize: 15
+	});
+}
+function matchType(types, arg) {
+	const needle = arg.trim().toLowerCase();
+	return types.find((t) => t.id === arg.trim()) ?? types.find((t) => t.name.toLowerCase() === needle);
+}
+const ACCOUNT_ID = /^(?:[0-9a-f]{24}|[a-z0-9]+:[0-9a-f-]{36}(?::[0-9a-f-]{36})?)$/i;
+function userResolver(client, project) {
+	return async (query) => {
+		if (query === "me") return (await fetchMyself(client)).accountId;
+		if (ACCOUNT_ID.test(query)) return query;
+		const users = (await searchAssignableUsers(client, project, query)).filter((u) => u.active);
+		const exact = users.filter((u) => u.displayName.toLowerCase() === query.toLowerCase() || u.email.toLowerCase() === query.toLowerCase());
+		const candidates = exact.length === 1 ? exact : users;
+		if (candidates.length === 1) return candidates[0].accountId;
+		if (candidates.length === 0) throw new Error(`no assignable user matches "${query}".`);
+		const names = candidates.map((u) => u.displayName).join(", ");
+		throw new Error(`"${query}" matches ${candidates.length} users: ${names}.`);
+	};
+}
+async function jiraFields(projectArg, typeArg, options) {
+	const client = new AtlassianClient(await requireAuth());
+	const project = projectArg.toUpperCase();
+	const types = await fetchCreateIssueTypes(client, project);
+	if (!typeArg) {
+		if (options.json) console.log(JSON.stringify(types, null, 2));
+		else if (types.length === 0) console.log(`You cannot create issues in ${project}.`);
+		else for (const line of formatIssueTypeRows(types)) console.log(line);
+		return;
+	}
+	const fields = await fetchCreateFields(client, project, (await resolveType(project, types, typeArg, true)).id);
+	if (options.json) console.log(JSON.stringify(fields, null, 2));
+	else for (const line of formatFieldRows(fields)) console.log(line);
+}
 //#endregion
 //#region src/commands/jira.ts
 async function jiraProjects(query, options) {
@@ -2463,6 +3223,7 @@ async function jiraList(options) {
 function formatIssueRows(issues, nowMs) {
 	return alignedRows(issues, nowMs, (i) => ({
 		id: i.key,
+		url: i.url,
 		label: i.status,
 		color: colorForCategory(i.statusCategory),
 		text: i.summary
@@ -2483,10 +3244,15 @@ const ISSUE_REF = {
 };
 //#endregion
 //#region src/cli/jira.ts
+function collect(value, previous = []) {
+	return [...previous, value];
+}
 function registerJira(jira) {
 	jira.description("Jira commands");
 	jira.command("projects [query]").description("List projects (optionally filtered by key or name)").option("--json", "output results as JSON").action(run(jiraProjects));
 	jira.command("statuses [query]").description("List statuses (optionally filtered by name, scoped with --project)").option("-p, --project <key>", "limit to statuses used by a project").option("--json", "output results as JSON").action(run(jiraStatuses));
+	jira.command("create [project] [type]").description("Create a Jira issue, prompting for fields or taking them all as flags").option("-s, --summary <text>", "issue summary").option("-d, --description <markdown>", "description as Markdown").option("--description-file <path>", "read the description from a Markdown file").option("-a, --assignee <who>", "assignee: me, an account id, or a name to look up").option("--priority <name>", "priority name").option("-l, --label <label>", "label (repeatable, or comma separated)", collect).option("-c, --component <name>", "component (repeatable, or comma separated)", collect).option("--parent <key>", "parent issue key for subtasks").option("-f, --field <name=value>", "any other create-screen field (repeatable)", collect).option("--no-input", "never prompt; fail if a required field is missing").option("--dry-run", "print the resolved payload instead of creating").option("--json", "print the created issue as JSON").action(run(jiraCreate));
+	jira.command("fields <project> [type]").description("Show the issue types you can create in a project, or the create form for one type").option("--json", "output results as JSON").action(run(jiraFields));
 	jira.command("view [issue]").description("Show a Jira issue (key or URL) in the terminal").option("--all-comments", "show all comments instead of the last 5").option("--no-pager", "print directly instead of paging long output").action(run(jiraView));
 	jira.command("copy [issue]").description("Copy a Jira issue (key or URL) to a Markdown file").option("-o, --out <path>", "output file or directory").action(run(jiraCopy));
 	jira.command("update [file]").description("Update a Jira issue description from an edited Markdown file").option("--summary", "also push the H1 as the issue summary").option("-f, --force", "skip the stale-issue and data-loss checks").option("--dry-run", "show what would change without writing").action(run(jiraUpdate));
@@ -2496,7 +3262,7 @@ function registerJira(jira) {
 }
 //#endregion
 //#region package.json
-var version = "1.10.0";
+var version = "1.11.0";
 //#endregion
 //#region src/cli/build.ts
 const PRODUCTS = {

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { r as fail, t as buildAtlass } from "./build-Colq1d4N.mjs";
+import { r as fail, t as buildAtlass } from "./build-wKtbjBhd.mjs";
 //#region src/cli.ts
 buildAtlass().parseAsync().catch(fail);
 //#endregion

package/dist/confluence.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as buildStandalone, r as fail } from "./build-Colq1d4N.mjs";
+import { n as buildStandalone, r as fail } from "./build-wKtbjBhd.mjs";
 //#region src/confluence.ts
 buildStandalone("confluence").parseAsync().catch(fail);
 //#endregion

package/dist/jira.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as buildStandalone, r as fail } from "./build-Colq1d4N.mjs";
+import { n as buildStandalone, r as fail } from "./build-wKtbjBhd.mjs";
 //#region src/jira.ts
 buildStandalone("jira").parseAsync().catch(fail);
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "atlass",
-	"version": "1.10.0",
+	"version": "1.11.0",
 	"description": "CLI to copy Jira issues and Confluence pages to Markdown, and update Confluence pages.",
 	"license": "MIT",
 	"repository": {