@snelusha/noto 1.2.9 → 1.3.0-beta.1

package/dist/index.js

@@ -1,50 +1,95 @@
 // src/index.ts
-import * as p8 from "@clack/prompts";
-import color9 from "picocolors";
-
-// src/utils/parser.ts
-import arg from "arg";
-var parse = (schema, raw) => {
-  const args = arg(schema, { argv: raw, permissive: true });
-  return {
-    command: args._[0],
-    options: args
-  };
-};
-var safeParse = (schema, raw) => {
-  let current = { ...schema };
-  let iterations = 0;
-  const maxIterations = Object.keys(current).filter((key) => current[key] === String).length;
-  while (iterations++ < maxIterations) {
-    try {
-      return parse(current, raw);
-    } catch (error) {
-      if (error.code === "ARG_MISSING_REQUIRED_LONGARG") {
-        const match = error.message.match(/(--\w[\w-]*)/);
-        if (match) {
-          const missingFlag = match[0];
-          if (current[missingFlag] === String) {
-            current[missingFlag] = Boolean;
-            continue;
-          }
-        }
-      }
-      throw error;
-    }
-  }
-  return parse(current, raw);
-};
-
-// src/commands/noto.ts
-import * as p3 from "@clack/prompts";
-import color3 from "picocolors";
-import clipboard from "clipboardy";
+import { createCli } from "trpc-cli";
+// package.json
+var version = "1.3.0-beta.1";
 
-// src/middleware/auth.ts
+// src/trpc.ts
+import fs3 from "node:fs/promises";
+import { initTRPC } from "@trpc/server";
 import * as p from "@clack/prompts";
 import color from "picocolors";
 import dedent from "dedent";
 
+// src/utils/git.ts
+import simpleGit from "simple-git";
+var git = simpleGit();
+var isGitRepository = async () => {
+  return git.checkIsRepo();
+};
+var getGitRoot = async () => {
+  try {
+    return await git.revparse(["--show-toplevel"]);
+  } catch {
+    return null;
+  }
+};
+var getCommits = async (limit = 10) => {
+  try {
+    const log = await git.log({ maxCount: limit });
+    return log.all.map((c) => c.message);
+  } catch {
+    return null;
+  }
+};
+var getStagedDiff = async () => {
+  try {
+    return git.diff(["--cached", "--", ":!*.lock"]);
+  } catch {
+    return null;
+  }
+};
+var commit = async (message, amend) => {
+  try {
+    const options = amend ? { "--amend": null } : undefined;
+    const {
+      summary: { changes }
+    } = await git.commit(message, undefined, options);
+    return Boolean(changes);
+  } catch {
+    return false;
+  }
+};
+var push = async () => {
+  try {
+    const result = await git.push();
+    return result.update || result.pushed && result.pushed.length > 0;
+  } catch {
+    return false;
+  }
+};
+var getCurrentBranch = async () => {
+  try {
+    const branch = await git.branch();
+    return branch.current;
+  } catch {
+    return null;
+  }
+};
+var getBranches = async (remote) => {
+  try {
+    const branches = await git.branch();
+    return remote ? branches.all : Object.keys(branches.branches).filter((b) => !b.startsWith("remotes/"));
+  } catch {
+    return null;
+  }
+};
+var checkout = async (branch) => {
+  try {
+    await git.checkout(branch, {});
+    return true;
+  } catch {
+    return false;
+  }
+};
+var checkoutLocalBranch = async (branch) => {
+  try {
+    await git.checkoutLocalBranch(branch);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
 // src/utils/storage.ts
 import os from "os";
 import { dirname, join, resolve } from "path";
@@ -73,11 +118,12 @@ var StorageSchema = z2.object({
     apiKey: z2.string().optional(),
     model: AvailableModelsSchema.optional().or(z2.string())
   }).optional(),
-  lastGeneratedMessage: z2.string().optional()
+  lastGeneratedMessage: z2.string().optional(),
+  cache: z2.record(z2.string(), z2.string()).optional()
 });
 
 class StorageManager {
-  static storagePath = resolve(join(os.homedir(), ".noto"), "storage.sithi");
+  static storagePath = resolve(join(os.homedir(), ".config", "noto"), ".notorc");
   static storage = {};
   static async load() {
     try {
@@ -123,6 +169,38 @@ class StorageManager {
   }
 }
 
+// src/utils/fs.ts
+import fs2 from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+async function findUp(name, options = {}) {
+  let directory = path.resolve(toPath(options.cwd ?? ""));
+  const { root } = path.parse(directory);
+  options.stopAt = path.resolve(toPath(options.stopAt ?? root));
+  const isAbsoluteName = path.isAbsolute(name);
+  while (directory) {
+    const filePath = isAbsoluteName ? name : path.join(directory, name);
+    try {
+      const stats = await fs2.stat(filePath);
+      if (options.type === undefined || options.type === "file" && stats.isFile() || options.type === "directory" && stats.isDirectory())
+        return filePath;
+    } catch {}
+    if (directory === options.stopAt || directory === root)
+      break;
+    directory = path.dirname(directory);
+  }
+}
+
+// src/utils/prompt.ts
+var getPromptFile = async () => {
+  const root = await getGitRoot();
+  return await findUp(".noto/commit-prompt.md", {
+    stopAt: root || process.cwd(),
+    type: "file"
+  });
+};
+
 // src/utils/process.ts
 var exit = async (code) => {
   await new Promise((resolve2) => setTimeout(resolve2, 1));
@@ -130,149 +208,230 @@ var exit = async (code) => {
   process.exit(code);
 };
 
-// src/middleware/auth.ts
-var withAuth = (fn, options = { enabled: true }) => {
-  return async (opts) => {
-    const storage = await StorageManager.get();
-    const apiKey = process.env.NOTO_API_KEY || storage.llm?.apiKey;
-    if (!apiKey && options.enabled) {
-      p.log.error(dedent`${color.red("noto api key is missing.")}
+// src/trpc.ts
+var t = initTRPC.meta().create({
+  defaultMeta: {
+    intro: true,
+    authRequired: true,
+    repoRequired: true,
+    diffRequired: false,
+    promptRequired: false
+  }
+});
+var authMiddleware = t.middleware(async (opts) => {
+  const { meta, next } = opts;
+  const storage = await StorageManager.get();
+  const apiKey = process.env.NOTO_API_KEY || storage.llm?.apiKey;
+  if (meta?.authRequired && !apiKey) {
+    p.log.error(dedent`${color.red("noto api key is missing.")}
         ${color.dim(`run ${color.cyan("`noto config key`")} to set it up.`)}`);
-      return await exit(1);
+    return await exit(1);
+  }
+  return next();
+});
+var gitMiddleware = t.middleware(async (opts) => {
+  const { meta, next } = opts;
+  const isRepository = await isGitRepository();
+  if (meta?.repoRequired && !isRepository) {
+    p.log.error(dedent`${color.red("no git repository found in cwd.")}
+          ${color.dim(`run ${color.cyan("`git init`")} to initialize a new repository.`)}`);
+    return await exit(1);
+  }
+  const diff = isRepository && await getStagedDiff();
+  if (meta?.diffRequired && !diff) {
+    p.log.error(dedent`${color.red("no staged changes found.")}
+          ${color.dim(`run ${color.cyan("`git add <file>`")} or ${color.cyan("`git add .`")} to stage changes.`)}`);
+    return await exit(1);
+  }
+  let prompt = null;
+  if (meta?.promptRequired) {
+    const promptPath = await getPromptFile();
+    if (promptPath) {
+      try {
+        prompt = await fs3.readFile(promptPath, "utf-8");
+      } catch {}
     }
-    return fn(opts);
-  };
-};
+  }
+  return next({
+    ctx: {
+      noto: {
+        prompt
+      },
+      git: {
+        isRepository,
+        diff
+      }
+    }
+  });
+});
+var baseProcedure = t.procedure.use((opts) => {
+  const { meta, next } = opts;
+  if (meta?.intro) {
+    console.log();
+    p.intro(`${color.bgCyan(color.black(" @snelusha/noto "))}`);
+  }
+  return next();
+});
+var authProcedure = baseProcedure.use(authMiddleware);
+var gitProcedure = baseProcedure.use(gitMiddleware);
+var authedGitProcedure = baseProcedure.use(authMiddleware).use(gitMiddleware);
 
-// src/middleware/git.ts
+// src/commands/checkout.ts
+import { z as z3 } from "zod";
 import * as p2 from "@clack/prompts";
 import color2 from "picocolors";
-import dedent2 from "dedent";
-
-// src/utils/git.ts
-import simpleGit from "simple-git";
-var INIT_COMMIT_MESSAGE = "chore: init repo";
-var git = simpleGit();
-var isGitRepository = async () => {
-  return git.checkIsRepo();
-};
-var getCommitCount = async () => {
-  try {
-    const count = await git.raw(["rev-list", "--all", "--count"]);
-    return parseInt(count);
-  } catch (error) {
-    const message = error.message;
-    const regex = /(ambiguous argument.*HEAD|unknown revision or path.*HEAD)/;
-    if (regex.test(message))
-      return 0;
-    throw error;
+import clipboard from "clipboardy";
+var checkout2 = gitProcedure.meta({
+  description: "checkout a branch"
+}).input(z3.object({
+  copy: z3.boolean().meta({
+    description: "copy the selected branch to clipboard",
+    alias: "c"
+  }),
+  create: z3.union([z3.boolean(), z3.string()]).optional().meta({ description: "create a new branch", alias: "b" }),
+  branch: z3.string().optional().meta({ positional: true })
+})).mutation(async (opts) => {
+  const { input } = opts;
+  const branches = await getBranches();
+  if (!branches) {
+    p2.log.error("failed to fetch branches");
+    return await exit(1);
   }
-};
-var isFirstCommit = async () => {
-  const count = await getCommitCount();
-  return count === 0;
-};
-var getStagedDiff = async () => {
-  try {
-    return git.diff(["--cached", "--", ":!*.lock"]);
-  } catch {
-    return null;
+  const currentBranch = await getCurrentBranch();
+  const targetBranch = typeof input.create === "string" ? input.create : input.branch;
+  const createFlag = input.create === true || typeof input.create === "string";
+  if (createFlag && targetBranch) {
+    if (branches.includes(targetBranch)) {
+      p2.log.error(`branch ${color2.red(targetBranch)} already exists in the repository`);
+      return await exit(1);
+    }
+    const result2 = await checkoutLocalBranch(targetBranch);
+    if (!result2) {
+      p2.log.error(`failed to create and checkout ${color2.bold(targetBranch)}`);
+      return await exit(1);
+    }
+    p2.log.success(`created and checked out ${color2.green(targetBranch)}`);
+    return await exit(0);
   }
-};
-var commit = async (message, amend) => {
-  try {
-    const options = amend ? { "--amend": null } : undefined;
-    const {
-      summary: { changes }
-    } = await git.commit(message, undefined, options);
-    return Boolean(changes);
-  } catch {
-    return false;
+  if (targetBranch) {
+    if (!branches.includes(targetBranch)) {
+      p2.log.error(`branch ${color2.red(targetBranch)} does not exist in the repository`);
+      const createBranch = await p2.confirm({
+        message: `do you want to create branch ${color2.green(targetBranch)}?`
+      });
+      if (p2.isCancel(createBranch)) {
+        p2.log.error("aborted");
+        return await exit(1);
+      }
+      if (createBranch) {
+        const result3 = await checkoutLocalBranch(targetBranch);
+        if (!result3) {
+          p2.log.error(`failed to create and checkout ${color2.bold(targetBranch)}`);
+          return await exit(1);
+        }
+        p2.log.success(`created and checked out ${color2.green(targetBranch)}`);
+        return await exit(0);
+      }
+      return await exit(1);
+    }
+    if (targetBranch === currentBranch) {
+      p2.log.error(`${color2.red("already on branch")} ${color2.green(targetBranch)}`);
+      return await exit(1);
+    }
+    const result2 = await checkout(targetBranch);
+    if (!result2) {
+      p2.log.error(`failed to checkout ${color2.bold(targetBranch)}`);
+      return await exit(1);
+    }
+    p2.log.success(`checked out ${color2.green(targetBranch)}`);
+    return await exit(0);
   }
-};
-var push = async () => {
-  try {
-    const result = await git.push();
-    return result.update || result.pushed && result.pushed.length > 0;
-  } catch {
-    return false;
+  if (branches.length === 0) {
+    p2.log.error("no branches found in the repository");
+    return await exit(1);
   }
-};
-var getCurrentBranch = async () => {
-  try {
-    const branch = await git.branch();
-    return branch.current;
-  } catch {
-    return null;
+  const branch = await p2.select({
+    message: "select a branch to checkout",
+    options: branches.map((branch2) => ({
+      value: branch2,
+      label: color2.bold(branch2 === currentBranch ? color2.green(branch2) : branch2),
+      hint: branch2 === currentBranch ? "current branch" : undefined
+    })),
+    initialValue: currentBranch
+  });
+  if (p2.isCancel(branch)) {
+    p2.log.error("nothing selected!");
+    return await exit(1);
   }
-};
-var getBranches = async (remote) => {
-  try {
-    const branches = await git.branch();
-    return remote ? branches.all : Object.keys(branches.branches).filter((b) => !b.startsWith("remotes/"));
-  } catch {
-    return null;
+  if (!branch) {
+    p2.log.error("no branch selected");
+    return await exit(1);
   }
-};
-var checkout = async (branch) => {
-  try {
-    await git.checkout(branch, {});
-    return true;
-  } catch {
-    return false;
+  if (input.copy) {
+    clipboard.writeSync(branch);
+    p2.log.success(`copied ${color2.green(branch)} to clipboard`);
+    return await exit(0);
   }
-};
-var checkoutLocalBranch = async (branch) => {
-  try {
-    await git.checkoutLocalBranch(branch);
-    return true;
-  } catch {
-    return false;
+  if (branch === currentBranch) {
+    p2.log.error(`${color2.red("already on branch")}`);
+    return await exit(1);
   }
-};
-var deleteBranches = async (branches, force = false) => {
-  try {
-    const result = await git.deleteLocalBranches(branches, force);
-    return result.success;
-  } catch {
-    return false;
+  const result = await checkout(branch);
+  if (!result) {
+    p2.log.error(`failed to checkout ${color2.bold(branch)}`);
+    return await exit(1);
   }
-};
+  p2.log.success(`checked out ${color2.green(branch)}`);
+  await exit(0);
+});
 
-// src/middleware/git.ts
-var withRepository = (fn, options = { enabled: true }) => {
-  return async (opts) => {
-    const isRepo = await isGitRepository();
-    if (!isRepo && options.enabled) {
-      p2.log.error(dedent2`${color2.red("no git repository found in cwd.")}
-          ${color2.dim(`run ${color2.cyan("`git init`")} to initialize a new repository.`)}`);
+// src/commands/config/key.ts
+import { z as z4 } from "zod";
+import * as p3 from "@clack/prompts";
+import color3 from "picocolors";
+var key = baseProcedure.meta({ description: "configure noto api key" }).input(z4.string().optional().describe("apiKey")).mutation(async (opts) => {
+  const { input } = opts;
+  let apiKey = input;
+  if ((await StorageManager.get()).llm?.apiKey) {
+    const confirm3 = await p3.confirm({
+      message: "noto api key already configured, do you want to update it?"
+    });
+    if (p3.isCancel(confirm3) || !confirm3) {
+      p3.log.error(color3.red("nothing changed!"));
       return await exit(1);
     }
-    opts.isRepo = isRepo;
-    if (isRepo) {
-      const diff = await getStagedDiff();
-      if (!diff && options.enabled) {
-        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.`)}`);
-        return await exit(1);
-      }
-      opts.diff = diff;
+  }
+  if (!apiKey) {
+    const result = await p3.text({
+      message: "enter your noto api key"
+    });
+    if (p3.isCancel(result)) {
+      p3.log.error(color3.red("nothing changed!"));
+      return await exit(1);
     }
-    return fn(opts);
-  };
-};
+    apiKey = result;
+  }
+  await StorageManager.update((current) => ({
+    ...current,
+    llm: {
+      ...current.llm,
+      apiKey
+    }
+  }));
+  p3.log.success(color3.green("noto api key configured!"));
+  await exit(0);
+});
 
-// src/ai/index.ts
-import { generateObject } from "ai";
-import z3 from "zod";
-import dedent3 from "dedent";
+// src/commands/config/model.ts
+import * as p4 from "@clack/prompts";
+import color4 from "picocolors";
 
 // src/ai/models.ts
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 var google = createGoogleGenerativeAI({
   apiKey: (await StorageManager.get()).llm?.apiKey ?? "api-key"
 });
-var defaultModel = "gemini-2.0-flash";
+var DEFAULT_MODEL = "gemini-2.0-flash";
 var models = {
   "gemini-1.5-flash": google("gemini-1.5-flash"),
   "gemini-1.5-flash-latest": google("gemini-1.5-flash-latest"),
@@ -290,839 +449,792 @@ var availableModels = Object.keys(models);
 var getModel = async () => {
   let model = (await StorageManager.get()).llm?.model;
   if (!model || !availableModels.includes(model)) {
-    model = defaultModel;
+    model = DEFAULT_MODEL;
     await StorageManager.update((current) => ({
       ...current,
       llm: {
         ...current.llm,
-        model: defaultModel
+        model: DEFAULT_MODEL
       }
     }));
   }
   return models[model];
 };
 
-// src/ai/index.ts
-var generateCommitMessage = async (diff, type, context) => {
-  const model = await getModel();
-  const { object } = await generateObject({
-    model,
-    schema: z3.object({
-      message: z3.string()
-    }),
-    messages: [
-      {
-        role: "system",
-        content: dedent3`
-        ## Persona
-        You are a highly specialized AI assistant engineered for generating precise, standards-compliant Git commit messages. Your function is to serve as an automated tool ensuring consistency and clarity in version control history, adhering strictly to predefined formatting rules optimized for software development workflows.
-
-        ## Core Objective
-        Your objective is to meticulously analyze provided code changes (diffs) and synthesize a Git commit message that strictly conforms to the specified output requirements. The focus is on accuracy, conciseness, and unwavering adherence to the format.
-
-        ## Input Specification
-        The input provided by the user will be structured as follows:
-
-        1.  **Optional Type Override:** A line indicating the desired commit type, formatted as:
-            \`USER_SPECIFIED_TYPE: <value>\`
-            *   The \`<value>\` will either be one of the valid types (\`chore\`, \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`perf\`, \`test\) or the special keyword \`[none]\` if the user does not wish to force a specific type.
-        2.  **Optional User Context:** A section providing supplementary information about the changes, formatted as:
-            \`USER_PROVIDED_CONTEXT:\`
-            \`{context_placeholder or [none]}\`
-            *   This context (e.g., issue details, goal description) is optional. If provided, use it to better understand the *purpose* and *intent* behind the code changes. If not provided, the value will be \`[none]\`.
-        3.  **Diff Content:** The raw diff output, typically generated by \`git diff --staged\`, encapsulated within triple backticks.
-
-        **You must parse the \`USER_SPECIFIED_TYPE:\` and \`USER_PROVIDED_CONTEXT:\` inputs before analyzing the diff.**
-          
-        ## Output Specification & Constraints (Mandatory Adherence)
-        Adherence to the following specifications is mandatory and non-negotiable. Any deviation constitutes an incorrect output.
-
-        1.  **Commit Message Format:**
-            *   The output MUST strictly follow the single-line format: \`<type>: <description>\`
-            *   A single colon (\`:\`) followed by a single space MUST separate the \`<type>\` and \`<description>\`.
-            *   Scopes within the type (e.g., \`feat(api):\`) are explicitly disallowed.
-            *   Message bodies and footers are explicitly disallowed. The output MUST be exactly one line.
-
-        2.  **Type (\`<type>\`) - Determination Logic:**
-            *   **Priority 1: User-Specified Type:** Check the value provided on the \`USER_SPECIFIED_TYPE:\` line. If this value is exactly one of \`chore\`, \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`perf\`, \`test\`, then you **MUST** use this user-specified type.
-            *   **Priority 2: Diff & Context Analysis (Default Behavior):** If the value on the \`USER_SPECIFIED_TYPE:\` line is \`[none]\` or invalid, you **MUST** select the \`<type>\` exclusively from the predefined vocabulary (\`chore\`, \`feat\`, \`fix\`, \`docs\`, \`refactor\`, \`perf\`, \`test\`). Base your selection on your analysis of the diff, **informed by the \`USER_PROVIDED_CONTEXT\`** if available, to accurately reflect the primary semantic purpose of the changes.
-
-        3.  **Description (\`<description>\`):**
-            *   **Tense:** MUST employ the imperative, present tense (e.g.,\`add\`, \`fix\`, \`update\`, \`implement\`, \`refactor\`, \`remove\`).
-            *   **Content:** Must succinctly convey the core semantic change introduced by the diff.
-                *   **Leverage Context:** If \`USER_PROVIDED_CONTEXT\` is available and not \`[none]\`, use it to **refine the description**, ensuring it reflects the *intent* and *purpose* behind the changes, while still accurately summarizing *what* was changed in the diff.
-                *   **Focus:** Prioritize the most significant aspects of the change.
-            *   **File Name Reference:** Inclusion of file names should be exceptional, reserved only for renaming operations or when essential for disambiguating the change's primary focus.
-            *   **Case Sensitivity:** The entire output string, encompassing both \`<type>\` and \`<description>\`, MUST be rendered in lowercase.
-            *   **Punctuation:** The description MUST NOT conclude with any terminal punctuation (e.g., no period/full stop).
-            *   **Length Constraint:** The total character count of the generated commit message line MUST NOT exceed 72 characters. **The description must be concise enough to fit within this limit alongside the chosen type.**`
-      },
-      {
-        role: "user",
-        content: dedent3`
-        \`\`\`text
-        USER_SPECIFIED_TYPE: ${type ?? "[none]"}
-
-        USER_PROVIDED_CONTEXT:
-        ${context ?? "[none]"}
-        \`\`\`
+// src/commands/config/model.ts
+var model = baseProcedure.meta({
+  description: "configure model"
+}).mutation(async () => {
+  const model2 = await p4.select({
+    message: "select a model",
+    initialValue: (await StorageManager.get()).llm?.model,
+    options: Object.keys(models).map((model3) => ({
+      label: model3,
+      value: model3
+    }))
+  });
+  if (p4.isCancel(model2)) {
+    p4.log.error(color4.red("nothing changed!"));
+    return await exit(1);
+  }
+  if (model2 === "gemini-2.5-pro-preview-05-06") {
+    const confirm4 = await p4.confirm({
+      message: "this model does not have free quota tier, do you want to continue?"
+    });
+    if (p4.isCancel(confirm4) || !confirm4) {
+      p4.log.error(color4.red("nothing changed!"));
+      return await exit(1);
+    }
+  }
+  await StorageManager.update((current) => ({
+    ...current,
+    llm: {
+      ...current.llm,
+      model: model2
+    }
+  }));
+  p4.log.success(color4.green("model configured!"));
+  await exit(0);
+});
 
-        \`\`\`diff
-        ${diff}
-        \`\`\``
-      }
-    ]
+// src/commands/config/reset.ts
+import * as p5 from "@clack/prompts";
+import color5 from "picocolors";
+var reset = baseProcedure.meta({
+  description: "reset the configuration"
+}).mutation(async () => {
+  const confirm5 = await p5.confirm({
+    message: "are you sure you want to reset the configuration?"
   });
-  return object.message.trim();
-};
+  if (p5.isCancel(confirm5) || !confirm5) {
+    p5.log.error(color5.red("nothing changed!"));
+    return await exit(1);
+  }
+  await StorageManager.clear();
+  p5.log.success(color5.green("configuration reset!"));
+  await exit(0);
+});
 
-// src/commands/noto.ts
-var availableTypes = [
-  "chore",
-  "feat",
-  "fix",
-  "docs",
-  "refactor",
-  "perf",
-  "test"
-];
-var commitTypeOptions = availableTypes.map((type) => ({
-  label: type,
-  value: type
-}));
-var command = {
-  name: "noto",
-  description: "generate commit message",
-  usage: "noto [options]",
-  options: [
-    {
-      type: String,
-      flag: "--type",
-      alias: "-t",
-      description: "generate commit message based on type"
-    },
-    {
-      type: String,
-      flag: "--message",
-      alias: "-m",
-      description: "provide context for the commit message"
-    },
-    {
-      type: Boolean,
-      flag: "--copy",
-      alias: "-c",
-      description: "copy the generated commit message to clipboard"
-    },
-    {
-      type: Boolean,
-      flag: "--apply",
-      alias: "-a",
-      description: "commit the generated message directly"
-    },
-    {
-      type: Boolean,
-      flag: "--push",
-      alias: "-p",
-      description: "commit and push the changes"
-    },
-    {
-      type: Boolean,
-      flag: "--manual",
-      description: "commit and push the changes"
-    }
-  ],
-  execute: withAuth(withRepository(async (options) => {
-    const spin = p3.spinner();
-    try {
-      const { diff } = options;
-      const manual = options["--manual"];
-      if (manual) {
-        const message2 = await p3.text({
-          message: "edit the generated commit message",
-          placeholder: "chore: init repo"
-        });
-        if (p3.isCancel(message2)) {
-          p3.log.error(color3.red("nothing changed!"));
-          return await exit(1);
-        }
-        p3.log.step(color3.green(message2));
-        await StorageManager.update((current) => ({
-          ...current,
-          lastGeneratedMessage: message2
-        }));
-        if (options["--apply"]) {
-          const success = await commit(message2);
-          if (success) {
-            p3.log.step(color3.dim("commit successful"));
-          } else {
-            p3.log.error(color3.red("failed to commit changes"));
-          }
-        }
-        return await exit(0);
-      }
-      const type = options["--type"];
-      if (typeof type === "string" && !availableTypes.includes(type) || typeof type === "boolean") {
-        const type2 = await p3.select({
-          message: "select the type of commit message",
-          options: commitTypeOptions
-        });
-        if (p3.isCancel(type2)) {
-          p3.log.error(color3.red("nothing selected!"));
-          return await exit(1);
-        }
-        options.type = type2;
-      } else if (typeof type === "string") {
-        options.type = type;
-      }
-      const context = options["--message"];
-      if (typeof context === "string") {
-        options.context = context;
-      } else if (typeof context === "boolean") {
-        const context2 = await p3.text({
-          message: "provide context for the commit message",
-          placeholder: "describe the changes"
-        });
-        if (p3.isCancel(context2)) {
-          p3.log.error(color3.red("nothing changed!"));
-          return await exit(1);
-        }
-        options.context = context2;
-      }
-      spin.start("generating commit message");
-      let message = null;
-      if (!await isFirstCommit()) {
-        message = await generateCommitMessage(diff, options.type, options.context);
-      } else {
-        message = INIT_COMMIT_MESSAGE;
-      }
-      spin.stop(color3.white(message));
-      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"));
-      }
-      if (options["--apply"]) {
-        const success = await commit(message);
-        if (success) {
-          p3.log.step(color3.dim("commit successful"));
-        } else {
-          p3.log.error(color3.red("failed to commit changes"));
-        }
-      }
-      if (options["--push"]) {
-        const success = await push();
-        if (success) {
-          p3.log.step(color3.dim("push successful"));
-        } else {
-          p3.log.error(color3.red("failed to push changes"));
-        }
-      }
-      return await exit(0);
-    } catch {
-      spin.stop(color3.red("failed to generate commit message"), 1);
-      return await exit(1);
-    }
-  }))
-};
-var noto_default = command;
+// src/commands/config/index.ts
+var config = t.router({
+  key,
+  model,
+  reset
+});
 
 // src/commands/prev.ts
-import * as p4 from "@clack/prompts";
-import color4 from "picocolors";
-import dedent4 from "dedent";
+import { z as z5 } from "zod";
+import * as p6 from "@clack/prompts";
+import color6 from "picocolors";
+import dedent2 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"
-    },
-    {
-      type: Boolean,
-      flag: "--amend",
-      description: "amend the last commit with the last generated 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"];
-    const isAmend = options["--amend"];
-    if (isAmend && !isEditMode) {
-      p4.log.error(color4.red("the --amend option requires the --edit option"));
-      return await exit(1);
-    }
-    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"] || isAmend) {
-      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 && !isAmend) {
-        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, isAmend);
-      if (success) {
-        p4.log.step(color4.dim("commit successful"));
-      } else {
-        p4.log.error(color4.red("failed to commit changes"));
-      }
-    }
-    return await exit(0);
-  }, { enabled: false }))
-};
-var prev_default = command2;
-
-// src/commands/branch.ts
-import * as p5 from "@clack/prompts";
-import color5 from "picocolors";
-import clipboard3 from "clipboardy";
-import dedent5 from "dedent";
-var current = {
-  name: "current",
-  description: "get current branch",
-  usage: "branch current",
-  options: [
-    {
-      type: Boolean,
-      flag: "--copy",
-      alias: "-c",
-      description: "copy the selected branch to clipboard"
-    }
-  ],
-  execute: withRepository(async (options) => {
-    if (!options.isRepo) {
-      p5.log.error(dedent5`${color5.red("no git repository found in cwd.")}
-            ${color5.dim(`run ${color5.cyan("`git init`")} to initialize a new repository.`)}`);
-      return await exit(1);
-    }
-    const branch = await getCurrentBranch();
-    if (!branch) {
-      p5.log.error("failed to fetch current branch");
-      return await exit(1);
-    }
-    p5.log.success(`current branch: ${color5.bold(branch)}`);
-    if (options["--copy"]) {
-      clipboard3.writeSync(branch);
-      p5.log.success(`${color5.green("copied to clipboard!")}`);
-    }
-    await exit(0);
-  }, { enabled: false })
-};
-var del = {
-  name: "delete",
-  description: "delete a branch",
-  usage: "branch delete <branch>",
-  options: [
-    {
-      type: Boolean,
-      flag: "--force",
-      alias: "-f",
-      description: "force delete a branch"
-    },
-    {
-      type: Boolean,
-      flag: "--all",
-      alias: "-a",
-      description: "select all branches except the current one"
-    }
-  ],
-  execute: withRepository(async (options) => {
-    if (!options.isRepo) {
-      p5.log.error(dedent5`${color5.red("no git repository found in cwd.")}
-          ${color5.dim(`run ${color5.cyan("`git init`")} to initialize a new repository.`)}`);
-      return await exit(1);
-    }
-    const currentBranch = await getCurrentBranch();
-    const branches = await getBranches();
-    if (!currentBranch || !branches) {
-      p5.log.error("failed to fetch branches");
-      return await exit(1);
-    }
-    const selectedBranches = await p5.multiselect({
-      message: "select branches to delete",
-      initialValues: options["--all"] ? branches.filter((b) => b !== currentBranch) : [],
-      options: branches.map((branch) => ({
-        value: branch,
-        label: color5.bold(branch),
-        hint: branch === options["--current"] ? "current branch" : undefined
-      }))
+var prev = gitProcedure.meta({
+  description: "access the last generated commit",
+  repoRequired: false
+}).input(z5.object({
+  copy: z5.boolean().meta({ description: "copy the last commit to clipboard", alias: "c" }),
+  apply: z5.boolean().meta({ description: "commit the last generated message", alias: "a" }),
+  edit: z5.boolean().meta({
+    description: "edit the last generated commit message",
+    alias: "e"
+  }),
+  amend: z5.boolean().meta({
+    description: "amend the last commit with the last message"
+  })
+})).mutation(async (opts) => {
+  const { input, ctx } = opts;
+  let lastGeneratedMessage = (await StorageManager.get()).lastGeneratedMessage;
+  if (!lastGeneratedMessage) {
+    p6.log.error(color6.red("no previous commit message found"));
+    return await exit(1);
+  }
+  const isEditMode = input.edit;
+  const isAmend = input.amend;
+  if (isAmend && !isEditMode) {
+    p6.log.error(color6.red("the --amend option requires the --edit option"));
+    return await exit(1);
+  }
+  p6.log.step(isEditMode ? color6.white(lastGeneratedMessage) : color6.green(lastGeneratedMessage));
+  if (isEditMode) {
+    const editedMessage = await p6.text({
+      message: "edit the last generated commit message",
+      initialValue: lastGeneratedMessage,
+      placeholder: lastGeneratedMessage
     });
-    if (p5.isCancel(selectedBranches)) {
-      p5.log.error("nothing selected!");
+    if (p6.isCancel(editedMessage)) {
+      p6.log.error(color6.red("nothing changed!"));
       return await exit(1);
     }
-    if (!selectedBranches) {
-      p5.log.error("no branch selected");
-      return await exit(1);
-    }
-    const force = options["--force"];
-    if (currentBranch && selectedBranches.includes(currentBranch)) {
-      p5.log.error("cannot delete current branch");
+    lastGeneratedMessage = editedMessage;
+    await StorageManager.update((current) => ({
+      ...current,
+      lastGeneratedMessage: editedMessage
+    }));
+    p6.log.step(color6.green(lastGeneratedMessage));
+  }
+  if (input.copy) {
+    clipboard2.writeSync(lastGeneratedMessage);
+    p6.log.step(color6.dim("copied last generated commit message to clipboard"));
+  }
+  if (input.apply || isAmend) {
+    if (!ctx.git.isRepository) {
+      p6.log.error(dedent2`${color6.red("no git repository found in cwd.")}
+              ${color6.dim(`run ${color6.cyan("`git init`")} to initialize a new repository.`)}`);
       return await exit(1);
     }
-    const deletedBranches = await deleteBranches(selectedBranches, force);
-    if (!deletedBranches) {
-      p5.log.error("failed to delete branches");
+    if (!ctx.git.diff && !isAmend) {
+      p6.log.error(dedent2`${color6.red("no staged changes found.")}
+              ${color6.dim(`run ${color6.cyan("`git add <file>`")} or ${color6.cyan("`git add .`")} to stage changes.`)}`);
       return await exit(1);
     }
-    p5.log.success("branches deleted successfully");
-    await exit(0);
-  }, { enabled: false })
-};
-var command3 = {
-  name: "branch",
-  description: "list branches",
-  usage: "branch [options]",
-  options: [
-    {
-      type: Boolean,
-      flag: "--remote",
-      alias: "-r",
-      description: "list branches including remotes"
-    },
-    {
-      type: Boolean,
-      flag: "--delete",
-      alias: "-d",
-      description: "delete a branch"
-    },
-    {
-      type: Boolean,
-      flag: "--force",
-      alias: "-f",
-      description: "force delete a branch"
-    },
-    {
-      type: Boolean,
-      flag: "--all",
-      alias: "-a",
-      description: "select all branches except the current one"
-    }
-  ],
-  execute: withRepository(async (options) => {
-    if (!options.isRepo) {
-      p5.log.error(dedent5`${color5.red("no git repository found in cwd.")}
-            ${color5.dim(`run ${color5.cyan("`git init`")} to initialize a new repository.`)}`);
-      return await exit(1);
+    const success = await commit(lastGeneratedMessage, isAmend);
+    if (success) {
+      p6.log.step(color6.dim("commit successful"));
+    } else {
+      p6.log.error(color6.red("failed to commit changes"));
     }
-    if (options["--delete"])
-      return del.execute(options);
-    const remote = options["--remote"];
-    const branches = await getBranches(remote);
-    if (!branches) {
-      p5.log.error("failed to fetch branches");
-      return await exit(1);
+  }
+  return await exit(0);
+});
+
+// src/commands/init.ts
+import fs4 from "node:fs/promises";
+import { z as z7 } from "zod";
+import * as p7 from "@clack/prompts";
+import color7 from "picocolors";
+import dedent4 from "dedent";
+
+// src/ai/index.ts
+import { generateObject, wrapLanguageModel } from "ai";
+import z6 from "zod";
+import dedent3 from "dedent";
+import superjson from "superjson";
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function hashString(content) {
+  const body = Buffer.from(content, "utf-8");
+  const header = Buffer.from(`blob ${body.length}\x00`, "utf-8");
+  return createHash("sha1").update(header).update(body).digest("hex");
+}
+
+// src/ai/index.ts
+var COMMIT_GENERATOR_PROMPT = dedent3`
+# System Instruction for Noto
+
+You are a Git commit message generator for the \`noto\` CLI tool. Your role is to analyze staged code changes and generate clear, single-line commit messages that follow the user's established style.
+
+## Your Purpose
+
+Generate accurate, concise commit messages by analyzing git diffs and following user-provided style guidelines.
+
+## Core Behavior
+
+**Output Format:** Return ONLY a single-line commit message. No explanations, no markdown, no body, no footer.
+
+**Response Style:**
+- Be precise and factual based on the diff
+- Follow the user's custom guidelines exactly
+- Use clear, specific language
+- Stay within 50-72 characters when possible
+
+**Analysis Process:**
+1. Read any user-provided context to understand the intent behind the changes
+2. Examine the git diff to understand what changed technically
+3. Combine user context and diff analysis to get complete understanding
+4. Apply the user's style guidelines from \`.noto/commit-prompt.md\`
+5. Classify the change type (feat, fix, refactor, docs, style, test, chore, etc.)
+6. Generate a commit message that accurately describes both what changed and why
+
+## Input Structure
+
+You will receive:
+\`\`\`
+USER GUIDELINES:
+[Custom style from .noto/commit-prompt.md]
+
+USER CONTEXT (optional):
+[Additional context or description provided by the user about the changes]
+
+GIT DIFF:
+[Staged changes]
+\`\`\`
+
+If user context is provided, use it to better understand the intent and purpose of the changes. Combine this context with your diff analysis to generate a more accurate and meaningful commit message.
+
+## Output Requirements
+
+Return only the commit message text:
+\`\`\`
+type(scope): description
+\`\`\`
+
+Or whatever format matches the user's guidelines. **Must be single-line only.**
+
+## Quality Standards
+
+- Accurately reflect the changes in the diff
+- Incorporate user-provided context when available to capture the "why"
+- Follow user's format, tense, and capitalization preferences
+- Be specific (avoid vague terms like "update" or "change")
+- Use proper grammar
+- Make the git history useful and searchable
+- Balance technical accuracy with user intent
+
+## What NOT to Do
+
+- Don't add explanations or commentary
+- Don't generate multi-line messages
+- Don't make assumptions beyond the visible diff
+- Don't ignore the user's style guidelines
+- Don't use generic or vague descriptions
+
+**Remember:** Your output becomes permanent git history. Generate commit messages that are clear, accurate, and consistent with the user's established patterns.
+`;
+var DEFAULT_COMMIT_GUIDELINES = dedent3`
+# Commit Message Guidelines
+
+## Format
+Use conventional commits: \`type(scope): description\`
+
+The scope is optional but recommended when changes affect a specific component or area.
+
+## Style Rules
+- **Tense**: Imperative present tense (e.g., "add" not "added" or "adds")
+- **Capitalization**: Lowercase for the first letter of description
+- **Length**: Keep the entire message under 72 characters, ideally around 50
+- **Tone**: Clear, concise, and professional
+
+## Commit Types
+- \`feat\`: New feature or functionality for the user
+- \`fix\`: Bug fix that resolves an issue
+- \`docs\`: Documentation changes only
+- \`style\`: Code style changes (formatting, missing semicolons, etc.) with no logic changes
+- \`refactor\`: Code changes that neither fix bugs nor add features
+- \`perf\`: Performance improvements
+- \`test\`: Adding or updating tests
+- \`build\`: Changes to build system or dependencies (npm, webpack, etc.)
+- \`ci\`: Changes to CI/CD configuration files and scripts
+- \`chore\`: Routine tasks, maintenance, or tooling changes
+- \`revert\`: Revert a previous commit
+
+## Scope Usage
+**Prefer omitting scopes whenever possible.** Only include a scope when it significantly clarifies which part of the codebase is affected.
+
+Use scopes sparingly and only when the change is isolated to a specific area:
+- Component or module names (e.g., \`auth\`, \`api\`, \`ui\`, \`parser\`)
+- Feature areas (e.g., \`login\`, \`checkout\`, \`dashboard\`)
+- File or directory names when appropriate
+
+Omit scope for:
+- Changes that affect the entire project
+- Changes that don't fit a specific area
+- Most commits where the type and description are clear enough
+- When in doubt, leave it out
+
+## Description Patterns
+- Start with a verb in imperative mood (add, update, remove, fix, implement, etc.)
+- Be specific about what changed, not how it changed
+- Focus on the "what" and "why", not the "how"
+- Avoid ending with a period
+- Keep it clear enough that someone can understand the change without reading the code
+
+## Examples
+- \`feat: add OAuth2 authentication support\`
+- \`fix: resolve timeout issue in user endpoint\`
+- \`docs: update installation instructions in README\`
+- \`style: fix indentation and spacing\`
+- \`refactor: simplify data parsing logic\`
+- \`perf: optimize database query performance\`
+- \`test: add unit tests for login validation\`
+- \`build: upgrade webpack to version 5\`
+- \`ci: add automated deployment workflow\`
+- \`chore: update dependencies to latest versions\`
+
+Examples with scope (use only when necessary):
+- \`feat(auth): add biometric authentication\`
+- \`fix(api): handle null response in user service\`
+
+## Breaking Changes
+For breaking changes, add \`!\` after the type/scope:
+- \`feat!: remove deprecated API endpoints\`
+- \`refactor(api)!: change response format to JSON:API spec\`
+
+## Additional Notes
+- If a commit addresses a specific issue, you can reference it in the description (e.g., \`fix: resolve memory leak (fixes #123)\`)
+- Each commit should represent a single logical change
+- Write commits as if completing the sentence: "If applied, this commit will..."`;
+var GUIDELINES_GENERATOR_PROMPT = dedent3`
+You are a commit style analyzer. Analyze the provided commit history and generate a personalized style guide that will be used to generate future commit messages.
+
+## Task
+
+Analyze the commit messages below and create clear guidelines that capture the user's commit message style and patterns.
+
+## Input Format
+
+You will receive a list of commit messages from the user's git history:
+
+\`\`\`
+COMMIT HISTORY:
+[List of previous commit messages]
+\`\`\`
+
+## Output Format
+
+Generate a markdown document with clear, actionable guidelines. Use this structure:
+
+\`\`\`markdown
+# Commit Message Guidelines
+
+## Format
+[Describe the exact format: conventional commits, custom format, etc.]
+
+## Style Rules
+- **Tense**: [present/past/imperative]
+- **Capitalization**: [first letter uppercase/lowercase/varies]
+- **Length**: [typical character count or "concise"/"detailed"]
+- **Tone**: [technical/casual/formal]
+
+## Commit Types
+[List the types they use with brief descriptions]
+- \`type\`: When to use this type
+
+## Scope Usage
+[If they use scopes, describe the pattern. If not, say "No scopes used"]
+
+## Description Patterns
+[How they write descriptions - specific patterns, keywords, style]
+
+## Examples from History
+[Include 3-5 actual examples from their commits]
+\`\`\`
+
+## Analysis Guidelines
+
+**IMPORTANT**: Ignore merge commits when analyzing style. Skip any commits that:
+- Start with "Merge pull request"
+- Start with "Merge branch"
+- Start with "Merge remote-tracking branch"
+- Contain "Merge" as the primary action
+
+Focus only on regular commits (features, fixes, refactors, etc.) for style analysis.
+
+When analyzing commits, look for:
+
+1. **Structure Patterns**:
+   - Do they follow conventional commits? (type: description or type(scope): description)
+   - Is there a consistent format?
+   - Any special characters or prefixes?
+
+2. **Commit Types**:
+   - What types do they use? (feat, fix, docs, refactor, style, test, chore, etc.)
+   - Are types consistent or mixed?
+   - Any custom types?
+
+3. **Scope Patterns**:
+   - Do they use scopes in parentheses?
+   - What scopes appear frequently?
+   - Are scopes specific (file/component names) or general (area names)?
+
+4. **Writing Style**:
+   - Present tense ("add feature") vs past tense ("added feature") vs imperative ("add feature")
+   - First letter capitalized or lowercase?
+   - Typical length - short and concise or longer and detailed?
+   - Technical terminology or simple language?
+
+5. **Common Patterns**:
+   - Repeated keywords or phrases
+   - How they describe features vs fixes vs refactors
+   - Any emoji usage?
+   - Any ticket/issue references?
+
+## Quality Requirements
+
+The generated guidelines must be:
+- ✓ **Clear and specific** - no vague statements
+- ✓ **Actionable** - easy to follow when generating new commits
+- ✓ **Accurate** - truly reflect the user's style
+- ✓ **Concise** - keep it under 300 words
+- ✓ **Consistent** - don't contradict yourself
+
+## Special Cases
+
+**If commits are inconsistent**: Choose the most frequent pattern and note: "Style varies, but most commonly uses [pattern]"
+
+**If very few commits after filtering merges**: Note: "Limited commit history available. Using conventional commits as base with observed patterns."
+
+**If only merge commits exist**: Generate standard conventional commits guidelines and note: "No regular commits found in history. Using conventional commits format."
+
+**If commits are very simple**: That's fine! Note: "Prefers simple, straightforward commit messages"
+
+**If no clear pattern**: Generate sensible conventional commit guidelines with a note: "No strong pattern detected. Recommending conventional commits format."
+
+## Example Analysis
+
+Given these commits:
+\`\`\`
+feat(auth): add OAuth2 login support
+fix(api): resolve timeout issue in user endpoint
+refactor: simplify database connection logic
+docs: update README with setup instructions
+feat(ui): implement dark mode toggle
+\`\`\`
+
+Generate guidelines like:
+\`\`\`markdown
+# Commit Message Guidelines
+
+## Format
+Use conventional commits: \`type(scope): description\`
+
+## Style Rules
+- **Tense**: Imperative/present ("add", "fix", "implement")
+- **Capitalization**: Lowercase first letter
+- **Length**: Concise, 40-60 characters
+- **Tone**: Technical and specific
+
+## Commit Types
+- \`feat\`: New features or capabilities
+- \`fix\`: Bug fixes and issue resolutions
+- \`refactor\`: Code improvements without new features
+- \`docs\`: Documentation updates
+
+## Scope Usage
+Use specific component/area names in parentheses (auth, api, ui). Omit scope for general changes like refactoring.
+
+## Description Patterns
+Start with action verb (add, implement, resolve, update, simplify). Be specific about what changed. Reference the component or feature affected.
+
+## Examples from History
+- feat(auth): add OAuth2 login support
+- fix(api): resolve timeout issue in user endpoint
+- refactor: simplify database connection logic
+\`\`\`
+
+## Important Notes
+
+- Focus on patterns, not on individual commit content
+- Generate guidelines that will work for future commits, not just explain past ones
+- Keep it practical and easy to follow
+- The output will be stored as \`.noto/commit-prompt.md\` and used by an AI to generate commits
+
+Generate the markdown guidelines now based on the commit history provided.
+`;
+var cacheMiddleware = {
+  wrapGenerate: async ({ doGenerate, params }) => {
+    const key2 = hashString(JSON.stringify(params));
+    const cache = (await StorageManager.get()).cache;
+    if (cache && key2 in cache) {
+      const cached = cache[key2];
+      return superjson.parse(cached);
     }
-    const currentBranch = await getCurrentBranch();
-    const branch = await p5.select({
-      message: "select a branch",
-      options: branches.map((branch2) => ({
-        value: branch2,
-        label: color5.bold(branch2 === currentBranch ? color5.green(branch2) : branch2),
-        hint: branch2 === currentBranch ? "current branch" : undefined
-      })),
-      initialValue: currentBranch
+    const result = await doGenerate();
+    await StorageManager.update((current) => {
+      return {
+        ...current,
+        cache: {
+          [key2]: superjson.stringify(result)
+        }
+      };
     });
-    if (p5.isCancel(branch)) {
-      p5.log.error("nothing selected!");
-      return await exit(1);
-    }
-    if (!branch) {
-      p5.log.error("no branch selected");
-      return await exit(1);
-    }
-    clipboard3.writeSync(branch);
-    p5.log.success(`${color5.green("copied to clipboard!")}`);
-    await exit(0);
-  }, { enabled: false }),
-  subCommands: [current, del]
+    return result;
+  }
 };
-var branch_default = command3;
+var generateCommitMessage = async (diff, prompt, context, forceCache = false) => {
+  const model2 = await getModel();
+  const { object } = await generateObject({
+    model: !forceCache ? wrapLanguageModel({
+      model: model2,
+      middleware: cacheMiddleware
+    }) : model2,
+    schema: z6.object({
+      message: z6.string()
+    }),
+    messages: [
+      {
+        role: "system",
+        content: COMMIT_GENERATOR_PROMPT
+      },
+      {
+        role: "user",
+        content: dedent3`
+        USER GUIDELINES:
+        ${prompt ?? DEFAULT_COMMIT_GUIDELINES}
+        ${context ? `
+USER CONTEXT:
+${context}` : ""}
 
-// src/commands/checkout.ts
-import * as p6 from "@clack/prompts";
-import color6 from "picocolors";
-import clipboard4 from "clipboardy";
-import dedent6 from "dedent";
-var command4 = {
-  name: "checkout",
-  description: "checkout a branch",
-  usage: "checkout [options]",
-  options: [
-    {
-      type: Boolean,
-      flag: "--copy",
-      alias: "-c",
-      description: "copy the selected branch to clipboard"
-    },
-    {
-      type: Boolean,
-      flag: "--create",
-      alias: "-b",
-      description: "create a new branch"
-    }
-  ],
-  execute: withRepository(async (options) => {
-    const args = options._.slice(1);
-    if (!options.isRepo) {
-      p6.log.error(dedent6`${color6.red("no git repository found in cwd.")}
-            ${color6.dim(`run ${color6.cyan("`git init`")} to initialize a new repository.`)}`);
-      return await exit(1);
-    }
-    const branches = await getBranches();
-    if (!branches) {
-      p6.log.error("failed to fetch branches");
-      return await exit(1);
-    }
-    const currentBranch = await getCurrentBranch();
-    const branchName = args[0];
-    if (options["--create"]) {
-      if (branches.includes(branchName)) {
-        p6.log.error(`branch ${color6.red(branchName)} already exists in the repository`);
-        return await exit(1);
-      }
-      const result2 = await checkoutLocalBranch(branchName);
-      if (!result2) {
-        p6.log.error(`failed to create and checkout ${color6.bold(branchName)}`);
-        return await exit(1);
-      }
-      p6.log.success(`created and checked out ${color6.green(branchName)}`);
-      return await exit(0);
-    }
-    if (branchName) {
-      if (!branches.includes(branchName)) {
-        p6.log.error(`branch ${color6.red(branchName)} does not exist in the repository`);
-        const createBranch = await p6.confirm({
-          message: `do you want to create branch ${color6.green(branchName)}?`
-        });
-        if (p6.isCancel(createBranch)) {
-          p6.log.error("aborted");
-          return await exit(1);
-        }
-        if (createBranch) {
-          const result3 = await checkoutLocalBranch(branchName);
-          if (!result3) {
-            p6.log.error(`failed to create and checkout ${color6.bold(branchName)}`);
-            return await exit(1);
-          }
-          p6.log.success(`created and checked out ${color6.green(branchName)}`);
-          return await exit(0);
-        }
-        return await exit(1);
+        GIT DIFF:
+        ${diff}
+      `
       }
-      if (branchName === currentBranch) {
-        p6.log.error(`${color6.red("already on branch")} ${color6.green(branchName)}`);
-        return await exit(1);
+    ]
+  });
+  return object.message.trim();
+};
+var generateCommitGuidelines = async (commits) => {
+  const model2 = await getModel();
+  const { object } = await generateObject({
+    model: model2,
+    schema: z6.object({
+      prompt: z6.string()
+    }),
+    messages: [
+      {
+        role: "system",
+        content: GUIDELINES_GENERATOR_PROMPT
+      },
+      {
+        role: "user",
+        content: dedent3`
+        COMMIT HISTORY:
+        ${commits.join(`
+`)}`
       }
-      const result2 = await checkout(branchName);
-      if (!result2) {
-        p6.log.error(`failed to checkout ${color6.bold(branchName)}`);
+    ]
+  });
+  return object.prompt.trim();
+};
+
+// src/commands/init.ts
+var EMPTY_TEMPLATE = dedent4`
+  # Commit Message Guidelines
+  
+  # Add your custom guidelines here.
+  # When no guidelines are present, noto will use conventional commits format by default.`;
+var init = authedGitProcedure.meta({
+  description: "initialize noto in the repository"
+}).input(z7.object({
+  root: z7.boolean().meta({
+    description: "create the prompt file in the git root"
+  }),
+  generate: z7.boolean().meta({
+    description: "generate a prompt file based on existing commits"
+  })
+})).mutation(async (opts) => {
+  const { input } = opts;
+  const root = await getGitRoot();
+  let promptFile = root;
+  const cwd = process.cwd();
+  const existingPromptFile = await getPromptFile();
+  let prompt = null;
+  if (existingPromptFile) {
+    if (!existingPromptFile.startsWith(cwd)) {
+      p7.log.warn(dedent4`${color7.yellow("a prompt file already exists!")}
+                    ${color7.gray(existingPromptFile)}`);
+      const shouldContinue = await p7.confirm({
+        message: "do you want to create in the current directory instead?",
+        initialValue: true
+      });
+      if (p7.isCancel(shouldContinue) || !shouldContinue) {
+        p7.log.error("aborted");
         return await exit(1);
       }
-      p6.log.success(`checked out ${color6.green(branchName)}`);
-      return await exit(0);
-    }
-    const branch = await p6.select({
-      message: "select a branch to checkout",
-      options: branches.map((branch2) => ({
-        value: branch2,
-        label: color6.bold(branch2 === currentBranch ? color6.green(branch2) : branch2),
-        hint: branch2 === currentBranch ? "current branch" : undefined
-      })),
-      initialValue: currentBranch
-    });
-    if (p6.isCancel(branch)) {
-      p6.log.error("nothing selected!");
+      promptFile = cwd;
+    } else {
+      p7.log.error(dedent4`${color7.red("a prompt file already exists.")}
+                    ${color7.gray(existingPromptFile)}`);
       return await exit(1);
     }
-    if (!branch) {
-      p6.log.error("no branch selected");
+  }
+  if (root !== cwd && !input.root) {
+    const shouldUseRoot = await p7.confirm({
+      message: "do you want to create the prompt file in the git root?",
+      initialValue: true
+    });
+    if (p7.isCancel(shouldUseRoot)) {
+      p7.log.error("aborted");
       return await exit(1);
     }
-    if (options["--copy"]) {
-      clipboard4.writeSync(branch);
-      p6.log.success(`copied ${color6.green(branch)} to clipboard`);
-      return await exit(0);
-    }
-    if (branch === currentBranch) {
-      p6.log.error(`${color6.red("already on branch")}`);
+    if (!shouldUseRoot)
+      promptFile = cwd;
+  }
+  const commits = await getCommits();
+  let generate = input.generate;
+  if (generate) {
+    if (!commits || commits.length < 5) {
+      p7.log.error(dedent4`${color7.red("not enough commits to generate a prompt file.")}
+                    ${color7.gray("at least 5 commits are required.")}`);
       return await exit(1);
     }
-    const result = await checkout(branch);
-    if (!result) {
-      p6.log.error(`failed to checkout ${color6.bold(branch)}`);
+  } else if (commits && commits.length >= 5) {
+    const shouldGenerate = await p7.confirm({
+      message: "do you want to generate a prompt file based on existing commits?",
+      initialValue: true
+    });
+    if (p7.isCancel(shouldGenerate)) {
+      p7.log.error("aborted");
       return await exit(1);
     }
-    p6.log.success(`checked out ${color6.green(branch)}`);
-    await exit(0);
-  }, { enabled: false })
-};
-var checkout_default = command4;
+    generate = shouldGenerate;
+  }
+  const spin = p7.spinner();
+  if (commits && generate) {
+    spin.start("generating commit message guidelines");
+    prompt = await generateCommitGuidelines(commits);
+    spin.stop(color7.green("generated commit message guidelines!"));
+  } else {
+    prompt = EMPTY_TEMPLATE;
+  }
+  try {
+    const dir = `${promptFile}/.noto`;
+    await fs4.mkdir(dir, { recursive: true });
+    const filePath = `${dir}/commit-prompt.md`;
+    await fs4.writeFile(filePath, prompt, "utf-8");
+    p7.log.success(dedent4`${color7.green("prompt file created!")}
+                        ${color7.gray(filePath)}`);
+    return await exit(0);
+  } catch {
+    p7.log.error(color7.red("failed to create the prompt file!"));
+  }
+});
 
-// src/commands/config.ts
-import * as p7 from "@clack/prompts";
-import color7 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 confirm3 = await p7.confirm({
-        message: "noto api key already configured, do you want to update it?"
+// src/commands/noto.ts
+import { z as z8 } from "zod";
+import * as p8 from "@clack/prompts";
+import color8 from "picocolors";
+import clipboard3 from "clipboardy";
+import { APICallError, RetryError } from "ai";
+var noto = authedGitProcedure.meta({
+  description: "generate a commit message",
+  default: true,
+  diffRequired: true,
+  promptRequired: true
+}).input(z8.object({
+  message: z8.string().or(z8.boolean()).meta({
+    description: "provide context for commit message",
+    alias: "m"
+  }),
+  copy: z8.boolean().meta({
+    description: "copy the generated message to clipboard",
+    alias: "c"
+  }),
+  apply: z8.boolean().meta({ description: "commit the generated message", alias: "a" }),
+  push: z8.boolean().meta({ description: "commit and push the changes", alias: "p" }),
+  force: z8.boolean().meta({
+    description: "bypass cache and force regeneration of commit message",
+    alias: "f"
+  }),
+  manual: z8.boolean().meta({ description: "custom commit message" })
+})).mutation(async (opts) => {
+  const { input, ctx } = opts;
+  const spin = p8.spinner();
+  try {
+    const manual = input.manual;
+    if (manual) {
+      const message2 = await p8.text({
+        message: "edit the generated commit message",
+        placeholder: "chore: init repo"
       });
-      if (p7.isCancel(confirm3) || !confirm3) {
-        p7.log.error(color7.red("nothing changed!"));
+      if (p8.isCancel(message2)) {
+        p8.log.error(color8.red("nothing changed!"));
         return await exit(1);
       }
+      p8.log.step(color8.green(message2));
+      await StorageManager.update((current) => ({
+        ...current,
+        lastGeneratedMessage: message2
+      }));
+      const success = await commit(message2);
+      if (success) {
+        p8.log.step(color8.dim("commit successful"));
+      } else {
+        p8.log.error(color8.red("failed to commit changes"));
+      }
+      return await exit(0);
     }
-    let apiKey = options._[0];
-    if (!apiKey) {
-      const result = await p7.text({
-        message: "enter your noto api key"
+    let context = input.message;
+    if (typeof context === "string") {
+      context = context.trim();
+    } else if (typeof context === "boolean" && context === true) {
+      const enteredContext = await p8.text({
+        message: "provide context for the commit message",
+        placeholder: "describe the changes"
       });
-      if (p7.isCancel(result)) {
-        p7.log.error(color7.red("nothing changed!"));
+      if (p8.isCancel(enteredContext)) {
+        p8.log.error(color8.red("nothing changed!"));
         return await exit(1);
       }
-      apiKey = result;
+      context = enteredContext;
     }
-    await StorageManager.update((current2) => ({
-      ...current2,
-      llm: {
-        ...current2.llm,
-        apiKey
-      }
-    }));
-    p7.log.success(color7.green("noto api key configured!"));
-    await exit(0);
-  }
-};
-var model = {
-  name: "model",
-  description: "configure model",
-  usage: "noto config model [options]",
-  execute: async () => {
-    const model2 = await p7.select({
-      message: "select a model",
-      initialValue: (await StorageManager.get()).llm?.model,
-      options: Object.keys(models).map((model3) => ({
-        label: model3,
-        value: model3
-      }))
+    spin.start("generating commit message");
+    let message = null;
+    message = await generateCommitMessage(ctx.git.diff, ctx.noto.prompt, typeof context === "string" ? context : undefined, input.force);
+    spin.stop(color8.white(message));
+    const editedMessage = await p8.text({
+      message: "edit the generated commit message",
+      initialValue: message,
+      placeholder: message
     });
-    if (p7.isCancel(model2)) {
-      p7.log.error(color7.red("nothing changed!"));
+    if (p8.isCancel(editedMessage)) {
+      p8.log.error(color8.red("nothing changed!"));
       return await exit(1);
     }
-    if (model2 === "gemini-2.5-pro-preview-05-06") {
-      const confirm3 = await p7.confirm({
-        message: "this model does not have free quota tier, do you want to continue?"
-      });
-      if (p7.isCancel(confirm3) || !confirm3) {
-        p7.log.error(color7.red("nothing changed!"));
-        return await exit(1);
-      }
-    }
-    await StorageManager.update((current2) => ({
-      ...current2,
-      llm: {
-        ...current2.llm,
-        model: model2
-      }
+    message = editedMessage;
+    p8.log.step(color8.green(message));
+    await StorageManager.update((current) => ({
+      ...current,
+      lastGeneratedMessage: message
     }));
-    p7.log.success(color7.green("model configured!"));
-    await exit(0);
-  }
-};
-var reset = {
-  name: "reset",
-  description: "reset configuration",
-  usage: "noto config reset",
-  execute: async () => {
-    const confirm3 = await p7.confirm({
-      message: "are you sure you want to reset the configuration?"
-    });
-    if (p7.isCancel(confirm3) || !confirm3) {
-      p7.log.error(color7.red("nothing changed!"));
-      return await exit(1);
+    if (input.copy) {
+      clipboard3.writeSync(message);
+      p8.log.step(color8.dim("copied commit message to clipboard"));
     }
-    await StorageManager.clear();
-    p7.log.success(color7.green("configuration reset!"));
-    await exit(0);
-  }
-};
-var subCommands = [key, model, reset];
-var command5 = {
-  name: "config",
-  description: "configure noto",
-  usage: "noto config [subcommand]",
-  execute: async (options) => {
-    const command6 = await p7.select({
-      message: "select a subcommand",
-      options: subCommands.map((cmd2) => ({
-        label: cmd2.description,
-        value: cmd2.name
-      }))
-    });
-    if (p7.isCancel(command6)) {
-      return await exit(1);
+    if (input.apply) {
+      const success = await commit(message);
+      if (success) {
+        p8.log.step(color8.dim("commit successful"));
+      } else {
+        p8.log.error(color8.red("failed to commit changes"));
+      }
     }
-    const cmd = getCommand(command6, subCommands);
-    if (!cmd) {
-      p7.log.error(color7.red("unknown config command"));
-      return await exit(1);
+    if (input.push) {
+      const success = await push();
+      if (success) {
+        p8.log.step(color8.dim("push successful"));
+      } else {
+        p8.log.error(color8.red("failed to push changes"));
+      }
     }
-    options._ = options._.slice(1);
-    cmd.execute(options);
-  },
-  subCommands
-};
-var config_default = command5;
-
-// src/commands/help.ts
-import color8 from "picocolors";
-var help = {
-  name: "help",
-  description: "show help",
-  usage: "noto help [command]",
-  execute: async (options) => {
-    const command6 = getCommand(options._[0]);
-    if (command6 && command6.name !== "help") {
-      console.log();
-      console.log(color8.bold("usage"));
-      console.log(`  ${command6.usage}`);
-      console.log();
-      console.log(color8.bold("description"));
-      console.log(`  ${command6.description}`);
-      console.log();
-    } else {
-      const commands = listCommand();
-      console.log();
-      console.log(color8.bold("usage"));
-      console.log(`  noto [command] [options]`);
-      console.log();
-      console.log(color8.bold("commands"));
-      commands.forEach((command7) => {
-        console.log(`  ${color8.bold(command7.name)}   ${color8.dim(command7.description)}`);
-      });
-      await exit(0);
+    return await exit(0);
+  } catch (e) {
+    let msg;
+    if (RetryError.isInstance(e) && APICallError.isInstance(e.lastError)) {
+      msg = safeParseErrorMessage(e.lastError.responseBody);
     }
+    const suffix = msg ? `
+${msg}` : "";
+    spin.stop(color8.red(`failed to generate commit message${suffix}`), 1);
+    await exit(1);
   }
-};
-var help_default = help;
+});
+function safeParseErrorMessage(body) {
+  if (typeof body !== "string")
+    return;
+  try {
+    const parsed = JSON.parse(body);
+    return parsed?.error?.message ?? parsed?.message;
+  } catch {
+    return;
+  }
+}
 
 // src/commands/index.ts
-var commands = [noto_default, prev_default, branch_default, checkout_default, config_default, help_default];
-var getCommand = (name, cmds = commands) => {
-  return cmds.find((cmd) => cmd.name === name);
+var commands = {
+  checkout: checkout2,
+  config,
+  prev,
+  init,
+  noto
 };
-var listCommand = () => {
-  return commands;
-};
-// package.json
-var version = "1.2.9";
+
+// src/router.ts
+var router = t.router(commands);
 
 // src/index.ts
-var globalSpec = {
-  "--version": Boolean,
-  "--help": Boolean,
-  "-v": "--version",
-  "-h": "--help"
-};
-function main() {
-  const args = process.argv.slice(2);
-  const { command: command6, options: globalOptions } = parse(globalSpec, args);
-  console.log();
-  p8.intro(`${color9.bgCyan(color9.black(" @snelusha/noto "))}`);
-  if (globalOptions["--version"])
-    return p8.outro(version);
-  if (globalOptions["--help"]) {
-    getCommand("help")?.execute(globalOptions);
-    return;
-  }
-  const cmd = getCommand(command6) ?? getCommand("noto");
-  if (!cmd)
-    return getCommand("noto")?.execute(globalOptions);
-  let commandArgs = args;
-  let selectedCommand = cmd;
-  if (cmd.subCommands && commandArgs.length) {
-    const possibleCommand = commandArgs[1];
-    const subCommand = cmd.subCommands.find((cmd2) => cmd2.name === possibleCommand || cmd2.aliases && cmd2.aliases.includes(possibleCommand));
-    if (subCommand) {
-      selectedCommand = subCommand;
-      commandArgs = commandArgs.slice(2);
-    }
-  }
-  const commandSpec = (selectedCommand.options ?? []).reduce((acc, opt) => {
-    acc[opt.flag] = opt.type ?? Boolean;
-    if (Array.isArray(opt.alias))
-      opt.alias.forEach((alias) => acc[alias] = opt.flag);
-    else if (opt.alias)
-      acc[opt.alias] = opt.flag;
-    return acc;
-  }, {});
-  const { options: commandOptions } = safeParse(commandSpec, commandArgs);
-  const options = { ...globalOptions, ...commandOptions };
-  selectedCommand.execute(options);
-}
-main();
+createCli({
+  name: "noto",
+  router,
+  version
+}).run();