@snelusha/noto 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import * as p5 from "@clack/prompts";
-import color5 from "picocolors";
+import * as p6 from "@clack/prompts";
+import color6 from "picocolors";
 
 // src/utils/parser.ts
 import arg from "arg";
@@ -47,7 +47,8 @@ var StorageSchema = z2.object({
   llm: z2.object({
     apiKey: z2.string().optional(),
     model: AvailableModelsSchema.optional()
-  }).optional()
+  }).optional(),
+  lastGeneratedMessage: z2.string().optional()
 });
 var StorageManager = class {
   static storagePath = resolve(
@@ -94,19 +95,25 @@ var StorageManager = class {
   }
 };
 
+// src/utils/process.ts
+var exit = async (code) => {
+  await new Promise((resolve2) => setTimeout(resolve2, 1));
+  console.log();
+  process.exit(code);
+};
+
 // src/middleware/auth.ts
-var withAuth = (fn) => {
-  return async (options) => {
+var withAuth = (fn, options = {}) => {
+  return async (opts) => {
     const storage = await StorageManager.get();
-    if (!storage.llm?.apiKey) {
+    if (!storage.llm?.apiKey && !options.silent) {
       p.log.error(
         dedent`${color.red("noto api key is missing.")}
         ${color.dim(`run ${color.cyan("`noto config key`")} to set it up.`)}`
       );
-      console.log();
-      process.exit(1);
+      return await exit(1);
     }
-    return fn(options);
+    return fn(opts);
   };
 };
 
@@ -140,28 +147,27 @@ var commit = async (message) => {
 };
 
 // src/middleware/git.ts
-var withRepository = (fn) => {
-  return async (options) => {
+var withRepository = (fn, options = {}) => {
+  return async (opts) => {
     const isRepo = await isGitRepository();
-    if (!isRepo) {
+    if (!isRepo && !options.silent) {
       p2.log.error(
         dedent2`${color2.red("no git repository found in cwd.")}
         ${color2.dim(`run ${color2.cyan("`git init`")} to initialize a new repository.`)}`
       );
-      console.log();
-      process.exit(1);
+      return await exit(1);
     }
+    opts.isRepo = isRepo;
     const diff = await getStagedDiff();
-    if (!diff) {
+    if (!diff && !options.silent) {
       p2.log.error(
         dedent2`${color2.red("no staged changes found.")}
         ${color2.dim(`run ${color2.cyan("`git add <file>`")} or ${color2.cyan("`git add .`")} to stage changes.`)}`
       );
-      console.log();
-      process.exit(1);
+      return await exit(1);
     }
-    options.diff = diff;
-    return fn(options);
+    opts.diff = diff;
+    return fn(opts);
   };
 };
 
@@ -214,7 +220,7 @@ var getModel = async () => {
 };
 
 // src/ai/index.ts
-var generateCommitMessage = async (diff) => {
+var generateCommitMessage = async (diff, type) => {
   const model2 = await getModel();
   const { object } = await generateObject({
     model: model2,
@@ -236,7 +242,11 @@ var generateCommitMessage = async (diff) => {
         6. Avoid mentioning file names unless a file was renamed or is critical for understanding the changes.
         7. Prioritize clarity and focus on the most impactful changes for the commit.
     
-        You are expected to generate structured outputs that align with the provided guidelines and produce a message optimized for readability and accuracy. Strictly follow all constraints to ensure high-quality results.`
+        You are expected to generate structured outputs that align with the provided guidelines and produce a message optimized for readability and accuracy. Strictly follow all constraints to ensure high-quality results.
+        
+        ${type ? `if a type is provided (e.g., feat, fix), include it in the commit message in the format "type: message"
+          
+          type: ${type}` : ""}`
       },
       {
         role: "user",
@@ -254,6 +264,12 @@ var command = {
   description: "generate commit message",
   usage: "noto [options]",
   options: [
+    {
+      type: Boolean,
+      flag: "--type",
+      alias: "-t",
+      description: "generate commit message based on type"
+    },
     {
       type: Boolean,
       flag: "--copy",
@@ -265,6 +281,12 @@ var command = {
       flag: "--apply",
       alias: "-a",
       description: "commit the generated message directly"
+    },
+    {
+      type: Boolean,
+      flag: "--edit",
+      alias: "-e",
+      description: "edit the generated commit message"
     }
   ],
   execute: withAuth(
@@ -272,9 +294,67 @@ var command = {
       const spin = p3.spinner();
       try {
         const { diff } = options;
+        const isEditMode = options["--edit"];
+        if (options["--type"]) {
+          const type = await p3.select({
+            message: "select the type of commit message",
+            options: [
+              {
+                label: "chore",
+                value: "chore"
+              },
+              {
+                label: "feat",
+                value: "feat"
+              },
+              {
+                label: "fix",
+                value: "fix"
+              },
+              {
+                label: "docs",
+                value: "docs"
+              },
+              {
+                label: "refactor",
+                value: "refactor"
+              },
+              {
+                label: "perf",
+                value: "perf"
+              },
+              {
+                label: "test",
+                value: "test"
+              }
+            ]
+          });
+          if (p3.isCancel(type)) {
+            p3.log.error(color3.red("nothing selected!"));
+            return await exit(1);
+          }
+          options.type = type;
+        }
         spin.start("generating commit message");
-        const message = await generateCommitMessage(diff);
-        spin.stop(color3.green(message));
+        let message = await generateCommitMessage(diff, options.type);
+        spin.stop(isEditMode ? color3.white(message) : color3.green(message));
+        if (isEditMode) {
+          const editedMessage = await p3.text({
+            message: "edit the generated commit message",
+            initialValue: message,
+            placeholder: message
+          });
+          if (p3.isCancel(editedMessage)) {
+            p3.log.error(color3.red("nothing changed!"));
+            return await exit(1);
+          }
+          message = editedMessage;
+          p3.log.step(color3.green(message));
+        }
+        await StorageManager.update((current) => ({
+          ...current,
+          lastGeneratedMessage: message
+        }));
         if (options["--copy"]) {
           clipboard.writeSync(message);
           p3.log.step(color3.dim("copied commit message to clipboard"));
@@ -287,44 +367,135 @@ var command = {
             p3.log.error(color3.red("failed to commit changes"));
           }
         }
+        process.stdout.write("\n");
       } catch {
         spin.stop(color3.red("failed to generate commit message"), 1);
-        process.exit(1);
-      } finally {
-        process.stdout.write("\n");
+        return await exit(1);
       }
     })
   )
 };
 var noto_default = command;
 
-// src/commands/config.ts
+// src/commands/prev.ts
 import * as p4 from "@clack/prompts";
 import color4 from "picocolors";
+import dedent4 from "dedent";
+import clipboard2 from "clipboardy";
+var command2 = {
+  name: "prev",
+  description: "access the last generated commit message",
+  usage: "noto prev [options]",
+  options: [
+    {
+      type: Boolean,
+      flag: "--copy",
+      alias: "-c",
+      description: "copy the last generated commit message to clipboard"
+    },
+    {
+      type: Boolean,
+      flag: "--apply",
+      alias: "-a",
+      description: "commit the last generated message directly"
+    },
+    {
+      type: Boolean,
+      flag: "--edit",
+      alias: "-e",
+      description: "edit the last generated commit message"
+    }
+  ],
+  execute: withAuth(
+    withRepository(
+      async (options) => {
+        let lastGeneratedMessage = (await StorageManager.get()).lastGeneratedMessage;
+        if (!lastGeneratedMessage) {
+          p4.log.error(color4.red("no previous commit message found"));
+          return await exit(1);
+        }
+        const isEditMode = options["--edit"];
+        p4.log.step(
+          isEditMode ? color4.white(lastGeneratedMessage) : color4.green(lastGeneratedMessage)
+        );
+        if (options["--edit"]) {
+          const editedMessage = await p4.text({
+            message: "edit the last generated commit message",
+            initialValue: lastGeneratedMessage,
+            placeholder: lastGeneratedMessage
+          });
+          if (p4.isCancel(editedMessage)) {
+            p4.log.error(color4.red("nothing changed!"));
+            return await exit(1);
+          }
+          lastGeneratedMessage = editedMessage;
+          await StorageManager.update((current) => ({
+            ...current,
+            lastGeneratedMessage: editedMessage
+          }));
+          p4.log.step(color4.green(lastGeneratedMessage));
+        }
+        if (options["--copy"]) {
+          clipboard2.writeSync(lastGeneratedMessage);
+          p4.log.step(
+            color4.dim("copied last generated commit message to clipboard")
+          );
+        }
+        if (options["--apply"]) {
+          if (!options.isRepo) {
+            p4.log.error(
+              dedent4`${color4.red("no git repository found in cwd.")}
+              ${color4.dim(`run ${color4.cyan("`git init`")} to initialize a new repository.`)}`
+            );
+            return await exit(1);
+          }
+          if (!options.diff) {
+            p4.log.error(
+              dedent4`${color4.red("no staged changes found.")}
+              ${color4.dim(`run ${color4.cyan("`git add <file>`")} or ${color4.cyan("`git add .`")} to stage changes.`)}`
+            );
+            return await exit(1);
+          }
+          const success = await commit(lastGeneratedMessage);
+          if (success) {
+            p4.log.step(color4.dim("commit successful"));
+          } else {
+            p4.log.error(color4.red("failed to commit changes"));
+          }
+        }
+        console.log();
+      },
+      { silent: true }
+    )
+  )
+};
+var prev_default = command2;
+
+// src/commands/config.ts
+import * as p5 from "@clack/prompts";
+import color5 from "picocolors";
 var key = {
   name: "key",
   description: "configure api key",
   usage: "noto config key [options]",
   execute: async (options) => {
     if ((await StorageManager.get()).llm?.apiKey) {
-      const confirm2 = await p4.confirm({
+      const confirm2 = await p5.confirm({
         message: "noto api key already configured, do you want to update it?"
       });
-      if (p4.isCancel(confirm2) || !confirm2) {
-        p4.log.error(color4.red("nothing changed!"));
-        console.log();
-        process.exit(1);
+      if (p5.isCancel(confirm2) || !confirm2) {
+        p5.log.error(color5.red("nothing changed!"));
+        return await exit(1);
       }
     }
     let apiKey = options._[0];
     if (!apiKey) {
-      const result = await p4.text({
+      const result = await p5.text({
         message: "enter your noto api key"
       });
-      if (p4.isCancel(result)) {
-        p4.log.error(color4.red("nothing changed!"));
-        console.log();
-        process.exit(1);
+      if (p5.isCancel(result)) {
+        p5.log.error(color5.red("nothing changed!"));
+        return await exit(1);
       }
       apiKey = result;
     }
@@ -335,7 +506,7 @@ var key = {
         apiKey
       }
     }));
-    p4.log.success(color4.green("noto api key configured!"));
+    p5.log.success(color5.green("noto api key configured!"));
     console.log();
   }
 };
@@ -344,7 +515,7 @@ var model = {
   description: "configure model",
   usage: "noto config model [options]",
   execute: async (options) => {
-    const model2 = await p4.select({
+    const model2 = await p5.select({
       message: "select a model",
       initialValue: (await StorageManager.get()).llm?.model,
       options: Object.keys(models).map((model3) => ({
@@ -352,10 +523,9 @@ var model = {
         value: model3
       }))
     });
-    if (p4.isCancel(model2)) {
-      p4.log.error(color4.red("nothing changed!"));
-      console.log();
-      process.exit();
+    if (p5.isCancel(model2)) {
+      p5.log.error(color5.red("nothing changed!"));
+      return await exit(1);
     }
     await StorageManager.update((current) => ({
       ...current,
@@ -364,48 +534,46 @@ var model = {
         model: model2
       }
     }));
-    p4.log.success(color4.green("model configured!"));
+    p5.log.success(color5.green("model configured!"));
     console.log();
   }
 };
 var subCommands = [key, model];
-var command2 = {
+var command3 = {
   name: "config",
   description: "configure noto",
   usage: "noto config [subcommand]",
   execute: async (options) => {
-    const command3 = await p4.select({
+    const command4 = await p5.select({
       message: "Select a subcommand",
       options: subCommands.map((cmd2) => ({
         label: cmd2.description,
         value: cmd2.name
       }))
     });
-    if (p4.isCancel(command3)) {
-      console.log();
-      process.exit(1);
+    if (p5.isCancel(command4)) {
+      return await exit(1);
     }
-    const cmd = getCommand(command3, subCommands);
+    const cmd = getCommand(command4, subCommands);
     if (!cmd) {
-      p4.log.error(color4.red("unknown config command"));
-      console.log();
-      process.exit(1);
+      p5.log.error(color5.red("unknown config command"));
+      return await exit(1);
     }
     options._ = options._.slice(1);
     cmd.execute(options);
   },
   subCommands
 };
-var config_default = command2;
+var config_default = command3;
 
 // src/commands/index.ts
-var commands = [noto_default, config_default];
+var commands = [noto_default, prev_default, config_default];
 var getCommand = (name, cmds = commands) => {
   return cmds.find((cmd) => cmd.name === name);
 };
 
 // package.json
-var version = "1.0.0-beta.3";
+var version = "1.0.0-beta.4";
 
 // src/index.ts
 var globalSpec = {
@@ -416,16 +584,16 @@ var globalSpec = {
 };
 function main() {
   const args = process.argv.slice(2);
-  const { command: command3, options: globalOptions } = parse(globalSpec, args);
+  const { command: command4, options: globalOptions } = parse(globalSpec, args);
   console.log();
-  p5.intro(`${color5.bgCyan(color5.black(" @snelusha/noto "))}`);
-  if (globalOptions["--version"]) return p5.outro(version);
-  const cmd = getCommand(command3) ?? getCommand("noto");
+  p6.intro(`${color6.bgCyan(color6.black(" @snelusha/noto "))}`);
+  if (globalOptions["--version"]) return p6.outro(version);
+  const cmd = getCommand(command4) ?? getCommand("noto");
   if (!cmd) return getCommand("noto")?.execute(globalOptions);
   let commandArgs = args;
   let selectedCommand = cmd;
   if (cmd.subCommands && commandArgs.length) {
-    const possibleCommand = commandArgs[0];
+    const possibleCommand = commandArgs[1];
     const subCommand = cmd.subCommands.find(
       (cmd2) => cmd2.name === possibleCommand || cmd2.aliases && cmd2.aliases.includes(possibleCommand)
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snelusha/noto",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
   "description": "Generate clean commit messages in a snap! ✨",
   "license": "MIT",
   "type": "module",