granola-toolkit 0.3.0 → 0.5.0

package/README.md

@@ -58,12 +58,14 @@ Export notes:
 
 ```bash
 node dist/cli.js notes --supabase "$HOME/Library/Application Support/Granola/supabase.json"
+node dist/cli.js notes --format json --output ./notes-json
 ```
 
 Export transcripts:
 
 ```bash
 node dist/cli.js transcripts --cache "$HOME/Library/Application Support/Granola/cache-v3.json"
+node dist/cli.js transcripts --format yaml --output ./transcripts-yaml
 ```
 
 ## How It Works
@@ -77,9 +79,10 @@ The flow is:
 1. read your local `supabase.json`
 2. extract the WorkOS access token from it
 3. call Granola's paginated documents API
-4. choose the best available note content for each document
-5. convert ProseMirror content into Markdown
-6. write one Markdown file per document into the output directory
+4. normalise each document into a structured note export
+5. choose the best available note content for each document
+6. render that export as Markdown, JSON, YAML, or raw JSON
+7. write one file per document into the output directory
 
 Content is chosen in this order:
 
@@ -88,7 +91,7 @@ Content is chosen in this order:
 3. `last_viewed_panel.original_content`
 4. raw `content`
 
-Each note file includes:
+Markdown note files include:
 
 - YAML frontmatter with the document id, created timestamp, updated timestamp, and tags
 - a top-level heading from the note title
@@ -102,20 +105,35 @@ The flow is:
 
 1. read Granola's cache JSON from disk
 2. parse the cache payload, whether it is double-encoded or already an object
-3. match transcript segments to documents by document id
-4. format segments as `[HH:MM:SS] Speaker: Text`
-5. write one `.txt` file per document into the output directory
+3. normalise transcript data into a structured export per document
+4. match transcript segments to documents by document id
+5. render each export as text, JSON, YAML, or raw JSON
+6. write one file per document into the output directory
 
 Speaker labels are currently normalised to:
 
 - `You` for `microphone`
 - `System` for everything else
 
+Structured output formats are useful when you want to post-process exports in scripts instead of reading the default human-oriented Markdown or text files.
+
 ### Incremental Writes
 
-Both commands are incremental. They only rewrite an export file when the source document appears newer than the file already on disk.
+Both commands keep a small hidden state file in the output directory to track:
+
+- document id to filename
+- content hash
+- source timestamp
+- last export time
+
+That state is used to:
+
+- keep filenames stable even if a meeting title changes later
+- skip rewrites when the rendered content is unchanged
+- migrate old files cleanly when the output format changes
+- delete stale exports when a document disappears from the source data
 
-That means repeated runs are cheap, and you can safely point the CLI at the same output directory over time.
+That makes repeated runs cheap and keeps long-lived export directories much cleaner.
 
 ## Config
 

package/dist/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
 //#region src/utils.ts
 const INVALID_FILENAME_CHARS = /[<>:"/\\|?*]/g;
 const CONTROL_CHARACTERS = /\p{Cc}/gu;
@@ -147,16 +148,6 @@ function latestDocumentTimestamp(document) {
 	});
 	return candidates[0] ?? document.updatedAt;
 }
-async function shouldWriteFile(filePath, updatedAt) {
-	try {
-		const existing = await stat(filePath);
-		const updatedTime = new Date(updatedAt);
-		if (Number.isNaN(updatedTime.getTime())) return true;
-		return updatedTime.getTime() > existing.mtime.getTime();
-	} catch {
-		return true;
-	}
-}
 async function writeTextFile(filePath, content) {
 	await mkdir(dirname(filePath), { recursive: true });
 	await writeFile(filePath, content, "utf8");
@@ -430,6 +421,170 @@ async function loadConfig(options) {
 	};
 }
 //#endregion
+//#region src/export-state.ts
+const EXPORT_STATE_VERSION = 1;
+function exportStatePath(outputDir, kind) {
+	return join(outputDir, `.granola-toolkit-${kind}-state.json`);
+}
+function emptyExportState(kind) {
+	return {
+		entries: {},
+		kind,
+		version: EXPORT_STATE_VERSION
+	};
+}
+function normaliseExportState(parsed, kind) {
+	const record = asRecord(parsed);
+	if (!record || record.version !== EXPORT_STATE_VERSION || record.kind !== kind) return emptyExportState(kind);
+	const rawEntries = asRecord(record.entries) ?? {};
+	return {
+		entries: Object.fromEntries(Object.entries(rawEntries).map(([id, entry]) => {
+			const value = asRecord(entry);
+			if (!value) return;
+			const fileName = stringValue(value.fileName);
+			const fileStem = stringValue(value.fileStem);
+			if (!fileName || !fileStem) return;
+			return [id, {
+				contentHash: stringValue(value.contentHash),
+				exportedAt: stringValue(value.exportedAt),
+				fileName,
+				fileStem,
+				sourceUpdatedAt: stringValue(value.sourceUpdatedAt)
+			}];
+		}).filter((entry) => Boolean(entry))),
+		kind,
+		version: EXPORT_STATE_VERSION
+	};
+}
+async function loadExportState(outputDir, kind) {
+	const statePath = exportStatePath(outputDir, kind);
+	try {
+		return normaliseExportState(parseJsonString(await readUtf8(statePath)), kind);
+	} catch {
+		return emptyExportState(kind);
+	}
+}
+function hashContent(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+function reserveStem(used, preferredStem, existingStem) {
+	if (existingStem && (used.get(existingStem) ?? 0) === 0) {
+		used.set(existingStem, 1);
+		return existingStem;
+	}
+	return makeUniqueFilename(preferredStem, used);
+}
+async function fileExists(pathname) {
+	try {
+		await stat(pathname);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function entryChanged(left, right) {
+	if (!left) return true;
+	return left.contentHash !== right.contentHash || left.exportedAt !== right.exportedAt || left.fileName !== right.fileName || left.fileStem !== right.fileStem || left.sourceUpdatedAt !== right.sourceUpdatedAt;
+}
+async function syncManagedExports({ items, kind, outputDir }) {
+	await ensureDirectory(outputDir);
+	const previousEntries = (await loadExportState(outputDir, kind)).entries;
+	const used = /* @__PURE__ */ new Map();
+	const plans = items.map((item) => {
+		const existing = previousEntries[item.id];
+		const fileStem = reserveStem(used, item.preferredStem, existing?.fileStem);
+		return {
+			content: item.content,
+			contentHash: hashContent(item.content),
+			existing,
+			fileName: `${fileStem}${item.extension}`,
+			fileStem,
+			id: item.id,
+			sourceUpdatedAt: item.sourceUpdatedAt
+		};
+	});
+	const activeIds = new Set(plans.map((plan) => plan.id));
+	const activeFileNames = new Set(plans.map((plan) => plan.fileName));
+	const exportedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const nextEntries = {};
+	let written = 0;
+	let stateChanged = false;
+	for (const plan of plans) {
+		const filePath = join(outputDir, plan.fileName);
+		const shouldWrite = !plan.existing || plan.existing.contentHash !== plan.contentHash || plan.existing.fileName !== plan.fileName || !await fileExists(filePath);
+		if (shouldWrite) {
+			await writeTextFile(filePath, plan.content);
+			written += 1;
+		}
+		const nextEntry = {
+			contentHash: plan.contentHash,
+			exportedAt: shouldWrite ? exportedAt : plan.existing?.exportedAt ?? exportedAt,
+			fileName: plan.fileName,
+			fileStem: plan.fileStem,
+			sourceUpdatedAt: plan.sourceUpdatedAt
+		};
+		nextEntries[plan.id] = nextEntry;
+		stateChanged = stateChanged || entryChanged(plan.existing, nextEntry);
+	}
+	for (const plan of plans) {
+		const previousFileName = plan.existing?.fileName;
+		if (previousFileName && previousFileName !== plan.fileName && !activeFileNames.has(previousFileName)) {
+			await rm(join(outputDir, previousFileName), { force: true });
+			stateChanged = true;
+		}
+	}
+	for (const [id, entry] of Object.entries(previousEntries)) {
+		if (activeIds.has(id)) continue;
+		if (!activeFileNames.has(entry.fileName)) await rm(join(outputDir, entry.fileName), { force: true });
+		stateChanged = true;
+	}
+	const serialisedState = `${JSON.stringify({
+		entries: nextEntries,
+		kind,
+		version: EXPORT_STATE_VERSION
+	}, null, 2)}\n`;
+	const statePath = exportStatePath(outputDir, kind);
+	const existingState = await fileExists(statePath) ? await readUtf8(statePath) : void 0;
+	if (stateChanged || existingState !== serialisedState) await writeTextFile(statePath, serialisedState);
+	return written;
+}
+//#endregion
+//#region src/render.ts
+function formatScalar(value) {
+	if (value == null) return "null";
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+function renderYaml(value, depth = 0) {
+	const indent = "  ".repeat(depth);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return [`${indent}[]`];
+		return value.flatMap((item) => {
+			if (item && typeof item === "object" && !Array.isArray(item)) {
+				const nested = renderYaml(item, depth + 1);
+				return [`${indent}- ${(nested[0] ?? `${"  ".repeat(depth + 1)}{}`).trimStart()}`, ...nested.slice(1)];
+			}
+			return [`${indent}- ${formatScalar(item)}`];
+		});
+	}
+	if (value && typeof value === "object") {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return [`${indent}{}`];
+		return entries.flatMap(([key, entryValue]) => {
+			if (Array.isArray(entryValue) || entryValue && typeof entryValue === "object") return [`${indent}${key}:`, ...renderYaml(entryValue, depth + 1)];
+			return [`${indent}${key}: ${formatScalar(entryValue)}`];
+		});
+	}
+	return [`${indent}${formatScalar(value)}`];
+}
+function toYaml(value) {
+	return `${renderYaml(value).join("\n").trimEnd()}\n`;
+}
+function toJson(value) {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+//#endregion
 //#region src/prosemirror.ts
 function repeatIndent(level) {
 	return "  ".repeat(level);
@@ -525,38 +680,104 @@ function extractPlainText(doc) {
 }
 //#endregion
 //#region src/notes.ts
-function documentToMarkdown(document) {
+function selectNoteContent(document) {
+	const notes = convertProseMirrorToMarkdown(document.notes).trim();
+	if (notes) return {
+		content: notes,
+		source: "notes"
+	};
+	const lastViewedPanel = convertProseMirrorToMarkdown(document.lastViewedPanel?.content).trim();
+	if (lastViewedPanel) return {
+		content: lastViewedPanel,
+		source: "lastViewedPanel.content"
+	};
+	const originalContent = htmlToMarkdownFallback(document.lastViewedPanel?.originalContent ?? "").trim();
+	if (originalContent) return {
+		content: originalContent,
+		source: "lastViewedPanel.originalContent"
+	};
+	return {
+		content: document.content.trim(),
+		source: "content"
+	};
+}
+function buildNoteExport(document) {
+	const { content, source } = selectNoteContent(document);
+	return {
+		content,
+		contentSource: source,
+		createdAt: document.createdAt,
+		id: document.id,
+		raw: document,
+		tags: document.tags,
+		title: document.title,
+		updatedAt: document.updatedAt
+	};
+}
+function renderNoteExport(note, format = "markdown") {
+	switch (format) {
+		case "json": return toJson({
+			content: note.content,
+			contentSource: note.contentSource,
+			createdAt: note.createdAt,
+			id: note.id,
+			tags: note.tags,
+			title: note.title,
+			updatedAt: note.updatedAt
+		});
+		case "raw": return toJson(note.raw);
+		case "yaml": return toYaml({
+			content: note.content,
+			contentSource: note.contentSource,
+			createdAt: note.createdAt,
+			id: note.id,
+			tags: note.tags,
+			title: note.title,
+			updatedAt: note.updatedAt
+		});
+		case "markdown": break;
+	}
 	const lines = [
 		"---",
-		`id: ${quoteYamlString(document.id)}`,
-		`created: ${quoteYamlString(document.createdAt)}`,
-		`updated: ${quoteYamlString(document.updatedAt)}`
+		`id: ${quoteYamlString(note.id)}`,
+		`created: ${quoteYamlString(note.createdAt)}`,
+		`updated: ${quoteYamlString(note.updatedAt)}`
 	];
-	if (document.tags.length > 0) {
+	if (note.tags.length > 0) {
 		lines.push("tags:");
-		for (const tag of document.tags) lines.push(`  - ${quoteYamlString(tag)}`);
+		for (const tag of note.tags) lines.push(`  - ${quoteYamlString(tag)}`);
 	}
 	lines.push("---", "");
-	if (document.title.trim()) lines.push(`# ${document.title.trim()}`, "");
-	const content = convertProseMirrorToMarkdown(document.notes).trim() || convertProseMirrorToMarkdown(document.lastViewedPanel?.content).trim() || htmlToMarkdownFallback(document.lastViewedPanel?.originalContent ?? "").trim() || document.content.trim();
-	if (content) lines.push(content);
+	if (note.title.trim()) lines.push(`# ${note.title.trim()}`, "");
+	if (note.content) lines.push(note.content);
 	return `${lines.join("\n").trimEnd()}\n`;
 }
 function documentFilename(document) {
 	return sanitiseFilename(document.title || document.id, "untitled");
 }
-async function writeNotes(documents, outputDir) {
-	await ensureDirectory(outputDir);
-	const sorted = [...documents].sort((left, right) => compareStrings(left.title || left.id, right.title || right.id) || compareStrings(left.id, right.id));
-	const used = /* @__PURE__ */ new Map();
-	let written = 0;
-	for (const document of sorted) {
-		const filePath = join(outputDir, `${makeUniqueFilename(documentFilename(document), used)}.md`);
-		if (!await shouldWriteFile(filePath, latestDocumentTimestamp(document))) continue;
-		await writeTextFile(filePath, documentToMarkdown(document));
-		written += 1;
+function noteFileExtension(format) {
+	switch (format) {
+		case "json": return ".json";
+		case "raw": return ".raw.json";
+		case "yaml": return ".yaml";
+		case "markdown": return ".md";
 	}
-	return written;
+}
+async function writeNotes(documents, outputDir, format = "markdown") {
+	return await syncManagedExports({
+		items: [...documents].sort((left, right) => compareStrings(left.title || left.id, right.title || right.id) || compareStrings(left.id, right.id)).map((document) => {
+			const note = buildNoteExport(document);
+			return {
+				content: renderNoteExport(note, format),
+				extension: noteFileExtension(format),
+				id: note.id,
+				preferredStem: documentFilename(document),
+				sourceUpdatedAt: latestDocumentTimestamp(document)
+			};
+		}),
+		kind: "notes",
+		outputDir
+	});
 }
 //#endregion
 //#region src/commands/shared.ts
@@ -572,7 +793,8 @@ Usage:
   granola notes [options]
 
 Options:
-  --output <path>     Output directory for Markdown files (default: ./notes)
+  --format <value>    Output format: markdown, json, yaml, raw (default: markdown)
+  --output <path>     Output directory for note files (default: ./notes)
   --timeout <value>   Request timeout, e.g. 2m, 30s, 120000 (default: 2m)
   --supabase <path>   Path to supabase.json
   --debug             Enable debug logging
@@ -581,8 +803,9 @@ Options:
 `;
 }
 const notesCommand = {
-	description: "Export Granola notes to Markdown",
+	description: "Export Granola notes",
 	flags: {
+		format: { type: "string" },
 		help: { type: "boolean" },
 		output: { type: "string" },
 		timeout: { type: "string" }
@@ -599,6 +822,8 @@ const notesCommand = {
 		debug(config.debug, "supabase", config.supabase);
 		debug(config.debug, "timeoutMs", config.notes.timeoutMs);
 		debug(config.debug, "output", config.notes.output);
+		const format = resolveNoteFormat(commandFlags.format);
+		debug(config.debug, "format", format);
 		console.log("Fetching documents from Granola API...");
 		const tokenProvider = new CachedTokenProvider(new SupabaseFileTokenSource(config.supabase), new NoopTokenStore());
 		const documents = await new GranolaApiClient(new AuthenticatedHttpClient({
@@ -606,12 +831,22 @@ const notesCommand = {
 			tokenProvider
 		})).listDocuments({ timeoutMs: config.notes.timeoutMs });
 		console.log(`Exporting ${documents.length} notes to ${config.notes.output}...`);
-		const written = await writeNotes(documents, config.notes.output);
+		const written = await writeNotes(documents, config.notes.output, format);
 		console.log("✓ Export completed successfully");
 		debug(config.debug, "notes written", written);
 		return 0;
 	}
 };
+function resolveNoteFormat(value) {
+	switch (value) {
+		case void 0: return "markdown";
+		case "json":
+		case "markdown":
+		case "raw":
+		case "yaml": return value;
+		default: throw new Error("invalid notes format: expected markdown, json, yaml, or raw");
+	}
+}
 //#endregion
 //#region src/cache.ts
 function parseCacheDocument(id, value) {
@@ -668,50 +903,103 @@ function parseCacheContents(contents) {
 }
 //#endregion
 //#region src/transcripts.ts
-function formatTranscript(document, segments) {
-	if (segments.length === 0) return "";
+function buildTranscriptExport(document, segments) {
+	const renderedSegments = segments.map((segment) => ({
+		endTimestamp: segment.endTimestamp,
+		id: segment.id,
+		isFinal: segment.isFinal,
+		source: segment.source,
+		speaker: transcriptSpeakerLabel(segment),
+		startTimestamp: segment.startTimestamp,
+		text: segment.text
+	}));
+	return {
+		createdAt: document.createdAt,
+		id: document.id,
+		raw: {
+			document,
+			segments
+		},
+		segments: renderedSegments,
+		title: document.title,
+		updatedAt: document.updatedAt
+	};
+}
+function renderTranscriptExport(transcript, format = "text") {
+	switch (format) {
+		case "json": return toJson({
+			createdAt: transcript.createdAt,
+			id: transcript.id,
+			segments: transcript.segments,
+			title: transcript.title,
+			updatedAt: transcript.updatedAt
+		});
+		case "raw": return toJson(transcript.raw);
+		case "yaml": return toYaml({
+			createdAt: transcript.createdAt,
+			id: transcript.id,
+			segments: transcript.segments,
+			title: transcript.title,
+			updatedAt: transcript.updatedAt
+		});
+		case "text": break;
+	}
+	return formatTranscriptText(transcript);
+}
+function formatTranscriptText(transcript) {
+	if (transcript.segments.length === 0) return "";
 	const header = [
 		"=".repeat(80),
-		document.title || document.id,
-		`ID: ${document.id}`,
-		document.createdAt ? `Created: ${document.createdAt}` : "",
-		document.updatedAt ? `Updated: ${document.updatedAt}` : "",
-		`Segments: ${segments.length}`,
+		transcript.title || transcript.id,
+		`ID: ${transcript.id}`,
+		transcript.createdAt ? `Created: ${transcript.createdAt}` : "",
+		transcript.updatedAt ? `Updated: ${transcript.updatedAt}` : "",
+		`Segments: ${transcript.segments.length}`,
 		"=".repeat(80),
 		""
 	].filter(Boolean);
-	const body = segments.map((segment) => {
-		return `[${formatTimestampForTranscript(segment.startTimestamp)}] ${transcriptSpeakerLabel(segment)}: ${segment.text}`;
+	const body = transcript.segments.map((segment) => {
+		return `[${formatTimestampForTranscript(segment.startTimestamp)}] ${segment.speaker}: ${segment.text}`;
 	});
 	return `${[...header, ...body].join("\n").trimEnd()}\n`;
 }
 function transcriptFilename(document) {
 	return sanitiseFilename(document.title || document.id, "untitled");
 }
-async function writeTranscripts(cacheData, outputDir) {
-	await ensureDirectory(outputDir);
-	const entries = Object.entries(cacheData.transcripts).filter(([, segments]) => segments.length > 0).sort(([leftId], [rightId]) => {
-		const leftDocument = cacheData.documents[leftId];
-		const rightDocument = cacheData.documents[rightId];
-		return compareStrings(leftDocument?.title || leftId, rightDocument?.title || rightId) || compareStrings(leftId, rightId);
-	});
-	const used = /* @__PURE__ */ new Map();
-	let written = 0;
-	for (const [documentId, segments] of entries) {
-		const document = cacheData.documents[documentId] ?? {
-			createdAt: "",
-			id: documentId,
-			title: documentId,
-			updatedAt: ""
-		};
-		const filePath = join(outputDir, `${makeUniqueFilename(transcriptFilename(document), used)}.txt`);
-		if (!await shouldWriteFile(filePath, document.updatedAt)) continue;
-		const content = formatTranscript(document, segments);
-		if (!content) continue;
-		await writeTextFile(filePath, content);
-		written += 1;
+function transcriptFileExtension(format) {
+	switch (format) {
+		case "json": return ".json";
+		case "raw": return ".raw.json";
+		case "text": return ".txt";
+		case "yaml": return ".yaml";
 	}
-	return written;
+}
+async function writeTranscripts(cacheData, outputDir, format = "text") {
+	return await syncManagedExports({
+		items: Object.entries(cacheData.transcripts).filter(([, segments]) => segments.length > 0).sort(([leftId], [rightId]) => {
+			const leftDocument = cacheData.documents[leftId];
+			const rightDocument = cacheData.documents[rightId];
+			return compareStrings(leftDocument?.title || leftId, rightDocument?.title || rightId) || compareStrings(leftId, rightId);
+		}).flatMap(([documentId, segments]) => {
+			const document = cacheData.documents[documentId] ?? {
+				createdAt: "",
+				id: documentId,
+				title: documentId,
+				updatedAt: ""
+			};
+			const content = renderTranscriptExport(buildTranscriptExport(document, segments), format);
+			if (!content) return [];
+			return [{
+				content,
+				extension: transcriptFileExtension(format),
+				id: document.id,
+				preferredStem: transcriptFilename(document),
+				sourceUpdatedAt: document.updatedAt
+			}];
+		}),
+		kind: "transcripts",
+		outputDir
+	});
 }
 //#endregion
 //#region src/commands/transcripts.ts
@@ -723,18 +1011,18 @@ Usage:
 
 Options:
   --cache <path>      Path to Granola cache JSON
+  --format <value>    Output format: text, json, yaml, raw (default: text)
   --output <path>     Output directory for transcript files (default: ./transcripts)
   --debug             Enable debug logging
   --config <path>     Path to .granola.toml
   -h, --help          Show help
 `;
 }
-//#endregion
-//#region src/commands/index.ts
-const commands = [notesCommand, {
-	description: "Export Granola transcripts to text files",
+const transcriptsCommand = {
+	description: "Export Granola transcripts",
 	flags: {
 		cache: { type: "string" },
+		format: { type: "string" },
 		help: { type: "boolean" },
 		output: { type: "string" }
 	},
@@ -749,16 +1037,31 @@ const commands = [notesCommand, {
 		debug(config.debug, "using config", config.configFileUsed ?? "(none)");
 		debug(config.debug, "cacheFile", config.transcripts.cacheFile);
 		debug(config.debug, "output", config.transcripts.output);
+		const format = resolveTranscriptFormat(commandFlags.format);
+		debug(config.debug, "format", format);
 		console.log("Reading Granola cache file...");
 		const cacheData = parseCacheContents(await readFile(config.transcripts.cacheFile, "utf8"));
 		const transcriptCount = Object.values(cacheData.transcripts).filter((segments) => segments.length > 0).length;
 		console.log(`Exporting ${transcriptCount} transcripts to ${config.transcripts.output}...`);
-		const written = await writeTranscripts(cacheData, config.transcripts.output);
+		const written = await writeTranscripts(cacheData, config.transcripts.output, format);
 		console.log("✓ Export completed successfully");
 		debug(config.debug, "transcripts written", written);
 		return 0;
 	}
-}];
+};
+function resolveTranscriptFormat(value) {
+	switch (value) {
+		case void 0: return "text";
+		case "json":
+		case "raw":
+		case "text":
+		case "yaml": return value;
+		default: throw new Error("invalid transcripts format: expected text, json, yaml, or raw");
+	}
+}
+//#endregion
+//#region src/commands/index.ts
+const commands = [notesCommand, transcriptsCommand];
 const commandMap = new Map(commands.map((command) => [command.name, command]));
 //#endregion
 //#region src/flags.ts

package/package.json

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