@lodestar-oss/quicksave 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,22 +1,66 @@
 #!/usr/bin/env node
 import { cli, command, description, name, option, parse, printErrors, printHelp, printVersion, schema, version } from "@bomb.sh/router";
-import { cancel, confirm, isCancel, log, outro } from "@clack/prompts";
-import { ENV_FILE_NAME, loadDotEnvFile } from "@little-nebulae/node-env";
+import { cancel, intro, log, outro } from "@clack/prompts";
+import { BaseError, DEFAULT_FAILURE_REASON, UnexpectedError, composeErrorMessage, isError } from "@little-nebulae/error";
+import { nodeLoadEnvFileList } from "@little-nebulae/node-env";
+import { prettifyError, z } from "zod";
 import { NonEmptyStringSchema } from "@little-nebulae/zod-schemas";
-import { z } from "zod";
+import { constants } from "node:os";
+import { attemptAsync, fail, succeed } from "@little-nebulae/result";
+import { x } from "tinyexec";
 import { createGroq } from "@ai-sdk/groq";
 import { generateText } from "ai";
-import { x } from "tinyexec";
+import { clackConfirm } from "@little-nebulae/clack";
+// src/constants.ts
+const CANCEL_EXIT_CODE = 128 + constants.signals.SIGINT;
+const OPERATION_FAILED_OUTRO = "Operation failed.";
+const MODE_ENUM = {
+	STAGED: "staged",
+	ALL: "all",
+	ASK: "ask"
+};
+const LOCKFILE_TUPLE = [
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"yarn.lock",
+	"deno.lock",
+	"bun.lock"
+];
 // package.json
-var version$1 = "0.2.0";
+var version$1 = "0.3.0";
 // src/app.ts
 const SwitchOptionSchema = z.preprocess((value) => typeof value === "undefined" ? false : value, z.boolean());
-const app = command(name("quicksave"), description("A conventional commit generator using LLM."), version(version$1), option(name("cwd"), cli(["--cwd", "-C"]), schema(NonEmptyStringSchema.default(process.cwd()))), option(name("staged"), cli(["--staged", "-s"], { switch: true }), schema(SwitchOptionSchema)), option(name("all"), cli(["--all", "-a"], { switch: true }), schema(SwitchOptionSchema)));
+const app = command(name("quicksave"), description("A conventional commit generator using LLM."), version(version$1), option(name("cwd"), cli(["--cwd", "-C"]), schema(NonEmptyStringSchema.default(process.cwd()))), option(name(MODE_ENUM.STAGED), cli(["--staged", "-s"], { switch: true }), schema(SwitchOptionSchema)), option(name(MODE_ENUM.ALL), cli(["--all", "-a"], { switch: true }), schema(SwitchOptionSchema)));
 // src/config/env.ts
 const EnvSchema = z.object({ GROQ_API_KEY: z.templateLiteral(["gsk_", NonEmptyStringSchema]) });
-function getEnvVars() {
-	return EnvSchema.parse(process.env);
+// src/features/git/ops/restore-index.ts
+async function restoreIndex({ cwd, treeId }) {
+	return attemptAsync({
+		tryFn: async () => {
+			await x("git", ["read-tree", treeId], {
+				nodeOptions: { cwd },
+				throwOnError: true
+			});
+		},
+		catchFn: (error) => new UnexpectedError({
+			message: composeErrorMessage({ operation: "unstaged the added changes" }),
+			cause: error,
+			meta: null
+		})
+	});
 }
+// src/errors/empty-commit-message.ts
+var EmptyCommitMessageError = class extends BaseError {
+	name = "EmptyCommitMessageError";
+	code = "EMPTY_COMMIT_MESSAGE_ERROR";
+	constructor(meta) {
+		super({
+			message: "The LLM provider responded with empty content",
+			cause: null,
+			meta
+		});
+	}
+};
 // src/features/ai/system-prompt.ts
 const SYSTEM_PROMPT = `You write Git commit messages that follow the Conventional Commits 1.0.0 specification.
 
@@ -69,106 +113,281 @@ Footers
 - Be specific. Prefer "fix(auth): reject expired refresh tokens" over "fix: update auth logic".
 - Never mention that you are an AI or that the message was generated.`;
 // src/features/ai/ops/generate-commit-message.ts
-async function generateCommitMessage({ diff }) {
-	const env = getEnvVars();
-	const groqProvider = createGroq({ apiKey: env.GROQ_API_KEY });
-	const { text } = await generateText({
-		model: groqProvider("openai/gpt-oss-20b"),
-		instructions: SYSTEM_PROMPT,
-		prompt: `<diff>\n${diff}\n</diff>`
+async function generateCommitMessage({ diff, env }) {
+	return attemptAsync({
+		tryFn: async () => {
+			const groqProvider = createGroq({ apiKey: env.GROQ_API_KEY });
+			const generation = await generateText({
+				model: groqProvider("openai/gpt-oss-20b"),
+				instructions: SYSTEM_PROMPT,
+				prompt: `<diff>\n${diff}\n</diff>`
+			});
+			const message = generation.text.trim();
+			const meta = {
+				finishReason: generation.finishReason,
+				usage: generation.usage,
+				warnings: generation.warnings,
+				finalStep: generation.finalStep
+			};
+			if (message.length === 0) throw new EmptyCommitMessageError(meta);
+			return {
+				message,
+				meta
+			};
+		},
+		catchFn: (error) => {
+			if (error instanceof EmptyCommitMessageError) return error;
+			return new UnexpectedError({
+				message: composeErrorMessage({ operation: "generate commit message" }),
+				cause: error,
+				meta: null
+			});
+		}
+	});
+}
+// src/errors/empty-diff.ts
+var EmptyDiffError = class extends BaseError {
+	name = "EmptyDiffError";
+	code = "EMPTY_DIFF_ERROR";
+	constructor() {
+		super({
+			message: "No staged changes to commit.",
+			cause: null,
+			meta: null
+		});
+	}
+};
+// src/features/git/ops/get-staged-diff.ts
+async function getStagedDiff({ cwd }) {
+	return attemptAsync({
+		tryFn: async () => {
+			const diff = (await x("git", [
+				"diff",
+				"--staged",
+				"--no-color",
+				"--no-ext-diff",
+				"--find-renames",
+				"--",
+				":/",
+				...LOCKFILE_TUPLE.map((f) => `:(exclude,glob)**/${f}`)
+			], {
+				nodeOptions: { cwd },
+				throwOnError: true
+			})).stdout.trim();
+			if (diff.length === 0) throw new EmptyDiffError();
+			return diff;
+		},
+		catchFn: (error) => {
+			if (error instanceof EmptyDiffError) return error;
+			return new UnexpectedError({
+				message: composeErrorMessage({ operation: "get staged diff" }),
+				cause: error,
+				meta: null
+			});
+		}
+	});
+}
+// src/ops/get-commit-message.ts
+async function getCommitMessage({ cwd, env }) {
+	const getStagedDiffResult = await getStagedDiff({ cwd });
+	if (!getStagedDiffResult.success) return getStagedDiffResult;
+	const diff = getStagedDiffResult.data;
+	return await generateCommitMessage({
+		diff,
+		env
 	});
-	return text.trim();
 }
 // src/features/git/ops/commit-staged-changes.ts
 async function commitStagedChanges({ cwd, message }) {
-	await x("git", [
-		"commit",
-		"-m",
+	return attemptAsync({
+		tryFn: async () => {
+			await x("git", [
+				"commit",
+				"-m",
+				message
+			], {
+				throwOnError: true,
+				nodeOptions: { cwd }
+			});
+		},
+		catchFn: (error) => new UnexpectedError({
+			message: composeErrorMessage({ operation: "commit staged changes" }),
+			cause: error,
+			meta: null
+		})
+	});
+}
+// src/ops/handle-commit.ts
+async function handleCommit({ isTTY, cwd, message }) {
+	let shouldCommit = true;
+	if (isTTY) {
+		const confirmCommitResult = await clackConfirm({
+			message: "Do you want to commit with the generated message?",
+			isTTY
+		});
+		if (!confirmCommitResult.success) return confirmCommitResult;
+		shouldCommit = confirmCommitResult.data;
+	}
+	if (!shouldCommit) return succeed({ committed: false });
+	const commitStagedChangesResult = await commitStagedChanges({
+		cwd,
 		message
-	], {
-		throwOnError: true,
-		nodeOptions: { cwd }
 	});
+	if (!commitStagedChangesResult.success) return commitStagedChangesResult;
+	return succeed({ committed: true });
 }
 // src/features/git/ops/get-all-changes.ts
 async function getAllChanges({ cwd }) {
-	const { stdout } = await x("git", [
-		"status",
-		"--porcelain=v1",
-		"-z",
-		"--untracked-files=all"
-	], {
-		nodeOptions: { cwd },
-		throwOnError: true
-	});
-	const changes = [];
-	if (stdout.trim().length === 0) return changes;
-	const parts = stdout.split("\0").filter((part) => part.length > 0);
-	for (let i = 0; i < parts.length; i++) {
-		const entry = parts[i];
-		const staged = entry[0];
-		const unstaged = entry[1];
-		const path = entry.slice(3);
-		if (staged === "R" || staged === "C") i++;
-		changes.push({
-			path,
-			status: {
-				staged,
-				unstaged
+	return attemptAsync({
+		tryFn: async () => {
+			const { stdout } = await x("git", [
+				"status",
+				"--porcelain=v1",
+				"-z",
+				"--untracked-files=all"
+			], {
+				nodeOptions: { cwd },
+				throwOnError: true
+			});
+			const changes = [];
+			if (stdout.trim().length === 0) return changes;
+			const parts = stdout.split("\0").filter((part) => part.length > 0);
+			for (let i = 0; i < parts.length; i++) {
+				const entry = parts[i];
+				const staged = entry[0];
+				const unstaged = entry[1];
+				const path = entry.slice(3);
+				if (staged === "R" || staged === "C") i++;
+				changes.push({
+					path,
+					status: {
+						staged,
+						unstaged
+					}
+				});
 			}
-		});
-	}
-	return changes;
-}
-// src/constants.ts
-const LOCKFILE_TUPLE = [
-	"package-lock.json",
-	"pnpm-lock.yaml",
-	"yarn.lock",
-	"deno.lock",
-	"bun.lock"
-];
-// src/features/git/ops/get-staged-diff.ts
-async function getStagedDiff({ cwd }) {
-	return (await x("git", [
-		"diff",
-		"--staged",
-		"--no-color",
-		"--no-ext-diff",
-		"--find-renames",
-		"--",
-		":/",
-		...LOCKFILE_TUPLE.map((f) => `:(exclude,glob)**/${f}`)
-	], {
-		nodeOptions: { cwd },
-		throwOnError: true
-	})).stdout.trim();
-}
-// src/features/git/ops/restore-index.ts
-async function restoreIndex({ cwd, treeId }) {
-	await x("git", ["read-tree", treeId], {
-		nodeOptions: { cwd },
-		throwOnError: true
+			return changes;
+		},
+		catchFn: (error) => new UnexpectedError({
+			message: composeErrorMessage({ operation: "get all changes made to the repo" }),
+			cause: error,
+			meta: null
+		})
 	});
 }
 // src/features/git/ops/snapshot-index.ts
 async function snapshotIndex({ cwd }) {
-	return (await x("git", ["write-tree"], {
-		nodeOptions: { cwd },
-		throwOnError: true
-	})).stdout.trim();
+	return attemptAsync({
+		tryFn: async () => {
+			return (await x("git", ["write-tree"], {
+				nodeOptions: { cwd },
+				throwOnError: true
+			})).stdout.trim();
+		},
+		catchFn: (error) => new UnexpectedError({
+			message: composeErrorMessage({ operation: "snapshot the current state of the repo" }),
+			cause: error,
+			meta: null
+		})
+	});
 }
 // src/features/git/ops/stage-all-changes.ts
 async function stageAllChanges({ cwd }) {
-	await x("git", ["add", "-A"], {
-		nodeOptions: { cwd },
-		throwOnError: true
+	return attemptAsync({
+		tryFn: async () => {
+			await x("git", ["add", "-A"], {
+				nodeOptions: { cwd },
+				throwOnError: true
+			});
+		},
+		catchFn: (error) => new UnexpectedError({
+			message: composeErrorMessage({ operation: "add all unstaged changes" }),
+			cause: error,
+			meta: null
+		})
+	});
+}
+// src/ops/handle-unstaged-changes.ts
+async function handleUnstagedChanges({ cwd, mode }) {
+	if (mode === "staged") return succeed({
+		snapshotted: false,
+		reason: "In staged mode, unstaged changes are ignored."
+	});
+	const getAllChangesResult = await getAllChanges({ cwd });
+	if (!getAllChangesResult.success) return getAllChangesResult;
+	if (!getAllChangesResult.data.some((change) => change.status.unstaged !== " ")) return succeed({
+		snapshotted: false,
+		reason: "The repo has no unstaged changes"
+	});
+	if (mode === "ask") {
+		const confirmStageResult = await clackConfirm({
+			message: "You have unstaged changes. Do you want to add them all?",
+			isTTY: true
+		});
+		if (!confirmStageResult.success) return confirmStageResult;
+		if (!confirmStageResult.data) return succeed({
+			snapshotted: false,
+			reason: "The user doesn't want to add all unstaged changes"
+		});
+	}
+	const snapshotIndexResult = await snapshotIndex({ cwd });
+	if (!snapshotIndexResult.success) return snapshotIndexResult;
+	const treeId = snapshotIndexResult.data;
+	const stageAllChangesResult = await stageAllChanges({ cwd });
+	if (!stageAllChangesResult.success) return stageAllChangesResult;
+	return succeed({
+		snapshotted: true,
+		treeId
 	});
 }
+// src/errors/conflicting-options.ts
+var ConflictingOptionsError = class extends BaseError {
+	name = "ConflictingOptionsError";
+	code = "CONFLICTING_OPTIONS_ERROR";
+	constructor({ message, options }) {
+		super({
+			message,
+			cause: options,
+			meta: null
+		});
+	}
+};
+// src/errors/missing-options.ts
+var MissingOptionsError = class extends BaseError {
+	name = "MissingOptionsError";
+	code = "MISSING_OPTIONS_ERROR";
+	constructor({ message, options }) {
+		super({
+			message,
+			cause: options,
+			meta: null
+		});
+	}
+};
+// src/ops/resolve-mode.ts
+function resolveMode({ staged, all, isTTY }) {
+	if (staged && all) return fail(new ConflictingOptionsError({
+		message: `Conflicting options: ${MODE_ENUM.STAGED}, ${MODE_ENUM.ALL}`,
+		options: {
+			staged,
+			all
+		}
+	}));
+	if (!isTTY && !staged && !all) return fail(new MissingOptionsError({
+		message: "The staged or all option is required in a non-interactive terminal context.",
+		options: {
+			staged,
+			all
+		}
+	}));
+	if (staged) return succeed("staged");
+	if (all) return succeed("all");
+	return succeed("ask");
+}
 // src/index.ts
 const result = parse(app, { argv: process.argv.slice(2) });
 if (!result.ok) {
-	log.error(printErrors(result));
+	console.error(printErrors(result));
 	process.exit(1);
 }
 switch (result.method) {
@@ -180,89 +399,117 @@ switch (result.method) {
 		break;
 	case "execute": switch (result.route) {
 		case "/": {
+			intro("Initiating quicksave...");
 			const { cwd, staged, all } = result.model;
 			const isTTY = process.stdin.isTTY;
-			if (staged && all) {
-				log.error("Conflicting options: staged, all");
-				process.exit(1);
-			}
-			if (!isTTY && !staged && !all) {
-				log.error("The staged or all flag is required in non-interactive terminals.");
+			const resolveModeResult = resolveMode({
+				staged,
+				all,
+				isTTY
+			});
+			if (!resolveModeResult.success) {
+				log.error(resolveModeResult.error.message);
+				outro(OPERATION_FAILED_OUTRO);
 				process.exit(1);
 			}
-			loadDotEnvFile({
+			const mode = resolveModeResult.data;
+			nodeLoadEnvFileList({
 				parentDirPath: cwd,
-				envFileName: ENV_FILE_NAME.LOCAL
+				envFileList: [".env.local", ".env"]
 			});
-			loadDotEnvFile({
-				parentDirPath: cwd,
-				envFileName: ENV_FILE_NAME.DEFAULT
+			const parseEnvResult = EnvSchema.safeParse(process.env);
+			if (!parseEnvResult.success) {
+				log.error("Invalid GROQ_API_KEY environment variable:");
+				log.message(prettifyError(parseEnvResult.error));
+				outro("Please fix the above issue to continue.");
+				process.exit(1);
+			}
+			const env = parseEnvResult.data;
+			const handleUnstagedChangesResult = await handleUnstagedChanges({
+				cwd,
+				mode
 			});
-			let treeId = void 0;
-			if (!staged) {
-				if ((await getAllChanges({ cwd })).some((change) => change.status.unstaged !== " ")) {
-					let willStage = true;
-					if (isTTY && !all) {
-						const shouldStage = await confirm({ message: "You have unstaged changes. Do you want to add them all?" });
-						if (isCancel(shouldStage)) {
-							cancel("Operation cancelled.");
-							process.exit(0);
-						}
-						willStage = shouldStage;
-					}
-					if (willStage) {
-						treeId = await snapshotIndex({ cwd });
-						await stageAllChanges({ cwd });
-					}
+			if (!handleUnstagedChangesResult.success) {
+				const handleUnstagedChangesError = handleUnstagedChangesResult.error;
+				if (handleUnstagedChangesError.code === "CLACK_IS_CANCELLED_ERROR") {
+					cancel(handleUnstagedChangesError.message);
+					process.exit(CANCEL_EXIT_CODE);
 				}
+				log.error(handleUnstagedChangesError.message);
+				log.message(isError(handleUnstagedChangesError.cause) ? handleUnstagedChangesError.cause.message : DEFAULT_FAILURE_REASON);
+				outro(OPERATION_FAILED_OUTRO);
+				process.exit(1);
 			}
-			const diff = await getStagedDiff({ cwd });
-			if (diff.length === 0) {
-				log.warn("No staged changes to commit.");
-				if (treeId) {
-					await restoreIndex({
+			const snapshotStatus = handleUnstagedChangesResult.data;
+			if (!snapshotStatus.snapshotted && snapshotStatus.reason === "The repo has no unstaged changes") log.warn(snapshotStatus.reason);
+			log.info("Generating commit message...");
+			const getCommitMessageResult = await getCommitMessage({
+				cwd,
+				env
+			});
+			if (!getCommitMessageResult.success) {
+				const getCommitMessageError = getCommitMessageResult.error;
+				log.error(getCommitMessageError.message);
+				if (getCommitMessageError.code === "UNEXPECTED_ERROR") log.message(isError(getCommitMessageError.cause) ? getCommitMessageError.cause.message : DEFAULT_FAILURE_REASON);
+				if (snapshotStatus.snapshotted) {
+					const restoreIndexResult = await restoreIndex({
 						cwd,
-						treeId
+						treeId: snapshotStatus.treeId
 					});
-					log.info("Unstaged the changes quicksave added.");
+					if (!restoreIndexResult.success) {
+						const restoreIndexError = restoreIndexResult.error;
+						log.error(restoreIndexError.message);
+						log.message(isError(restoreIndexError.cause) ? restoreIndexError.cause.message : DEFAULT_FAILURE_REASON);
+					}
 				}
-				outro("Exit early.");
-				process.exit(0);
+				outro(OPERATION_FAILED_OUTRO);
+				process.exit(1);
 			}
-			log.info("Generating commit message...");
-			const message = await generateCommitMessage({ diff });
 			log.success("Commit message generated:");
+			const { message } = getCommitMessageResult.data;
 			log.message(message);
-			if (isTTY) {
-				const shouldCommit = await confirm({ message: "Do you want to commit with the above message?" });
-				if (isCancel(shouldCommit)) {
-					if (treeId) {
-						await restoreIndex({
-							cwd,
-							treeId
-						});
-						log.info("Unstaged the changes quicksave added.");
+			const handleCommitResult = await handleCommit({
+				isTTY,
+				cwd,
+				message
+			});
+			if (!handleCommitResult.success) {
+				const handleCommitError = handleCommitResult.error;
+				if (handleCommitError.code === "CLACK_IS_CANCELLED_ERROR") cancel(handleCommitError.message);
+				else {
+					log.error(handleCommitError.message);
+					log.message(isError(handleCommitError.cause) ? handleCommitError.cause.message : DEFAULT_FAILURE_REASON);
+				}
+				if (snapshotStatus.snapshotted) {
+					const restoreIndexResult = await restoreIndex({
+						cwd,
+						treeId: snapshotStatus.treeId
+					});
+					if (!restoreIndexResult.success) {
+						const restoreIndexError = restoreIndexResult.error;
+						log.error(restoreIndexError.message);
+						log.message(isError(restoreIndexError.cause) ? restoreIndexError.cause.message : DEFAULT_FAILURE_REASON);
 					}
-					cancel("Operation cancelled.");
-					process.exit(0);
 				}
-				if (!shouldCommit) {
-					if (treeId) {
-						await restoreIndex({
-							cwd,
-							treeId
-						});
-						log.info("Unstaged the changes quicksave added.");
+				if (handleCommitError.code === "CLACK_IS_CANCELLED_ERROR") process.exit(CANCEL_EXIT_CODE);
+				outro(OPERATION_FAILED_OUTRO);
+				process.exit(1);
+			}
+			const { committed } = handleCommitResult.data;
+			if (!committed) {
+				if (snapshotStatus.snapshotted) {
+					const restoreIndexResult = await restoreIndex({
+						cwd,
+						treeId: snapshotStatus.treeId
+					});
+					if (!restoreIndexResult.success) {
+						const restoreIndexError = restoreIndexResult.error;
+						log.error(restoreIndexError.message);
+						log.message(isError(restoreIndexError.cause) ? restoreIndexError.cause.message : DEFAULT_FAILURE_REASON);
 					}
-					outro("Nothing was committed.");
-					process.exit(0);
 				}
 			}
-			await commitStagedChanges({
-				cwd,
-				message
-			});
-			outro("Changes committed.");
+			outro(committed ? "Changes committed." : "Nothing was commited.");
 			process.exit(0);
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lodestar-oss/quicksave",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "MIT",
   "bin": {
     "qs": "./dist/index.mjs",
@@ -15,21 +15,21 @@
     "tag": "latest"
   },
   "dependencies": {
-    "@ai-sdk/groq": "4.0.71",
+    "@ai-sdk/groq": "4.0.72",
     "@bomb.sh/router": "0.8.0",
     "@clack/prompts": "1.8.1",
-    "@little-nebulae/error": "1.4.0",
-    "@little-nebulae/node-env": "0.4.0",
+    "@little-nebulae/clack": "0.4.0",
+    "@little-nebulae/error": "1.4.1",
+    "@little-nebulae/node-env": "0.5.0",
     "@little-nebulae/result": "1.4.0",
-    "@little-nebulae/system-error": "2.1.0",
     "@little-nebulae/zod-schemas": "0.2.0",
-    "ai": "7.0.154",
+    "ai": "7.0.156",
     "tinyexec": "1.3.1",
     "zod": "4.6.7"
   },
   "devDependencies": {
     "@oxc-node/cli": "1.0.1",
-    "@types/node": "26.6.5",
+    "@types/node": "26.6.6",
     "oxfmt": "0.75.0",
     "oxlint": "1.90.0",
     "oxlint-tsgolint": "7.0.2005",
@@ -42,7 +42,7 @@
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
-      "version": "12.15.0",
+      "version": "12.16.1",
       "onFail": "warn"
     }
   },