atlass 1.0.0

package/README.md

@@ -0,0 +1,167 @@
+# atlass
+
+CLI to copy Jira issues and Confluence pages to Markdown.
+
+Fetches an issue or page from Atlassian Cloud, converts its rich content to
+Markdown, writes a `.md` file with YAML frontmatter, and downloads any
+attachments alongside it.
+
+## Install
+
+```bash
+pnpm install
+pnpm build
+pnpm link --global   # exposes the `atlass` binary
+```
+
+Or run from source without linking:
+
+```bash
+node dist/cli.mjs <command>
+```
+
+## Authentication
+
+Atlassian Cloud only. Auth uses your account email plus an API token
+(Basic auth). Create a token at
+`https://id.atlassian.com/manage-profile/security/api-tokens`.
+
+```bash
+atlass auth login
+```
+
+You are prompted for:
+
+- site, e.g. `acme.atlassian.net`
+- account email
+- API token
+
+The login is verified against `/rest/api/3/myself` before anything is saved.
+The site and email are stored in `~/.config/atlass/config.json`
+(or `$XDG_CONFIG_HOME/atlass/config.json`). The API token is stored in the OS
+keyring (service `atlass`), never on disk.
+
+```bash
+atlass auth status   # show current site/email and whether a token is stored
+atlass auth logout   # remove config and delete the token from the keyring
+```
+
+Only one account is supported at a time.
+
+## Usage
+
+### Copy a Jira issue
+
+```bash
+atlass jira copy PROJ-123
+atlass jira copy https://acme.atlassian.net/browse/PROJ-123
+atlass jira copy            # prompts for the key or URL
+```
+
+Accepts an issue key or any URL containing one. Writes `PROJ-123.md` to the
+current directory.
+
+### Copy a Confluence page
+
+```bash
+atlass confluence copy 123456
+atlass confluence copy https://acme.atlassian.net/wiki/spaces/DEV/pages/123456/Title
+atlass confluence copy     # prompts for the id or URL
+```
+
+Accepts a numeric page id or a page URL. Writes `123456-title-slug.md` to the
+current directory.
+
+### Output location
+
+By default files are written to the current directory, named after the issue
+key (Jira) or `<id>-<title-slug>` (Confluence). Use `--out` to override:
+
+```bash
+atlass jira copy PROJ-123 --out ./tickets/          # directory: ./tickets/PROJ-123.md
+atlass jira copy PROJ-123 --out ./bug.md            # explicit file path
+```
+
+Existing files are overwritten.
+
+## Output format
+
+Each file is:
+
+- YAML frontmatter with metadata
+- an H1 heading (issue summary / page title)
+- the body, converted from ADF to Markdown
+- a `## Comments` section (Jira comments / Confluence footer comments)
+- an `## Attachments` section linking every downloaded file
+
+Jira frontmatter: `key`, `type`, `status`, `assignee`, `reporter`, `priority`,
+`labels`, `created`, `updated`, `url`.
+
+Confluence frontmatter: `title`, `id`, `space`, `version`, `author`, `created`,
+`updated`, `url`.
+
+Example (Jira):
+
+```markdown
+---
+key: "PROJ-123"
+type: "Bug"
+status: "In Progress"
+assignee: "Dana Scully"
+reporter: "Fox Mulder"
+priority: "High"
+labels:
+    - "regression"
+url: "https://acme.atlassian.net/browse/PROJ-123"
+---
+
+# Login button does nothing on Safari
+
+Steps to reproduce...
+
+## Comments
+
+### Fox Mulder - 2025-07-01 10:30
+
+Reproduced on 17.5.
+
+## Attachments
+
+- [screenshot.png](PROJ-123.assets/screenshot.png)
+```
+
+### Attachments
+
+All attachments are downloaded into a sibling `<name>.assets/` folder and
+listed under `## Attachments`. Inline images are linked to the local copy where
+they can be matched:
+
+- Confluence media nodes carry the attachment file id, so inline images resolve
+  reliably.
+- Jira media nodes usually expose only a filename, so inline images resolve when
+  that filename matches an attachment; otherwise they render as
+  `[embedded media: ...]` and the file is still captured in the attachments
+  folder and section.
+
+## Development
+
+```bash
+pnpm test      # run unit tests
+pnpm check     # format, lint, typecheck (add --fix to auto-fix)
+pnpm build     # build dist/cli.mjs
+pnpm dev       # build in watch mode
+```
+
+### Layout
+
+- `src/cli.ts` command wiring (commander)
+- `src/commands/` `auth`, `jira`, `confluence` command handlers
+- `src/api/` fetch client, Jira and Confluence endpoints, attachment downloader
+- `src/adf/` ADF to Markdown converter (unit tested)
+- `src/markdown/` frontmatter, comments, attachments, media resolver
+- `src/config.ts`, `src/credentials.ts` config file and keyring
+- `src/util/` key/id parsing and output path resolution
+
+The ADF to Markdown converter in `src/adf/to-markdown.ts` is a single hand
+rolled walker shared by both commands. Confluence page bodies are requested as
+`atlas_doc_format` so they flow through the same converter as Jira.

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,680 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { input, password } from "@inquirer/prompts";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { Entry } from "@napi-rs/keyring";
+//#region package.json
+var version = "1.0.0";
+//#endregion
+//#region src/api/client.ts
+var AtlassianClient = class {
+	site;
+	authHeader;
+	constructor(auth) {
+		this.site = auth.site;
+		const basic = Buffer.from(`${auth.email}:${auth.token}`).toString("base64");
+		this.authHeader = `Basic ${basic}`;
+	}
+	async request(path, accept) {
+		const res = await fetch(`${this.site}${path}`, { headers: {
+			Authorization: this.authHeader,
+			Accept: accept
+		} });
+		if (!res.ok) throw httpError(res.status, path);
+		return res;
+	}
+	async getJson(path) {
+		return (await this.request(path, "application/json")).json();
+	}
+	async getBinary(url) {
+		const path = url.startsWith("http") ? new URL(url).pathname + new URL(url).search : url;
+		const res = await this.request(path, "*/*");
+		return new Uint8Array(await res.arrayBuffer());
+	}
+};
+function httpError(status, path) {
+	if (status === 401 || status === 403) return /* @__PURE__ */ new Error("Authentication failed (401/403). Run `atlass auth login` to update your token.");
+	if (status === 404) return /* @__PURE__ */ new Error(`Not found (404): ${path}`);
+	return /* @__PURE__ */ new Error(`Request failed (${status}): ${path}`);
+}
+//#endregion
+//#region src/config.ts
+function configDir() {
+	return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "atlass");
+}
+function configPath() {
+	return join(configDir(), "config.json");
+}
+async function readConfig() {
+	try {
+		const raw = await readFile(configPath(), "utf8");
+		const parsed = JSON.parse(raw);
+		if (!parsed.site || !parsed.email) return null;
+		return {
+			site: parsed.site,
+			email: parsed.email
+		};
+	} catch {
+		return null;
+	}
+}
+async function writeConfig(config) {
+	await mkdir(configDir(), { recursive: true });
+	await writeFile(configPath(), `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+async function clearConfig() {
+	await rm(configPath(), { force: true });
+}
+function normalizeSite(input) {
+	let value = input.trim();
+	if (!/^https?:\/\//i.test(value)) value = `https://${value}`;
+	return new URL(value).origin;
+}
+//#endregion
+//#region src/credentials.ts
+const SERVICE = "atlass";
+function entry(email) {
+	return new Entry(SERVICE, email);
+}
+function saveToken(email, token) {
+	entry(email).setPassword(token);
+}
+function readToken(email) {
+	return entry(email).getPassword();
+}
+function deleteToken(email) {
+	try {
+		entry(email).deleteCredential();
+	} catch {}
+}
+async function requireAuth() {
+	const config = await readConfig();
+	if (!config) throw new Error("Not logged in. Run `atlass auth login` first.");
+	const token = readToken(config.email);
+	if (!token) throw new Error("No API token found in keyring. Run `atlass auth login` again.");
+	return {
+		...config,
+		token
+	};
+}
+//#endregion
+//#region src/commands/auth.ts
+async function login() {
+	const site = normalizeSite(await input({
+		message: "Atlassian site (e.g. acme.atlassian.net):",
+		required: true
+	}));
+	const email = await input({
+		message: "Account email:",
+		required: true
+	});
+	const token = await password({
+		message: "API token (from id.atlassian.com/manage-profile/security/api-tokens):",
+		mask: true
+	});
+	const me = await new AtlassianClient({
+		site,
+		email,
+		token
+	}).getJson("/rest/api/3/myself");
+	await writeConfig({
+		site,
+		email
+	});
+	saveToken(email, token);
+	console.log(`Logged in as ${me.displayName} on ${site}.`);
+}
+async function logout() {
+	const config = await readConfig();
+	if (config) deleteToken(config.email);
+	await clearConfig();
+	console.log("Logged out. Credentials removed.");
+}
+async function status() {
+	const config = await readConfig();
+	if (!config) {
+		console.log("Not logged in. Run `atlass auth login`.");
+		return;
+	}
+	const hasToken = readToken(config.email) !== null;
+	console.log(`Site:  ${config.site}`);
+	console.log(`Email: ${config.email}`);
+	console.log(`Token: ${hasToken ? "stored in keyring" : "MISSING (run `atlass auth login`)"}`);
+}
+//#endregion
+//#region src/adf/to-markdown.ts
+function adfToMarkdown(doc, options = {}) {
+	if (!doc) return "";
+	const ctx = { resolveMedia: options.resolveMedia };
+	return (doc.type === "doc" ? renderBlocks(doc.content ?? [], ctx, "") : renderBlock(doc, ctx, "")).trim();
+}
+function renderBlocks(nodes, ctx, indent) {
+	return nodes.map((n) => renderBlock(n, ctx, indent)).filter((s) => s.length > 0).join("\n\n");
+}
+function renderBlock(node, ctx, indent) {
+	switch (node.type) {
+		case "paragraph": return indent + renderInline(node.content ?? [], ctx);
+		case "heading": {
+			const level = clampLevel(node.attrs?.["level"]);
+			return `${"#".repeat(level)} ${renderInline(node.content ?? [], ctx)}`;
+		}
+		case "bulletList": return renderList(node, ctx, indent, "bullet");
+		case "orderedList": return renderList(node, ctx, indent, "ordered");
+		case "taskList": return renderTaskList(node, ctx, indent);
+		case "decisionList": return renderDecisionList(node, ctx, indent);
+		case "codeBlock": return renderCodeBlock(node, indent);
+		case "blockquote": return prefixLines(renderBlocks(node.content ?? [], ctx, ""), `${indent}> `);
+		case "panel": return renderPanel(node, ctx, indent);
+		case "rule": return `${indent}---`;
+		case "table": return renderTable(node, ctx);
+		case "mediaSingle":
+		case "mediaGroup": return renderBlocks(node.content ?? [], ctx, indent);
+		case "media": return indent + renderMedia(node, ctx);
+		case "expand":
+		case "nestedExpand": return renderExpand(node, ctx, indent);
+		default:
+			if (node.content?.length) return renderBlocks(node.content, ctx, indent);
+			return node.text ? indent + node.text : "";
+	}
+}
+function renderList(node, ctx, indent, kind) {
+	const start = kind === "ordered" ? toNumber(node.attrs?.["order"]) ?? 1 : 0;
+	return (node.content ?? []).filter((n) => n.type === "listItem").map((item, i) => {
+		return renderListItem(item, ctx, indent, kind === "ordered" ? `${start + i}. ` : "- ");
+	}).join("\n");
+}
+function renderListItem(item, ctx, indent, marker) {
+	const childIndent = `${indent}${" ".repeat(marker.length)}`;
+	const rendered = (item.content ?? []).map((b, i) => renderBlock(b, ctx, i === 0 ? "" : childIndent));
+	const parts = [];
+	rendered.forEach((text, i) => {
+		if (i === 0) parts.push(`${indent}${marker}${text}`);
+		else parts.push(text);
+	});
+	return parts.join("\n");
+}
+function renderTaskList(node, ctx, indent) {
+	return (node.content ?? []).filter((n) => n.type === "taskItem").map((item) => {
+		return `${indent}- [${item.attrs?.["state"] === "DONE" ? "x" : " "}] ${renderInline(item.content ?? [], ctx)}`;
+	}).join("\n");
+}
+function renderDecisionList(node, ctx, indent) {
+	return (node.content ?? []).filter((n) => n.type === "decisionItem").map((item) => `${indent}- (decision) ${renderInline(item.content ?? [], ctx)}`).join("\n");
+}
+function renderCodeBlock(node, indent) {
+	const lang = typeof node.attrs?.["language"] === "string" ? node.attrs["language"] : "";
+	const code = (node.content ?? []).map((n) => n.text ?? "").join("");
+	const fence = "```";
+	return prefixLines(`${fence}${lang}\n${code}\n${fence}`, indent);
+}
+const PANEL_LABELS = {
+	info: "Info",
+	note: "Note",
+	warning: "Warning",
+	success: "Success",
+	error: "Error"
+};
+function renderPanel(node, ctx, indent) {
+	return prefixLines(`**${PANEL_LABELS[typeof node.attrs?.["panelType"] === "string" ? node.attrs["panelType"] : "info"] ?? "Note"}**\n\n${renderBlocks(node.content ?? [], ctx, "")}`, `${indent}> `);
+}
+function renderExpand(node, ctx, indent) {
+	return `${indent}<details><summary>${typeof node.attrs?.["title"] === "string" ? node.attrs["title"] : "Details"}</summary>\n\n${renderBlocks(node.content ?? [], ctx, "")}\n\n${indent}</details>`;
+}
+function renderTable(node, ctx) {
+	const rows = (node.content ?? []).filter((n) => n.type === "tableRow");
+	if (rows.length === 0) return "";
+	const grid = rows.map((row) => (row.content ?? []).map((cell) => renderCell(cell, ctx)));
+	const cols = Math.max(...grid.map((r) => r.length));
+	const pad = (r) => {
+		const copy = [...r];
+		while (copy.length < cols) copy.push("");
+		return copy;
+	};
+	const header = pad(grid[0] ?? []);
+	const lines = [`| ${header.join(" | ")} |`, `| ${header.map(() => "---").join(" | ")} |`];
+	for (const row of grid.slice(1)) lines.push(`| ${pad(row).join(" | ")} |`);
+	return lines.join("\n");
+}
+function renderCell(cell, ctx) {
+	return renderBlocks(cell.content ?? [], ctx, "").replace(/\n+/g, " ").replace(/\|/g, "\\|").trim();
+}
+function renderMedia(node, ctx) {
+	const attrs = node.attrs ?? {};
+	const alt = attrs.alt ?? "";
+	const resolved = ctx.resolveMedia?.(attrs);
+	if (resolved) return `![${alt}](${resolved})`;
+	return `[embedded media: ${alt || attrs.id || "media"}]`;
+}
+function renderInline(nodes, ctx) {
+	return nodes.map((n) => renderInlineNode(n, ctx)).join("");
+}
+function renderInlineNode(node, ctx) {
+	switch (node.type) {
+		case "text": return applyMarks(node.text ?? "", node.marks ?? []);
+		case "hardBreak": return "  \n";
+		case "mention": return (typeof node.attrs?.["text"] === "string" ? node.attrs["text"] : "") || "@unknown";
+		case "emoji": {
+			const text = node.attrs?.["text"];
+			if (typeof text === "string" && text.length > 0) return text;
+			const short = node.attrs?.["shortName"];
+			return typeof short === "string" ? short : "";
+		}
+		case "date": return formatDate$1(node.attrs?.["timestamp"]);
+		case "status": return `\`[${typeof node.attrs?.["text"] === "string" ? node.attrs["text"] : ""}]\``;
+		case "inlineCard": {
+			const url = node.attrs?.["url"];
+			if (typeof url === "string") return `[${url}](${url})`;
+			return "";
+		}
+		case "media": return renderMedia(node, ctx);
+		default: return node.text ?? "";
+	}
+}
+function applyMarks(text, marks) {
+	if (text.length === 0) return text;
+	let out = text;
+	let href;
+	for (const mark of marks) switch (mark.type) {
+		case "code":
+			out = `\`${out}\``;
+			break;
+		case "strong":
+			out = `**${out}**`;
+			break;
+		case "em":
+			out = `*${out}*`;
+			break;
+		case "strike":
+			out = `~~${out}~~`;
+			break;
+		case "link": {
+			const value = mark.attrs?.["href"];
+			if (typeof value === "string") href = value;
+			break;
+		}
+		default: break;
+	}
+	if (href) out = `[${out}](${href})`;
+	return out;
+}
+function prefixLines(text, prefix) {
+	return text.split("\n").map((line) => line.length > 0 ? prefix + line : prefix.trimEnd()).join("\n");
+}
+function clampLevel(value) {
+	const n = toNumber(value) ?? 1;
+	return Math.min(6, Math.max(1, n));
+}
+function toNumber(value) {
+	return typeof value === "number" ? value : void 0;
+}
+function formatDate$1(timestamp) {
+	const ms = typeof timestamp === "string" ? Number(timestamp) : typeof timestamp === "number" ? timestamp : NaN;
+	if (Number.isNaN(ms)) return "";
+	return new Date(ms).toISOString().slice(0, 10);
+}
+//#endregion
+//#region src/api/attachments.ts
+async function downloadAttachments(client, attachments, assetsDir, assetsDirName) {
+	if (attachments.length === 0) return [];
+	await mkdir(assetsDir, { recursive: true });
+	const used = /* @__PURE__ */ new Set();
+	const results = [];
+	for (const att of attachments) {
+		const savedAs = uniqueName(safeName(att.filename), used);
+		try {
+			const bytes = await client.getBinary(att.url);
+			await writeFile(join(assetsDir, savedAs), bytes);
+			results.push({
+				...att,
+				relativePath: `${assetsDirName}/${savedAs}`
+			});
+		} catch (err) {
+			console.warn(`  ! could not download ${att.filename}: ${err.message}`);
+		}
+	}
+	return results;
+}
+function safeName(name) {
+	return basename(name).replace(/[/\\]/g, "_") || "attachment";
+}
+function uniqueName(name, used) {
+	if (!used.has(name)) {
+		used.add(name);
+		return name;
+	}
+	const dot = name.lastIndexOf(".");
+	const stem = dot > 0 ? name.slice(0, dot) : name;
+	const ext = dot > 0 ? name.slice(dot) : "";
+	let i = 1;
+	let candidate = `${stem}-${i}${ext}`;
+	while (used.has(candidate)) {
+		i += 1;
+		candidate = `${stem}-${i}${ext}`;
+	}
+	used.add(candidate);
+	return candidate;
+}
+//#endregion
+//#region src/api/confluence.ts
+async function fetchPage(client, site, id) {
+	const page = await client.getJson(`/wiki/api/v2/pages/${encodeURIComponent(id)}?body-format=atlas_doc_format`);
+	const names = new UserNames(client);
+	const [spaceKey, attachments, comments, author] = await Promise.all([
+		fetchSpaceKey(client, page.spaceId),
+		fetchAttachments(client, id),
+		fetchComments$1(client, id, names),
+		names.resolve(page.version?.authorId ?? page.authorId)
+	]);
+	const webui = page._links?.webui ?? "";
+	return {
+		id: page.id,
+		title: page.title,
+		spaceKey,
+		version: page.version?.number ?? 0,
+		author,
+		createdAt: page.createdAt ?? "",
+		updatedAt: page.version?.createdAt ?? "",
+		url: webui ? `${site}/wiki${webui}` : "",
+		body: parseAdf(page.body?.atlas_doc_format?.value),
+		attachments,
+		comments
+	};
+}
+async function fetchSpaceKey(client, spaceId) {
+	if (!spaceId) return "";
+	try {
+		return (await client.getJson(`/wiki/api/v2/spaces/${encodeURIComponent(spaceId)}`)).key ?? "";
+	} catch {
+		return "";
+	}
+}
+async function fetchAttachments(client, id) {
+	return (await client.getJson(`/wiki/api/v2/pages/${encodeURIComponent(id)}/attachments?limit=250`)).results.filter((a) => a.downloadLink).map((a) => ({
+		id: a.fileId ?? a.id,
+		filename: a.title ?? a.id,
+		url: normalizeDownloadLink(a.downloadLink ?? "")
+	}));
+}
+async function fetchComments$1(client, id, names) {
+	const res = await client.getJson(`/wiki/api/v2/pages/${encodeURIComponent(id)}/footer-comments?body-format=atlas_doc_format&limit=250`);
+	return Promise.all(res.results.map(async (c) => ({
+		author: await names.resolve(c.version?.authorId),
+		created: c.version?.createdAt ?? "",
+		body: parseAdf(c.body?.atlas_doc_format?.value)
+	})));
+}
+function normalizeDownloadLink(link) {
+	if (link.startsWith("http") || link.startsWith("/wiki")) return link;
+	return `/wiki${link}`;
+}
+function parseAdf(value) {
+	if (!value) return null;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return null;
+	}
+}
+var UserNames = class {
+	client;
+	cache = /* @__PURE__ */ new Map();
+	constructor(client) {
+		this.client = client;
+	}
+	async resolve(accountId) {
+		if (!accountId) return "";
+		const cached = this.cache.get(accountId);
+		if (cached !== void 0) return cached;
+		let name = accountId;
+		try {
+			const user = await this.client.getJson(`/wiki/rest/api/user?accountId=${encodeURIComponent(accountId)}`);
+			if (user.displayName) name = user.displayName;
+		} catch {}
+		this.cache.set(accountId, name);
+		return name;
+	}
+};
+//#endregion
+//#region src/markdown/document.ts
+function mediaResolver(downloaded) {
+	const byId = new Map(downloaded.map((d) => [d.id, d.relativePath]));
+	const byName = new Map(downloaded.map((d) => [d.filename, d.relativePath]));
+	return (media) => {
+		if (media.id && byId.has(media.id)) return byId.get(media.id);
+		if (media.alt && byName.has(media.alt)) return byName.get(media.alt);
+	};
+}
+function frontmatter(fields) {
+	const lines = ["---"];
+	for (const [key, value] of Object.entries(fields)) if (Array.isArray(value)) if (value.length === 0) lines.push(`${key}: []`);
+	else lines.push(`${key}:`, ...value.map((v) => `  - ${quote(v)}`));
+	else if (typeof value === "number") lines.push(`${key}: ${value}`);
+	else lines.push(`${key}: ${quote(value)}`);
+	lines.push("---");
+	return lines.join("\n");
+}
+function quote(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function attachmentsSection(downloaded) {
+	if (downloaded.length === 0) return "";
+	return [
+		"## Attachments",
+		"",
+		...downloaded.map((d) => `- [${d.filename}](${d.relativePath})`)
+	].join("\n");
+}
+function commentsSection(comments, resolveMedia) {
+	if (comments.length === 0) return "";
+	return [
+		"## Comments",
+		"",
+		comments.map((c) => {
+			const heading = `### ${c.author || "Unknown"}${c.created ? ` - ${formatDate(c.created)}` : ""}`;
+			const body = adfToMarkdown(c.body, { resolveMedia });
+			return body ? `${heading}\n\n${body}` : heading;
+		}).join("\n\n")
+	].join("\n");
+}
+function formatDate(iso) {
+	const date = new Date(iso);
+	if (Number.isNaN(date.getTime())) return iso;
+	return date.toISOString().replace("T", " ").slice(0, 16);
+}
+function joinSections(sections) {
+	return `${sections.filter((s) => s.trim().length > 0).join("\n\n")}\n`;
+}
+//#endregion
+//#region src/util/output-path.ts
+function resolveOutput(defaultBase, out) {
+	let filePath;
+	if (!out) filePath = resolve(`${defaultBase}.md`);
+	else if (out.endsWith(".md")) filePath = isAbsolute(out) ? out : resolve(out);
+	else filePath = resolve(out, `${defaultBase}.md`);
+	const dir = dirname(filePath);
+	const assetsDirName = `${filePath.slice(dir.length + 1).replace(/\.md$/, "")}.assets`;
+	return {
+		filePath,
+		assetsDir: join(dir, assetsDirName),
+		assetsDirName
+	};
+}
+function slugify(title) {
+	return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "") || "page";
+}
+//#endregion
+//#region src/util/parse.ts
+function parseIssueKey(input) {
+	const match = input.toUpperCase().match(/[A-Z][A-Z0-9]+-\d+/);
+	return match ? match[0] : null;
+}
+function parsePageId(input) {
+	const trimmed = input.trim();
+	if (/^\d+$/.test(trimmed)) return trimmed;
+	const fromPath = trimmed.match(/\/pages\/(\d+)/);
+	if (fromPath) return fromPath[1];
+	const fromQuery = trimmed.match(/[?&]pageId=(\d+)/);
+	if (fromQuery) return fromQuery[1];
+	return null;
+}
+//#endregion
+//#region src/commands/confluence.ts
+async function confluenceCopy(arg, options) {
+	const auth = await requireAuth();
+	const id = await resolveId(arg);
+	const client = new AtlassianClient(auth);
+	console.log(`Fetching page ${id} ...`);
+	const page = await fetchPage(client, auth.site, id);
+	const target = resolveOutput(`${page.id}-${slugify(page.title)}`, options.out);
+	const downloaded = await downloadAttachments(client, page.attachments, target.assetsDir, target.assetsDirName);
+	const resolveMedia = mediaResolver(downloaded);
+	const document = joinSections([
+		frontmatter({
+			title: page.title,
+			id: page.id,
+			space: page.spaceKey,
+			version: page.version,
+			author: page.author,
+			created: page.createdAt,
+			updated: page.updatedAt,
+			url: page.url
+		}),
+		`# ${page.title}`,
+		adfToMarkdown(page.body, { resolveMedia }),
+		commentsSection(page.comments, resolveMedia),
+		attachmentsSection(downloaded)
+	]);
+	await writeFile(target.filePath, document, "utf8");
+	const suffix = downloaded.length > 0 ? ` (+${downloaded.length} attachment${downloaded.length === 1 ? "" : "s"})` : "";
+	console.log(`Wrote ${target.filePath}${suffix}`);
+}
+async function resolveId(arg) {
+	const raw = arg ?? await input({
+		message: "Confluence page id or URL:",
+		required: true
+	});
+	const id = parsePageId(raw);
+	if (!id) throw new Error(`Could not find a page id in "${raw}".`);
+	return id;
+}
+//#endregion
+//#region src/api/jira.ts
+const FIELDS = [
+	"summary",
+	"description",
+	"issuetype",
+	"status",
+	"assignee",
+	"reporter",
+	"priority",
+	"labels",
+	"created",
+	"updated",
+	"attachment"
+].join(",");
+async function fetchIssue(client, site, key) {
+	const issue = await client.getJson(`/rest/api/3/issue/${encodeURIComponent(key)}?fields=${FIELDS}`);
+	const comments = await fetchComments(client, key);
+	const f = issue.fields;
+	return {
+		key: issue.key,
+		url: `${site}/browse/${issue.key}`,
+		summary: f.summary ?? "",
+		type: f.issuetype?.name ?? "",
+		status: f.status?.name ?? "",
+		assignee: f.assignee?.displayName ?? "Unassigned",
+		reporter: f.reporter?.displayName ?? "",
+		priority: f.priority?.name ?? "",
+		labels: f.labels ?? [],
+		created: f.created ?? "",
+		updated: f.updated ?? "",
+		description: f.description ?? null,
+		comments,
+		attachments: (f.attachment ?? []).map((a) => ({
+			id: a.id,
+			filename: a.filename,
+			url: a.content
+		}))
+	};
+}
+async function fetchComments(client, key) {
+	return (await client.getJson(`/rest/api/3/issue/${encodeURIComponent(key)}/comment?maxResults=100&orderBy=created`)).comments.map((c) => ({
+		author: c.author?.displayName ?? "",
+		created: c.created ?? "",
+		body: c.body ?? null
+	}));
+}
+//#endregion
+//#region src/commands/jira.ts
+async function jiraCopy(arg, options) {
+	const auth = await requireAuth();
+	const key = await resolveKey(arg);
+	const client = new AtlassianClient(auth);
+	console.log(`Fetching ${key} ...`);
+	const issue = await fetchIssue(client, auth.site, key);
+	const target = resolveOutput(issue.key, options.out);
+	const downloaded = await downloadAttachments(client, issue.attachments, target.assetsDir, target.assetsDirName);
+	const resolveMedia = mediaResolver(downloaded);
+	const document = joinSections([
+		frontmatter({
+			key: issue.key,
+			type: issue.type,
+			status: issue.status,
+			assignee: issue.assignee,
+			reporter: issue.reporter,
+			priority: issue.priority,
+			labels: issue.labels,
+			created: issue.created,
+			updated: issue.updated,
+			url: issue.url
+		}),
+		`# ${issue.summary}`,
+		adfToMarkdown(issue.description, { resolveMedia }),
+		commentsSection(issue.comments, resolveMedia),
+		attachmentsSection(downloaded)
+	]);
+	await writeFile(target.filePath, document, "utf8");
+	report(target.filePath, downloaded.length);
+}
+async function resolveKey(arg) {
+	const raw = arg ?? await input({
+		message: "Jira issue key or URL:",
+		required: true
+	});
+	const key = parseIssueKey(raw);
+	if (!key) throw new Error(`Could not find an issue key in "${raw}" (expected e.g. PROJ-123).`);
+	return key;
+}
+function report(filePath, assetCount) {
+	const suffix = assetCount > 0 ? ` (+${assetCount} attachment${assetCount === 1 ? "" : "s"})` : "";
+	console.log(`Wrote ${filePath}${suffix}`);
+}
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+program.name("atlass").description("Copy Jira issues and Confluence pages to Markdown.").version(version);
+const auth = program.command("auth").description("Manage Atlassian credentials");
+auth.command("login").description("Store site, email, and API token").action(run(login));
+auth.command("logout").description("Remove stored credentials").action(run(logout));
+auth.command("status").description("Show the current login").action(run(status));
+program.command("jira").description("Jira commands").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));
+program.command("confluence").description("Confluence commands").command("copy [page]").description("Copy a Confluence page (id or URL) to a Markdown file").option("-o, --out <path>", "output file or directory").action(run(confluenceCopy));
+program.parseAsync().catch(fail);
+function run(fn) {
+	return async (...args) => {
+		try {
+			await fn(...args);
+		} catch (err) {
+			fail(err);
+		}
+	};
+}
+function fail(err) {
+	if (err instanceof Error && err.name === "ExitPromptError") process.exit(130);
+	console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+	process.exit(1);
+}
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "atlass",
+	"version": "1.0.0",
+	"description": "CLI to copy Jira issues and Confluence pages to Markdown.",
+	"license": "MIT",
+	"bin": {
+		"atlass": "./dist/cli.mjs"
+	},
+	"files": [
+		"dist"
+	],
+	"type": "module",
+	"exports": {
+		".": "./dist/cli.mjs",
+		"./package.json": "./package.json"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "vp pack",
+		"dev": "vp pack --watch",
+		"test": "vp test",
+		"check": "vp check",
+		"prepublishOnly": "vp run build",
+		"prepare": "vp config",
+		"release": "bumpp"
+	},
+	"dependencies": {
+		"@inquirer/prompts": "^8.5.2",
+		"@napi-rs/keyring": "^1.3.0",
+		"commander": "^15.0.0"
+	},
+	"devDependencies": {
+		"@types/node": "^25.6.2",
+		"@typescript/native-preview": "7.0.0-dev.20260509.2",
+		"bumpp": "^11.1.0",
+		"typescript": "^6.0.3",
+		"vite-plus": "^0.1.20"
+	},
+	"packageManager": "pnpm@11.9.0"
+}