granola-toolkit 0.11.0 → 0.13.0

package/README.md

@@ -214,6 +214,7 @@ Supported environment variables:
 - `TIMEOUT`
 - `CACHE_FILE`
 - `TRANSCRIPT_OUTPUT`
+- `GRANOLA_CLIENT_VERSION`
 
 ## Development Checks
 

package/dist/cli.js

@@ -540,13 +540,23 @@ function parseDocument(value) {
 }
 //#endregion
 //#region src/client/granola.ts
-const USER_AGENT = "Granola/5.354.0";
-const CLIENT_VERSION = "5.354.0";
+const DEFAULT_CLIENT_VERSION = "5.354.0";
 const DOCUMENTS_URL = "https://api.granola.ai/v2/get-documents";
+function resolveClientVersion(value) {
+	return value?.trim() || process.env.GRANOLA_CLIENT_VERSION?.trim() || DEFAULT_CLIENT_VERSION;
+}
 var GranolaApiClient = class {
-	constructor(httpClient, documentsUrl = DOCUMENTS_URL) {
+	clientVersion;
+	documentsUrl;
+	constructor(httpClient, options = DOCUMENTS_URL) {
 		this.httpClient = httpClient;
-		this.documentsUrl = documentsUrl;
+		if (typeof options === "string") {
+			this.documentsUrl = options;
+			this.clientVersion = resolveClientVersion();
+			return;
+		}
+		this.documentsUrl = options.documentsUrl ?? DOCUMENTS_URL;
+		this.clientVersion = resolveClientVersion(options.clientVersion);
 	}
 	async listDocuments(options) {
 		const documents = [];
@@ -559,8 +569,8 @@ var GranolaApiClient = class {
 				offset
 			}, {
 				headers: {
-					"User-Agent": USER_AGENT,
-					"X-Client-Version": CLIENT_VERSION
+					"User-Agent": `Granola/${this.clientVersion}`,
+					"X-Client-Version": this.clientVersion
 				},
 				timeoutMs: options.timeoutMs
 			});
@@ -580,35 +590,79 @@ var GranolaApiClient = class {
 };
 //#endregion
 //#region src/client/http.ts
+const RETRYABLE_STATUS_CODES = new Set([
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+function sleep(delayMs) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, delayMs);
+	});
+}
+function parseRetryAfter(headerValue) {
+	if (!headerValue?.trim()) return;
+	if (/^\d+$/.test(headerValue.trim())) return Number(headerValue.trim()) * 1e3;
+	const retryAt = Date.parse(headerValue);
+	if (Number.isNaN(retryAt)) return;
+	return Math.max(0, retryAt - Date.now());
+}
 var AuthenticatedHttpClient = class {
 	fetchImpl;
 	constructor(options) {
 		this.fetchImpl = options.fetchImpl ?? fetch;
 		this.logger = options.logger;
+		this.maxRetries = options.maxRetries ?? 2;
+		this.retryBaseDelayMs = options.retryBaseDelayMs ?? 500;
+		this.retryMaxDelayMs = options.retryMaxDelayMs ?? 5e3;
+		this.sleepImpl = options.sleepImpl ?? sleep;
 		this.tokenProvider = options.tokenProvider;
 	}
 	logger;
+	maxRetries;
+	retryBaseDelayMs;
+	retryMaxDelayMs;
+	sleepImpl;
 	tokenProvider;
-	async request(options) {
+	async retry(options, attempt, reason, response) {
+		const retryAfterMs = parseRetryAfter(response?.headers.get("retry-after") ?? null);
+		const delayMs = Math.min(retryAfterMs ?? this.retryBaseDelayMs * 2 ** attempt, this.retryMaxDelayMs);
+		this.logger?.warn?.(`${reason}; retrying in ${delayMs}ms (${attempt + 1}/${this.maxRetries})`);
+		await this.sleepImpl(delayMs);
+		return this.request(options, attempt + 1);
+	}
+	async request(options, attempt = 0) {
 		const { retryOnUnauthorized = true, timeoutMs, url } = options;
 		const accessToken = await this.tokenProvider.getAccessToken();
-		const response = await this.fetchImpl(url, {
-			body: options.body,
-			headers: {
-				...options.headers,
-				Authorization: `Bearer ${accessToken}`
-			},
-			method: options.method ?? "GET",
-			signal: AbortSignal.timeout(timeoutMs)
-		});
+		let response;
+		try {
+			response = await this.fetchImpl(url, {
+				body: options.body,
+				headers: {
+					...options.headers,
+					Authorization: `Bearer ${accessToken}`
+				},
+				method: options.method ?? "GET",
+				signal: AbortSignal.timeout(timeoutMs)
+			});
+		} catch (error) {
+			if (attempt < this.maxRetries) {
+				const message = error instanceof Error ? error.message : String(error);
+				return this.retry(options, attempt, `request failed: ${message}`);
+			}
+			throw error;
+		}
 		if (response.status === 401 && retryOnUnauthorized) {
 			this.logger?.warn?.("request returned 401; invalidating token provider and retrying once");
 			await this.tokenProvider.invalidate();
 			return this.request({
 				...options,
 				retryOnUnauthorized: false
-			});
+			}, attempt);
 		}
+		if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.maxRetries) return this.retry(options, attempt, `request returned ${response.status} ${response.statusText || ""}`.trim(), response);
 		return response;
 	}
 	async postJson(url, body, options = { timeoutMs: 3e4 }) {
@@ -885,6 +939,9 @@ function toJson(value) {
 function repeatIndent(level) {
 	return "  ".repeat(level);
 }
+function escapeMarkdownText(text) {
+	return text.replace(/\\/g, "\\\\").replace(/([*_`[\]])/g, "\\$1");
+}
 function renderInline(nodes = []) {
 	return nodes.map((node) => renderInlineNode(node)).join("");
 }
@@ -895,6 +952,9 @@ function applyMarks(text, marks = []) {
 			case "em": return `*${current}*`;
 			case "code": return `\`${current}\``;
 			case "strike": return `~~${current}~~`;
+			case "underline": return `<u>${current}</u>`;
+			case "subscript": return `<sub>${current}</sub>`;
+			case "superscript": return `<sup>${current}</sup>`;
 			case "link": {
 				const href = typeof mark.attrs?.href === "string" ? mark.attrs.href : void 0;
 				return href ? `[${current}](${href})` : current;
@@ -905,8 +965,9 @@ function applyMarks(text, marks = []) {
 }
 function renderInlineNode(node) {
 	switch (node.type) {
-		case "text": return applyMarks(node.text ?? "", node.marks);
+		case "text": return applyMarks(escapeMarkdownText(node.text ?? ""), node.marks);
 		case "hardBreak": return "  \n";
+		case "mention": return applyMarks(escapeMarkdownText(typeof node.attrs?.label === "string" ? node.attrs.label : typeof node.attrs?.text === "string" ? node.attrs.text : typeof node.attrs?.name === "string" ? node.attrs.name : renderInline(node.content)), node.marks);
 		default: return applyMarks(renderInline(node.content), node.marks);
 	}
 }
@@ -914,21 +975,45 @@ function indentLines(value, level) {
 	const indent = repeatIndent(level);
 	return value.split("\n").map((line) => line.length === 0 ? line : `${indent}${line}`).join("\n");
 }
-function renderList(items, ordered, indentLevel) {
-	return items.map((item, index) => renderListItem(item, ordered ? `${index + 1}.` : "-", indentLevel)).join("\n");
+function renderList(items, ordered, indentLevel, start = 1) {
+	return items.map((item, index) => renderListItem(item, ordered ? `${start + index}.` : "-", indentLevel)).join("\n");
 }
 function renderListItem(node, marker, indentLevel) {
 	const children = node.content ?? [];
 	const blockChildren = children.filter((child) => child.type !== "bulletList" && child.type !== "orderedList");
 	const nestedLists = children.filter((child) => child.type === "bulletList" || child.type === "orderedList");
 	const mainText = blockChildren.map((child) => renderBlock(child, indentLevel + 1)).filter(Boolean).join("\n").trim();
-	let output = `${`${repeatIndent(indentLevel)}${marker} `}${mainText || ""}`.trimEnd();
+	const prefix = `${repeatIndent(indentLevel)}${marker} `;
+	const continuationIndent = `${repeatIndent(indentLevel)}${" ".repeat(marker.length + 1)}`;
+	let output = `${prefix}${mainText.split("\n").map((line, index) => index === 0 ? line : `${continuationIndent}${line}`).join("\n") || ""}`.trimEnd();
 	if (nestedLists.length > 0) {
 		const nestedText = nestedLists.map((child) => renderBlock(child, indentLevel + 1)).filter(Boolean).map((value) => indentLines(value, 0)).join("\n");
 		output = `${output}\n${nestedText}`;
 	}
 	return output;
 }
+function renderTaskList(items, indentLevel) {
+	return items.map((item) => renderTaskItem(item, indentLevel)).join("\n");
+}
+function renderTaskItem(node, indentLevel) {
+	return renderListItem(node, node.attrs?.checked === true ? "[x]" : "[ ]", indentLevel);
+}
+function renderTableCell(node) {
+	return renderBlocks(node.content ?? [], 0).replace(/\n+/g, " <br> ").replace(/\|/g, "\\|").trim();
+}
+function renderTable(node) {
+	const rows = (node.content ?? []).map((row) => (row.content ?? []).map((cell) => renderTableCell(cell))).filter((row) => row.length > 0);
+	if (rows.length === 0) return "";
+	const header = rows[0];
+	const body = rows.slice(1);
+	const separator = header.map(() => "---");
+	const lines = [`| ${header.map((cell) => cell || " ").join(" | ")} |`, `| ${separator.join(" | ")} |`];
+	for (const row of body) {
+		const padded = header.map((_, index) => row[index] ?? " ");
+		lines.push(`| ${padded.join(" | ")} |`);
+	}
+	return lines.join("\n");
+}
 function renderBlock(node, indentLevel) {
 	switch (node.type) {
 		case "heading": {
@@ -937,10 +1022,25 @@ function renderBlock(node, indentLevel) {
 		}
 		case "paragraph": return renderInline(node.content).trim();
 		case "bulletList": return renderList(node.content ?? [], false, indentLevel);
-		case "orderedList": return renderList(node.content ?? [], true, indentLevel);
+		case "orderedList": {
+			const start = typeof node.attrs?.start === "number" ? node.attrs.start : 1;
+			return renderList(node.content ?? [], true, indentLevel, start);
+		}
 		case "listItem": return renderListItem(node, "-", indentLevel);
+		case "taskList": return renderTaskList(node.content ?? [], indentLevel);
+		case "taskItem": return renderTaskItem(node, indentLevel);
+		case "table": return renderTable(node);
+		case "tableRow": return (node.content ?? []).map((cell) => renderTableCell(cell)).join(" | ");
+		case "tableCell":
+		case "tableHeader": return renderTableCell(node);
 		case "blockquote": return renderBlocks(node.content ?? [], indentLevel).split("\n").map((line) => line ? `> ${line}` : ">").join("\n").trim();
-		case "codeBlock": return `\`\`\`\n${extractPlainText(node).trimEnd()}\n\`\`\``;
+		case "codeBlock": {
+			const text = extractPlainText({
+				type: "doc",
+				content: node.content
+			}).trimEnd();
+			return `\`\`\`${typeof node.attrs?.language === "string" ? node.attrs.language.trim() : typeof node.attrs?.params === "string" ? node.attrs.params.trim() : ""}\n${text}\n\`\`\``;
+		}
 		case "horizontalRule": return "---";
 		case "hardBreak": return "";
 		case "text": return renderInlineNode(node);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granola-toolkit",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "CLI toolkit for exporting and working with Granola notes and transcripts",
   "keywords": [
     "cli",