ai-dev-requirements 0.1.9 → 0.1.10

package/dist/index.mjs

@@ -65,6 +65,9 @@ const TASK_DETAIL_QUERY = `
   query Task($key: Key) {
     task(key: $key) {
       key uuid number name
+      description
+      descriptionText
+      desc_rich: description
       issueType { uuid name }
       status { uuid name category }
       priority { value }
@@ -294,7 +297,120 @@ function getSetCookies(response) {
 	const raw = response.headers.get("set-cookie");
 	return raw ? [raw] : [];
 }
-function toRequirement(task, description = "") {
+function extractWikiPageUuidsFromText(text) {
+	if (!text) return [];
+	const uuids = /* @__PURE__ */ new Set();
+	for (const pattern of [/\/page\/([\w-]+)/g, /page=([\w-]+)/g]) for (const match of text.matchAll(pattern)) if (match[1]) uuids.add(match[1]);
+	return [...uuids];
+}
+function htmlToPlainText(html) {
+	return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/\n{3,}/g, "\n\n").trim();
+}
+function getTaskDetailText(task) {
+	return task.descriptionText?.trim() || htmlToPlainText(task.desc_rich ?? task.description ?? "");
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseJsonRecord(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function asWikiBlocks(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter(isRecord);
+}
+function renderWikiTextRuns(value) {
+	if (!Array.isArray(value)) return "";
+	return value.map((run) => {
+		if (!isRecord(run)) return "";
+		const attributes = isRecord(run.attributes) ? run.attributes : {};
+		const insert = typeof run.insert === "string" ? run.insert.replace(/\u00A0/g, " ") : "";
+		const link = typeof attributes.link === "string" ? attributes.link : "";
+		if (link && insert.trim()) return `[${insert}](${link})`;
+		const taskName = typeof attributes.taskName === "string" ? attributes.taskName : "";
+		if (link && taskName) return `[${taskName}](${link})`;
+		return insert;
+	}).join("").replace(/\n{3,}/g, "\n\n").trim();
+}
+function renderWikiHeading(text, heading) {
+	if (!heading) return text;
+	const level = Math.min(Math.max(Math.trunc(heading), 1), 6);
+	return `${"#".repeat(level)} ${text}`;
+}
+function getWikiImageSource(block) {
+	const embedData = isRecord(block.embedData) ? block.embedData : {};
+	return typeof embedData.src === "string" ? embedData.src.trim() : "";
+}
+function renderWikiEmbed(block, context) {
+	if (block.embedType === "image") {
+		const src = getWikiImageSource(block);
+		if (src && !context.imageSources.includes(src)) context.imageSources.push(src);
+		return src ? `[Image: ${src}]` : "[Image]";
+	}
+	return block.embedType ? `[Embed: ${block.embedType}]` : "";
+}
+function escapeWikiTableCell(value) {
+	return value.replace(/\|/g, "\\|").replace(/[ \t]*\n+[ \t]*/g, " ").trim();
+}
+function renderWikiCell(value, document, context) {
+	const blocks = asWikiBlocks(value);
+	if (!blocks.length) return "";
+	return blocks.map((block) => renderWikiBlock(block, document, context)).filter(Boolean).join(" ").replace(/[ \t]*\n+[ \t]*/g, " ").trim();
+}
+function renderWikiTable(block, document, context) {
+	const cols = typeof block.cols === "number" && block.cols > 0 ? Math.trunc(block.cols) : 0;
+	const children = Array.isArray(block.children) ? block.children.filter((child) => typeof child === "string") : [];
+	if (!cols || !children.length) return "";
+	const rows = [];
+	for (let index = 0; index < children.length; index += cols) {
+		const cells = children.slice(index, index + cols).map((childId) => escapeWikiTableCell(renderWikiCell(document[childId], document, context)));
+		while (cells.length < cols) cells.push("");
+		rows.push(`| ${cells.join(" | ")} |`);
+	}
+	if (rows.length > 1) rows.splice(1, 0, `| ${Array.from({ length: cols }, () => "---").join(" | ")} |`);
+	return rows.join("\n");
+}
+function renderWikiBlock(block, document, context) {
+	if (block.type === "table") return renderWikiTable(block, document, context);
+	if (block.type === "embed") return renderWikiEmbed(block, context);
+	const text = renderWikiTextRuns(block.text);
+	if (!text) return "";
+	if (block.type === "list") {
+		const level = typeof block.level === "number" ? Math.max(Math.trunc(block.level), 1) : 1;
+		return `${"  ".repeat(level - 1)}${block.ordered ? `${block.start ?? 1}.` : "-"} ${text}`;
+	}
+	return renderWikiHeading(text, block.heading);
+}
+function renderWikiContent(content, context = { imageSources: [] }) {
+	const trimmed = content.trim();
+	if (!trimmed) return "";
+	const document = parseJsonRecord(trimmed);
+	if (!document) return trimmed;
+	if (!("blocks" in document)) return trimmed;
+	return asWikiBlocks(document.blocks).map((block) => renderWikiBlock(block, document, context)).filter(Boolean).join("\n\n").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function mimeTypeFromFileName(fileName) {
+	const normalized = fileName.toLowerCase();
+	if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
+	if (normalized.endsWith(".gif")) return "image/gif";
+	if (normalized.endsWith(".webp")) return "image/webp";
+	if (normalized.endsWith(".svg")) return "image/svg+xml";
+	return "image/png";
+}
+function attachmentNameFromPath(path) {
+	const name = path.split("/").pop() || path;
+	try {
+		return decodeURIComponent(name);
+	} catch {
+		return name;
+	}
+}
+function toRequirement(task, description = "", attachments = []) {
 	return {
 		id: task.uuid,
 		source: "ones",
@@ -309,7 +425,7 @@ function toRequirement(task, description = "") {
 		createdAt: "",
 		updatedAt: "",
 		dueDate: null,
-		attachments: [],
+		attachments,
 		raw: task
 	};
 }
@@ -589,12 +705,51 @@ var OnesAdapter = class extends BaseAdapter {
 	* Fetch wiki page content via REST API.
 	* Endpoint: /wiki/api/wiki/team/{teamUuid}/online_page/{wikiUuid}/content
 	*/
+	async fetchWikiPageDetail(wikiUuid) {
+		const session = await this.login();
+		const url = `${this.config.apiBase}/wiki/api/wiki/team/${session.teamUuid}/page/${wikiUuid}/detail`;
+		const response = await fetch(url, { headers: { Authorization: `Bearer ${session.accessToken}` } });
+		if (!response.ok) return {};
+		return response.json();
+	}
+	buildWikiImageUrl(session, refUuid, source, token) {
+		const encodedRefUuid = encodeURIComponent(refUuid);
+		const encodedSource = source.split("/").map((part) => encodeURIComponent(part)).join("/");
+		const encodedToken = encodeURIComponent(token);
+		return `${this.config.apiBase}/wiki/api/wiki/editor/${session.teamUuid}/${encodedRefUuid}/resources/${encodedSource}?token=${encodedToken}`;
+	}
 	async fetchWikiContent(wikiUuid) {
 		const session = await this.login();
 		const url = `${this.config.apiBase}/wiki/api/wiki/team/${session.teamUuid}/online_page/${wikiUuid}/content`;
 		const response = await fetch(url, { headers: { Authorization: `Bearer ${session.accessToken}` } });
-		if (!response.ok) return "";
-		return (await response.json()).content ?? "";
+		if (!response.ok) return {
+			content: "",
+			attachments: []
+		};
+		const data = await response.json();
+		const renderContext = { imageSources: [] };
+		const content = renderWikiContent(typeof data.content === "string" ? data.content : "", renderContext);
+		const token = typeof data.token === "string" ? data.token : "";
+		if (!renderContext.imageSources.length || !token) return {
+			content,
+			attachments: []
+		};
+		const detail = await this.fetchWikiPageDetail(wikiUuid);
+		const refUuid = typeof detail.ref_uuid === "string" ? detail.ref_uuid : "";
+		if (!refUuid) return {
+			content,
+			attachments: []
+		};
+		return {
+			content,
+			attachments: renderContext.imageSources.map((source, index) => ({
+				id: `${wikiUuid}-image-${index + 1}`,
+				name: attachmentNameFromPath(source),
+				url: this.buildWikiImageUrl(session, refUuid, source, token),
+				mimeType: mimeTypeFromFileName(source),
+				size: 0
+			}))
+		};
 	}
 	/**
 	* Fetch a single task by UUID or number (e.g. "#95945" or "95945").
@@ -622,13 +777,27 @@ var OnesAdapter = class extends BaseAdapter {
 		}
 		const task = (await this.graphql(TASK_DETAIL_QUERY, { key: `task-${taskUuid}` }, "Task")).data?.task;
 		if (!task) throw new Error(`ONES: Task "${taskUuid}" not found`);
-		const wikiPages = task.relatedWikiPages ?? [];
-		const wikiContents = await Promise.all(wikiPages.filter((w) => !w.errorMessage).map(async (wiki) => {
-			const content = await this.fetchWikiContent(wiki.uuid);
+		const wikiRefs = /* @__PURE__ */ new Map();
+		for (const wiki of task.relatedWikiPages ?? []) if (!wiki.errorMessage) wikiRefs.set(wiki.uuid, {
+			title: wiki.title,
+			uuid: wiki.uuid
+		});
+		const detailForLinkExtraction = [
+			task.description,
+			task.descriptionText,
+			task.desc_rich
+		].filter(Boolean).join("\n");
+		for (const wikiUuid of extractWikiPageUuidsFromText(detailForLinkExtraction)) if (!wikiRefs.has(wikiUuid)) wikiRefs.set(wikiUuid, {
+			title: `Wiki ${wikiUuid}`,
+			uuid: wikiUuid
+		});
+		const wikiContents = await Promise.all([...wikiRefs.values()].map(async (wiki) => {
+			const rendered = await this.fetchWikiContent(wiki.uuid);
 			return {
 				title: wiki.title,
 				uuid: wiki.uuid,
-				content
+				content: rendered.content,
+				attachments: rendered.attachments
 			};
 		}));
 		const parts = [];
@@ -667,7 +836,18 @@ var OnesAdapter = class extends BaseAdapter {
 				else parts.push("(No content available)");
 			}
 		}
-		return toRequirement(task, parts.join("\n"));
+		const detailText = getTaskDetailText(task);
+		const hasWikiContent = wikiContents.some((wiki) => wiki.content.trim());
+		if (detailText && !hasWikiContent) {
+			parts.push("");
+			parts.push("---");
+			parts.push("");
+			parts.push("## Requirement Detail");
+			parts.push("");
+			parts.push(detailText);
+		}
+		const wikiAttachments = wikiContents.flatMap((wiki) => wiki.attachments);
+		return toRequirement(task, parts.join("\n"), wikiAttachments);
 	}
 	/**
 	* Search tasks assigned to current user via GraphQL.
@@ -1088,7 +1268,7 @@ const GetIssueDetailSchema = z.object({
 * Download an image from URL and return as base64 data URI.
 * Returns null if download fails.
 */
-async function downloadImageAsBase64(url) {
+async function downloadImageAsBase64$1(url) {
 	try {
 		const res = await fetch(url, { redirect: "follow" });
 		if (!res.ok) return null;
@@ -1114,7 +1294,7 @@ async function handleGetIssueDetail(input, adapters, defaultSource) {
 	if (!adapter) throw new Error(`Source "${sourceType}" is not configured. Available: ${[...adapters.keys()].join(", ")}`);
 	const detail = await adapter.getIssueDetail({ issueId: input.issueId });
 	const imageUrls = detail.descriptionRich ? extractImageUrls(detail.descriptionRich) : [];
-	const imageResults = await Promise.all(imageUrls.map((url) => downloadImageAsBase64(url)));
+	const imageResults = await Promise.all(imageUrls.map((url) => downloadImageAsBase64$1(url)));
 	const content = [{
 		type: "text",
 		text: formatIssueDetail(detail)
@@ -1200,15 +1380,54 @@ const GetRequirementSchema = z.object({
 	id: z.string().describe("The requirement/issue ID"),
 	source: z.string().optional().describe("Source to fetch from. If omitted, uses the default source.")
 });
+async function downloadImageAsBase64(url, fallbackMimeType = "image/png") {
+	try {
+		const res = await fetch(url, { redirect: "follow" });
+		if (!res.ok) return null;
+		const mimeType = (res.headers.get("content-type") ?? fallbackMimeType).split(";")[0].trim() || fallbackMimeType;
+		return {
+			base64: Buffer.from(await res.arrayBuffer()).toString("base64"),
+			mimeType
+		};
+	} catch {
+		return null;
+	}
+}
+function isImageAttachment(attachment) {
+	if (attachment.mimeType.startsWith("image/")) return true;
+	return /\.(?:png|jpe?g|gif|webp|svg)$/i.test(attachment.url);
+}
+function displayAttachmentUrl(url) {
+	try {
+		const parsed = new URL(url);
+		parsed.search = "";
+		parsed.hash = "";
+		return parsed.toString();
+	} catch {
+		return url.replace(/[?#].*$/, "");
+	}
+}
 async function handleGetRequirement(input, adapters, defaultSource) {
 	const sourceType = input.source ?? defaultSource;
 	if (!sourceType) throw new Error("No source specified and no default source configured");
 	const adapter = adapters.get(sourceType);
 	if (!adapter) throw new Error(`Source "${sourceType}" is not configured. Available: ${[...adapters.keys()].join(", ")}`);
-	return { content: [{
+	const requirement = await adapter.getRequirement({ id: input.id });
+	const imageAttachments = requirement.attachments.filter(isImageAttachment);
+	const imageResults = await Promise.all(imageAttachments.map((attachment) => downloadImageAsBase64(attachment.url, attachment.mimeType)));
+	const content = [{
 		type: "text",
-		text: formatRequirement(await adapter.getRequirement({ id: input.id }))
-	}] };
+		text: formatRequirement(requirement)
+	}];
+	for (const image of imageResults) {
+		if (!image) continue;
+		content.push({
+			type: "image",
+			data: image.base64,
+			mimeType: image.mimeType
+		});
+	}
+	return { content };
 }
 function formatRequirement(req) {
 	const lines = [
@@ -1229,7 +1448,7 @@ function formatRequirement(req) {
 	lines.push("", "## Description", "", req.description || "_No description_");
 	if (req.attachments.length > 0) {
 		lines.push("", "## Attachments");
-		for (const att of req.attachments) lines.push(`- [${att.name}](${att.url}) (${att.mimeType}, ${att.size} bytes)`);
+		for (const att of req.attachments) lines.push(`- [${att.name}](${displayAttachmentUrl(att.url)}) (${att.mimeType}, ${att.size} bytes)`);
 	}
 	return lines.join("\n");
 }