granola-toolkit 0.1.0 → 0.3.0

package/README.md

@@ -146,17 +146,9 @@ Supported environment variables:
 - `CACHE_FILE`
 - `TRANSCRIPT_OUTPUT`
 
-## What Changed In The Port
+## Development Checks
 
-This port deliberately preserves the Go repo's architecture, but it also fixes a few obvious rough edges instead of copying them blindly:
-
-- deterministic export ordering, so duplicate-title suffixes are stable across runs
-- shared filename sanitisation between notes and transcripts
-- cross-platform default path discovery for both `supabase.json` and cache files
-- HTML fallback for note export is converted into readable Markdown-ish text instead of being dumped raw
-- transcript timestamps preserve the original clock time instead of being normalised to UTC
-
-## Verify
+Before pushing changes, run:
 
 ```bash
 vp check
@@ -165,54 +157,11 @@ vp pack
 npm pack --dry-run
 ```
 
-`vp build` is for web apps. This repo publishes a CLI bundle, so the correct build step here is `vp pack`.
-
-## Publishing
-
-Any push to `main` with a package version that is not already on npm becomes a publish candidate automatically. The workflow verifies the build, checks whether `package.json` contains an unpublished version, and then pauses in the `production` environment until someone approves the deployment review in GitHub.
-
-That means you can use either flow:
-
-- merge a PR that already includes the version bump
-- run the local release helper on `main`
-
-Local release helper:
-
-```bash
-npm run release
-```
-
-That script:
-
-1. verifies the git working tree is clean
-2. verifies you are on `main`
-3. bumps the package version with `npm version --no-git-tag-version`
-4. commits and pushes the release commit
-5. lets the push-to-`main` workflow create a publish candidate automatically
-
-You can also choose the bump type explicitly:
-
-```bash
-npm run release patch
-npm run release minor
-npm run release major
-```
-
-The GitHub Actions release job then:
-
-- installs dependencies with Vite+ via `setup-vp`
-- runs `vp check`, `vp test`, `vp pack`, and `npm pack --dry-run`
-- checks npm first and skips the publish job if that exact version already exists
-- waits for approval on the `production` environment before npm credentials are exposed
-- publishes to npm using `NPM_TOKEN`
-- tags the published version as `v<version>`
-
-### GitHub Setup
-
-To get the review dialog you showed in the screenshots, configure this once in GitHub:
+What those do:
 
-1. create a `production` environment in repository Settings -> Environments
-2. add required reviewers to that environment
-3. add `NPM_TOKEN` as an environment secret on `production`
+- `vp check`: formatting, linting, and type checks
+- `vp test`: unit tests
+- `vp pack`: builds the CLI bundle into `dist/cli.js`
+- `npm pack --dry-run`: shows the exact npm package contents without publishing
 
-After that, merges to `main` that contain a new unpublished version will stop at "Review deployments". Approving that deployment is what allows the npm publish step to run.
+`vp build` is for web apps. This repo is a CLI package, so the build step here is `vp pack`.

package/dist/cli.js

@@ -171,10 +171,56 @@ function transcriptSpeakerLabel(segment) {
 	return segment.source === "microphone" ? "You" : "System";
 }
 //#endregion
-//#region src/api.ts
-const USER_AGENT = "Granola/5.354.0";
-const CLIENT_VERSION = "5.354.0";
-const DOCUMENTS_URL = "https://api.granola.ai/v2/get-documents";
+//#region src/client/auth.ts
+function getAccessTokenFromSupabaseContents(supabaseContents) {
+	const wrapper = parseJsonString(supabaseContents);
+	if (!wrapper) throw new Error("failed to parse supabase.json");
+	const workosTokens = wrapper.workos_tokens;
+	let tokenPayload;
+	if (typeof workosTokens === "string") tokenPayload = parseJsonString(workosTokens);
+	else tokenPayload = asRecord(workosTokens);
+	const accessToken = tokenPayload ? stringValue(tokenPayload.access_token) : "";
+	if (!accessToken.trim()) throw new Error("access token not found in supabase.json");
+	return accessToken;
+}
+var SupabaseFileTokenSource = class {
+	constructor(filePath) {
+		this.filePath = filePath;
+	}
+	async loadAccessToken() {
+		return getAccessTokenFromSupabaseContents(await readFile(this.filePath, "utf8"));
+	}
+};
+var NoopTokenStore = class {
+	async clearToken() {}
+	async readToken() {}
+	async writeToken(_token) {}
+};
+var CachedTokenProvider = class {
+	#token;
+	constructor(source, store = new NoopTokenStore()) {
+		this.source = source;
+		this.store = store;
+	}
+	async getAccessToken() {
+		if (this.#token) return this.#token;
+		const storedToken = await this.store.readToken();
+		if (storedToken?.trim()) {
+			this.#token = storedToken;
+			return storedToken;
+		}
+		const token = await this.source.loadAccessToken();
+		this.#token = token;
+		await this.store.writeToken(token);
+		return token;
+	}
+	async invalidate() {
+		this.#token = void 0;
+		await this.store.clearToken();
+	}
+};
+//#endregion
+//#region src/client/parsers.ts
 function parseProseMirrorDoc(value, options = {}) {
 	if (value == null) return;
 	if (typeof value === "string") {
@@ -209,17 +255,6 @@ function parseLastViewedPanel(value) {
 		updatedAt: stringValue(panel.updated_at)
 	};
 }
-function getAccessToken(supabaseContents) {
-	const wrapper = parseJsonString(supabaseContents);
-	if (!wrapper) throw new Error("failed to parse supabase.json");
-	const workosTokens = wrapper.workos_tokens;
-	let tokenPayload;
-	if (typeof workosTokens === "string") tokenPayload = parseJsonString(workosTokens);
-	else tokenPayload = asRecord(workosTokens);
-	const accessToken = tokenPayload ? stringValue(tokenPayload.access_token) : "";
-	if (!accessToken.trim()) throw new Error("access token not found in supabase.json");
-	return accessToken;
-}
 function parseDocument(value) {
 	const record = asRecord(value);
 	if (!record) throw new Error("document payload is not an object");
@@ -235,98 +270,93 @@ function parseDocument(value) {
 		updatedAt: stringValue(record.updated_at)
 	};
 }
-async function fetchDocuments(options) {
-	const fetchImpl = options.fetchImpl ?? fetch;
-	const accessToken = getAccessToken(options.supabaseContents);
-	const documents = [];
-	const url = options.url ?? DOCUMENTS_URL;
-	const limit = 100;
-	let offset = 0;
-	for (;;) {
-		const signal = AbortSignal.timeout(options.timeoutMs);
-		const response = await fetchImpl(url, {
-			body: JSON.stringify({
+//#endregion
+//#region src/client/granola.ts
+const USER_AGENT = "Granola/5.354.0";
+const CLIENT_VERSION = "5.354.0";
+const DOCUMENTS_URL = "https://api.granola.ai/v2/get-documents";
+var GranolaApiClient = class {
+	constructor(httpClient, documentsUrl = DOCUMENTS_URL) {
+		this.httpClient = httpClient;
+		this.documentsUrl = documentsUrl;
+	}
+	async listDocuments(options) {
+		const documents = [];
+		const limit = options.limit ?? 100;
+		let offset = 0;
+		for (;;) {
+			const response = await this.httpClient.postJson(this.documentsUrl, {
 				include_last_viewed_panel: true,
 				limit,
 				offset
-			}),
+			}, {
+				headers: {
+					"User-Agent": USER_AGENT,
+					"X-Client-Version": CLIENT_VERSION
+				},
+				timeoutMs: options.timeoutMs
+			});
+			if (!response.ok) {
+				const body = (await response.text()).slice(0, 500);
+				throw new Error(`failed to get documents: ${response.status} ${response.statusText}${body ? `: ${body}` : ""}`);
+			}
+			const payload = await response.json();
+			if (!Array.isArray(payload.docs)) throw new Error("failed to parse documents response");
+			const page = payload.docs.map(parseDocument);
+			documents.push(...page);
+			if (page.length < limit) break;
+			offset += limit;
+		}
+		return documents;
+	}
+};
+//#endregion
+//#region src/client/http.ts
+var AuthenticatedHttpClient = class {
+	fetchImpl;
+	constructor(options) {
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.logger = options.logger;
+		this.tokenProvider = options.tokenProvider;
+	}
+	logger;
+	tokenProvider;
+	async request(options) {
+		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)
+		});
+		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
+			});
+		}
+		return response;
+	}
+	async postJson(url, body, options = { timeoutMs: 3e4 }) {
+		return this.request({
+			...options,
+			body: JSON.stringify(body),
 			headers: {
 				Accept: "*/*",
-				Authorization: `Bearer ${accessToken}`,
 				"Content-Type": "application/json",
-				"User-Agent": USER_AGENT,
-				"X-Client-Version": CLIENT_VERSION
+				...options.headers
 			},
 			method: "POST",
-			signal
+			url
 		});
-		if (!response.ok) {
-			const body = (await response.text()).slice(0, 500);
-			throw new Error(`failed to get documents: ${response.status} ${response.statusText}${body ? `: ${body}` : ""}`);
-		}
-		const payload = await response.json();
-		if (!Array.isArray(payload.docs)) throw new Error("failed to parse documents response");
-		const page = payload.docs.map(parseDocument);
-		documents.push(...page);
-		if (page.length < limit) break;
-		offset += limit;
 	}
-	return documents;
-}
-//#endregion
-//#region src/cache.ts
-function parseCacheDocument(id, value) {
-	const record = asRecord(value);
-	if (!record) return;
-	return {
-		createdAt: stringValue(record.created_at),
-		id,
-		title: stringValue(record.title),
-		updatedAt: stringValue(record.updated_at)
-	};
-}
-function parseTranscriptSegments(value) {
-	if (!Array.isArray(value)) return;
-	return value.flatMap((segment) => {
-		const record = asRecord(segment);
-		if (!record) return [];
-		return [{
-			documentId: stringValue(record.document_id),
-			endTimestamp: stringValue(record.end_timestamp),
-			id: stringValue(record.id),
-			isFinal: Boolean(record.is_final),
-			source: stringValue(record.source),
-			startTimestamp: stringValue(record.start_timestamp),
-			text: stringValue(record.text)
-		}];
-	});
-}
-function parseCacheContents(contents) {
-	const outer = parseJsonString(contents);
-	if (!outer) throw new Error("failed to parse cache JSON");
-	const rawCache = outer.cache;
-	let cachePayload;
-	if (typeof rawCache === "string") cachePayload = parseJsonString(rawCache);
-	else cachePayload = asRecord(rawCache);
-	const state = cachePayload ? asRecord(cachePayload.state) : void 0;
-	if (!state) throw new Error("failed to parse cache state");
-	const rawDocuments = asRecord(state.documents) ?? {};
-	const rawTranscripts = asRecord(state.transcripts) ?? {};
-	const documents = {};
-	for (const [id, rawDocument] of Object.entries(rawDocuments)) {
-		const document = parseCacheDocument(id, rawDocument);
-		if (document) documents[id] = document;
-	}
-	const transcripts = {};
-	for (const [id, rawTranscript] of Object.entries(rawTranscripts)) {
-		const segments = parseTranscriptSegments(rawTranscript);
-		if (segments) transcripts[id] = segments;
-	}
-	return {
-		documents,
-		transcripts
-	};
-}
+};
 //#endregion
 //#region src/config.ts
 function pickString(value) {
@@ -529,6 +559,114 @@ async function writeNotes(documents, outputDir) {
 	return written;
 }
 //#endregion
+//#region src/commands/shared.ts
+function debug(enabled, ...values) {
+	if (enabled) console.error("[debug]", ...values);
+}
+//#endregion
+//#region src/commands/notes.ts
+function notesHelp() {
+	return `Granola notes
+
+Usage:
+  granola notes [options]
+
+Options:
+  --output <path>     Output directory for Markdown files (default: ./notes)
+  --timeout <value>   Request timeout, e.g. 2m, 30s, 120000 (default: 2m)
+  --supabase <path>   Path to supabase.json
+  --debug             Enable debug logging
+  --config <path>     Path to .granola.toml
+  -h, --help          Show help
+`;
+}
+const notesCommand = {
+	description: "Export Granola notes to Markdown",
+	flags: {
+		help: { type: "boolean" },
+		output: { type: "string" },
+		timeout: { type: "string" }
+	},
+	help: notesHelp,
+	name: "notes",
+	async run({ commandFlags, globalFlags }) {
+		const config = await loadConfig({
+			globalFlags,
+			subcommandFlags: commandFlags
+		});
+		if (!config.supabase) throw new Error(`supabase.json not found. Pass --supabase or create .granola.toml. Expected locations include: ${granolaSupabaseCandidates().join(", ")}`);
+		debug(config.debug, "using config", config.configFileUsed ?? "(none)");
+		debug(config.debug, "supabase", config.supabase);
+		debug(config.debug, "timeoutMs", config.notes.timeoutMs);
+		debug(config.debug, "output", config.notes.output);
+		console.log("Fetching documents from Granola API...");
+		const tokenProvider = new CachedTokenProvider(new SupabaseFileTokenSource(config.supabase), new NoopTokenStore());
+		const documents = await new GranolaApiClient(new AuthenticatedHttpClient({
+			logger: console,
+			tokenProvider
+		})).listDocuments({ timeoutMs: config.notes.timeoutMs });
+		console.log(`Exporting ${documents.length} notes to ${config.notes.output}...`);
+		const written = await writeNotes(documents, config.notes.output);
+		console.log("✓ Export completed successfully");
+		debug(config.debug, "notes written", written);
+		return 0;
+	}
+};
+//#endregion
+//#region src/cache.ts
+function parseCacheDocument(id, value) {
+	const record = asRecord(value);
+	if (!record) return;
+	return {
+		createdAt: stringValue(record.created_at),
+		id,
+		title: stringValue(record.title),
+		updatedAt: stringValue(record.updated_at)
+	};
+}
+function parseTranscriptSegments(value) {
+	if (!Array.isArray(value)) return;
+	return value.flatMap((segment) => {
+		const record = asRecord(segment);
+		if (!record) return [];
+		return [{
+			documentId: stringValue(record.document_id),
+			endTimestamp: stringValue(record.end_timestamp),
+			id: stringValue(record.id),
+			isFinal: Boolean(record.is_final),
+			source: stringValue(record.source),
+			startTimestamp: stringValue(record.start_timestamp),
+			text: stringValue(record.text)
+		}];
+	});
+}
+function parseCacheContents(contents) {
+	const outer = parseJsonString(contents);
+	if (!outer) throw new Error("failed to parse cache JSON");
+	const rawCache = outer.cache;
+	let cachePayload;
+	if (typeof rawCache === "string") cachePayload = parseJsonString(rawCache);
+	else cachePayload = asRecord(rawCache);
+	const state = cachePayload ? asRecord(cachePayload.state) : void 0;
+	if (!state) throw new Error("failed to parse cache state");
+	const rawDocuments = asRecord(state.documents) ?? {};
+	const rawTranscripts = asRecord(state.transcripts) ?? {};
+	const documents = {};
+	for (const [id, rawDocument] of Object.entries(rawDocuments)) {
+		const document = parseCacheDocument(id, rawDocument);
+		if (document) documents[id] = document;
+	}
+	const transcripts = {};
+	for (const [id, rawTranscript] of Object.entries(rawTranscripts)) {
+		const segments = parseTranscriptSegments(rawTranscript);
+		if (segments) transcripts[id] = segments;
+	}
+	return {
+		documents,
+		transcripts
+	};
+}
+//#endregion
 //#region src/transcripts.ts
 function formatTranscript(document, segments) {
 	if (segments.length === 0) return "";
@@ -576,7 +714,54 @@ async function writeTranscripts(cacheData, outputDir) {
 	return written;
 }
 //#endregion
-//#region src/cli.ts
+//#region src/commands/transcripts.ts
+function transcriptsHelp() {
+	return `Granola transcripts
+
+Usage:
+  granola transcripts [options]
+
+Options:
+  --cache <path>      Path to Granola cache JSON
+  --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",
+	flags: {
+		cache: { type: "string" },
+		help: { type: "boolean" },
+		output: { type: "string" }
+	},
+	help: transcriptsHelp,
+	name: "transcripts",
+	async run({ commandFlags, globalFlags }) {
+		const config = await loadConfig({
+			globalFlags,
+			subcommandFlags: commandFlags
+		});
+		if (!config.transcripts.cacheFile) throw new Error(`Granola cache file not found. Pass --cache or create .granola.toml. Expected locations include: ${granolaCacheCandidates().join(", ")}`);
+		debug(config.debug, "using config", config.configFileUsed ?? "(none)");
+		debug(config.debug, "cacheFile", config.transcripts.cacheFile);
+		debug(config.debug, "output", config.transcripts.output);
+		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);
+		console.log("✓ Export completed successfully");
+		debug(config.debug, "transcripts written", written);
+		return 0;
+	}
+}];
+const commandMap = new Map(commands.map((command) => [command.name, command]));
+//#endregion
+//#region src/flags.ts
 function parseBooleanValue(value) {
 	if (/^(true|1|yes|on)$/i.test(value)) return true;
 	if (/^(false|0|no|off)$/i.test(value)) return false;
@@ -624,13 +809,15 @@ function parseFlags(args, spec) {
 		values
 	};
 }
+//#endregion
+//#region src/cli.ts
 function splitCommand(argv) {
-	const commands = new Set(["notes", "transcripts"]);
 	const rest = [];
 	let command;
 	for (const token of argv) {
-		if (!command && !token.startsWith("-") && commands.has(token)) {
-			command = token;
+		const candidate = !token.startsWith("-") ? commandMap.get(token) : void 0;
+		if (!command && candidate) {
+			command = candidate;
 			continue;
 		}
 		rest.push(token);
@@ -641,6 +828,7 @@ function splitCommand(argv) {
 	};
 }
 function rootHelp() {
+	const commandWidth = Math.max(...commands.map((command) => command.name.length));
 	return `Granola CLI
 
 Export your Granola notes and transcripts.
@@ -649,8 +837,7 @@ Usage:
   granola <command> [options]
 
 Commands:
-  notes        Export Granola notes to Markdown
-  transcripts  Export Granola transcripts to text files
+${commands.map((command) => `  ${command.name.padEnd(commandWidth)}  ${command.description}`).join("\n")}
 
 Global options:
   --config <path>     Path to .granola.toml
@@ -663,38 +850,6 @@ Examples:
   granola transcripts --cache "${granolaCacheCandidates()[0] ?? "/path/to/cache-v3.json"}"
 `;
 }
-function notesHelp() {
-	return `Granola notes
-
-Usage:
-  granola notes [options]
-
-Options:
-  --output <path>     Output directory for Markdown files (default: ./notes)
-  --timeout <value>   Request timeout, e.g. 2m, 30s, 120000 (default: 2m)
-  --supabase <path>   Path to supabase.json
-  --debug             Enable debug logging
-  --config <path>     Path to .granola.toml
-  -h, --help          Show help
-`;
-}
-function transcriptsHelp() {
-	return `Granola transcripts
-
-Usage:
-  granola transcripts [options]
-
-Options:
-  --cache <path>      Path to Granola cache JSON
-  --output <path>     Output directory for transcript files (default: ./transcripts)
-  --debug             Enable debug logging
-  --config <path>     Path to .granola.toml
-  -h, --help          Show help
-`;
-}
-function debug(enabled, ...values) {
-	if (enabled) console.error("[debug]", ...values);
-}
 async function runCli(argv) {
 	try {
 		const { command, rest } = splitCommand(argv);
@@ -712,68 +867,15 @@ async function runCli(argv) {
 			console.log(rootHelp());
 			return 1;
 		}
-		switch (command) {
-			case "notes": {
-				const subcommand = parseFlags(global.rest, {
-					help: { type: "boolean" },
-					output: { type: "string" },
-					timeout: { type: "string" }
-				});
-				if (subcommand.values.help || global.values.help) {
-					console.log(notesHelp());
-					return 0;
-				}
-				const config = await loadConfig({
-					globalFlags: global.values,
-					subcommandFlags: subcommand.values
-				});
-				if (!config.supabase) throw new Error(`supabase.json not found. Pass --supabase or create .granola.toml. Expected locations include: ${granolaSupabaseCandidates().join(", ")}`);
-				debug(config.debug, "using config", config.configFileUsed ?? "(none)");
-				debug(config.debug, "supabase", config.supabase);
-				debug(config.debug, "timeoutMs", config.notes.timeoutMs);
-				debug(config.debug, "output", config.notes.output);
-				console.log("Fetching documents from Granola API...");
-				const documents = await fetchDocuments({
-					supabaseContents: await readFile(config.supabase, "utf8"),
-					timeoutMs: config.notes.timeoutMs
-				});
-				console.log(`Exporting ${documents.length} notes to ${config.notes.output}...`);
-				const written = await writeNotes(documents, config.notes.output);
-				console.log("✓ Export completed successfully");
-				debug(config.debug, "notes written", written);
-				return 0;
-			}
-			case "transcripts": {
-				const subcommand = parseFlags(global.rest, {
-					cache: { type: "string" },
-					help: { type: "boolean" },
-					output: { type: "string" }
-				});
-				if (subcommand.values.help || global.values.help) {
-					console.log(transcriptsHelp());
-					return 0;
-				}
-				const config = await loadConfig({
-					globalFlags: global.values,
-					subcommandFlags: subcommand.values
-				});
-				if (!config.transcripts.cacheFile) throw new Error(`Granola cache file not found. Pass --cache or create .granola.toml. Expected locations include: ${granolaCacheCandidates().join(", ")}`);
-				debug(config.debug, "using config", config.configFileUsed ?? "(none)");
-				debug(config.debug, "cacheFile", config.transcripts.cacheFile);
-				debug(config.debug, "output", config.transcripts.output);
-				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);
-				console.log("✓ Export completed successfully");
-				debug(config.debug, "transcripts written", written);
-				return 0;
-			}
-			default:
-				console.log(rootHelp());
-				return 1;
+		const subcommand = parseFlags(global.rest, command.flags);
+		if (subcommand.values.help || global.values.help) {
+			console.log(command.help());
+			return 0;
 		}
+		return await command.run({
+			commandFlags: subcommand.values,
+			globalFlags: global.values
+		});
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		console.error(message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granola-toolkit",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "CLI toolkit for exporting and working with Granola notes and transcripts",
   "keywords": [
     "cli",
@@ -15,7 +15,7 @@
   "author": "Nima Karimi",
   "repository": {
     "type": "git",
-    "url": "git@github.com:kkarimi/granola-toolkit.git"
+    "url": "git+https://github.com/kkarimi/granola-toolkit.git"
   },
   "bin": {
     "granola": "dist/cli.js"
@@ -37,8 +37,11 @@
     "fmt": "vp fmt",
     "lint": "vp lint",
     "pack:dry-run": "npm pack --dry-run",
-    "prepublishOnly": "vp pack",
+    "prepublishOnly": "node scripts/prepublish.mjs",
     "release": "node scripts/release.mjs",
+    "release:major": "node scripts/release.mjs major",
+    "release:minor": "node scripts/release.mjs minor",
+    "release:patch": "node scripts/release.mjs patch",
     "start": "node dist/cli.js",
     "notes": "node dist/cli.js notes",
     "transcripts": "node dist/cli.js transcripts",