nocommit 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# nocommit
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.0. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/ai.d.ts

@@ -0,0 +1,10 @@
+/** Options for generating commit messages */
+export interface GenerateOptions {
+    diffSnippets: string;
+    files: string[];
+    maxLength?: number;
+    count?: number;
+    timeout?: number;
+}
+export declare const generateCommitMessages: (options: GenerateOptions) => Promise<string[]>;
+export declare const generateCommitMessage: (diff: string) => Promise<string>;

package/dist/ai.js

@@ -0,0 +1,97 @@
+import { GoogleGenAI } from "@google/genai";
+import { getApiKey, getConfig } from "./config.js";
+import { KnownError } from "./error.js";
+const buildPrompt = (diffSnippets, fileList, maxLength, count) => `You are an expert developer writing git commit messages.
+
+CHANGES:
+Files: ${fileList.join(", ")}
+
+${diffSnippets ? `CODE DIFF:\n${diffSnippets}` : ""}
+
+TASK: Generate ${count} different commit message${count > 1 ? "s" : ""} for these changes.
+
+FORMAT RULES:
+- Use Conventional Commits: <type>: <subject>
+- NO scope (use "feat: add login" NOT "feat(auth): add login")
+- Maximum ${maxLength} characters per message
+- Use imperative mood ("add" not "added")
+- Be specific but concise
+
+TYPES:
+- feat: NEW user-facing feature
+- fix: bug fix
+- docs: documentation only
+- style: formatting, missing semi-colons
+- refactor: code change without new feature or fix
+- perf: performance improvement
+- test: adding/correcting tests
+- build: build system, dependencies
+- ci: CI configuration
+- chore: maintenance, config updates
+
+EXAMPLES (correct):
+- feat: add user authentication with JWT
+- fix: resolve memory leak in image processor
+- refactor: simplify error handling logic
+
+WRONG (do not use scope):
+- feat(auth): add login
+
+Output ${count > 1 ? `exactly ${count} commit messages, one per line` : "only the commit message"}, no explanations or numbering.`;
+// Generates commit messages using Gemini
+export const generateCommitMessages = async (options) => {
+    const apiKey = getApiKey();
+    const model = getConfig("model");
+    const maxLength = options.maxLength ?? getConfig("maxLength");
+    const count = options.count ?? getConfig("generate");
+    const ai = new GoogleGenAI({ apiKey });
+    const prompt = buildPrompt(options.diffSnippets, options.files, maxLength, count);
+    try {
+        const response = await ai.models.generateContent({
+            model,
+            contents: prompt,
+            config: {
+                maxOutputTokens: 256,
+                temperature: 0.7,
+            },
+        });
+        const text = response.text?.trim();
+        if (!text) {
+            throw new KnownError("AI returned empty response. Please try again");
+        }
+        // Parse response: split by newlines, remove empty lines
+        const messages = text
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.match(/^\d+\./))
+            .map((line) => line.replace(/^[-*]\s*/, ""));
+        if (messages.length === 0) {
+            throw new KnownError("AI returned no valid commit messages.");
+        }
+        return messages.slice(0, count);
+    }
+    catch (error) {
+        if (error instanceof KnownError) {
+            throw error;
+        }
+        if (error.message?.includes("API key")) {
+            throw new KnownError("Invalid Gemini API Key. Run: nc config set GEMINI_API_KEY=<key>");
+        }
+        if (error.message?.includes("Quota")) {
+            throw new KnownError("API quota exceeded. Please check your Gemini API usage limits.");
+        }
+        if (error.message?.includes("network") || error.code === "ENOTFOUND") {
+            throw new KnownError("Network error. Please check your internet connection.");
+        }
+        throw new KnownError(`AI error: ${error.message}`);
+    }
+};
+// generate a single commit message
+export const generateCommitMessage = async (diff) => {
+    const messages = await generateCommitMessages({
+        diffSnippets: diff,
+        files: [],
+        count: 1,
+    });
+    return messages[0] || "";
+};

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+export interface ConfigSchema {
+    GEMINI_API_KEY: string;
+    model: string;
+    maxLength: number;
+    timeout: number;
+    generate: number;
+}
+export declare const getConfig: <K extends keyof ConfigSchema>(key: K) => ConfigSchema[K];
+export declare const setConfig: <K extends keyof ConfigSchema>(key: K, value: ConfigSchema[K]) => void;
+export declare const getAllConfig: () => ConfigSchema;
+export declare const getApiKey: () => string;

package/dist/config.js

@@ -0,0 +1,33 @@
+import Conf from "conf";
+import { KnownError } from "./error.js";
+const config = new Conf({
+    projectName: "nocommit",
+    defaults: {
+        GEMINI_API_KEY: "",
+        model: "gemini-2.5-flash",
+        maxLength: 72,
+        timeout: 30000,
+        generate: 3,
+    },
+});
+// export const getConfig = (key: string) => {
+//     return config.get(key as any);
+//   };
+// get Config
+export const getConfig = (key) => {
+    return config.get(key);
+};
+// set Config
+export const setConfig = (key, value) => {
+    config.set(key, value);
+};
+export const getAllConfig = () => {
+    return config.store;
+};
+export const getApiKey = () => {
+    const key = config.get("GEMINI_API_KEY");
+    if (!key) {
+        throw new KnownError("Missing API Key. Run: nc config set GEMINI_API_KEY=<Key Your API Key>");
+    }
+    return key;
+};

package/dist/error.d.ts

@@ -0,0 +1,5 @@
+export declare class KnownError extends Error {
+    constructor(message: string);
+}
+export declare const isKnownError: (error: unknown) => error is KnownError;
+export declare const handleCliError: (error: unknown) => void;

package/dist/error.js

@@ -0,0 +1,18 @@
+export class KnownError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "KnownError";
+    }
+}
+export const isKnownError = (error) => {
+    return error instanceof KnownError;
+};
+export const handleCliError = (error) => {
+    if (isKnownError(error)) {
+        process.exit(1);
+    }
+    if (error instanceof Error) {
+        console.error("\nUnexpected error", error.stack);
+    }
+    process.exit(1);
+};

package/dist/git.d.ts

@@ -0,0 +1,13 @@
+export declare const isGitRepo: () => Promise<boolean>;
+export declare const assertGitRepo: () => Promise<void>;
+export declare const stageAllChanges: () => Promise<void>;
+export declare const getStagedDiff: () => Promise<string>;
+export declare const hasStagedChanges: () => Promise<boolean>;
+export declare const getStagedFiles: () => Promise<string[]>;
+export declare const commitChanges: (message: string) => Promise<void>;
+/**
+ * Extracts only changed lines from diff for token efficiency.
+ * Limits: 5 files max, 30 lines per file, 4000 chars total.
+ */
+export declare const buildDiffSnippets: (files: string[], perFileMaxLines?: number, totalMaxChars?: number) => Promise<string>;
+export declare const getStagedSummary: () => Promise<string>;

package/dist/git.js

@@ -0,0 +1,136 @@
+import { execa } from "execa";
+import { KnownError } from "./error.js";
+// Exclude from diff to save API Token
+const EXCLUDE = [
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "bun.lock",
+    "node_modules/**",
+    "dist/**",
+    "build/**",
+    ".next/**",
+    "*.min.js",
+    "*.map",
+    "*.log",
+].flatMap((file) => [":(exclude)" + file]);
+// Check git init or not
+export const isGitRepo = async () => {
+    try {
+        await execa("git", ["rev-parse", "--is-inside-work-tree"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const assertGitRepo = async () => {
+    if (!(await isGitRepo())) {
+        throw new KnownError("Not a git repository. Run this command inside 'git init'");
+    }
+};
+// Check Stages everything (git add .)
+export const stageAllChanges = async () => {
+    await execa("git", ["add", "--update"]);
+};
+// gets the actual code changes
+export const getStagedDiff = async () => {
+    try {
+        const { stdout } = await execa("git", ["diff", "--staged", ...EXCLUDE]);
+        return stdout;
+    }
+    catch {
+        return "";
+    }
+};
+export const hasStagedChanges = async () => {
+    const { stdout } = await execa("git", [
+        "diff",
+        "--staged",
+        "--name-only",
+        ...EXCLUDE,
+    ]);
+    return stdout.trim().length > 0;
+};
+// gets the list of filenames
+export const getStagedFiles = async () => {
+    const { stdout } = await execa("git", [
+        "diff",
+        "--staged",
+        "--name-only",
+        ...EXCLUDE,
+    ]);
+    return stdout.split("\n").filter(Boolean);
+};
+// git commit -m "your message here"
+export const commitChanges = async (message) => {
+    await execa("git", ["commit", "-m", message], {
+        stdio: "inherit",
+    });
+};
+/**
+ * Extracts only changed lines from diff for token efficiency.
+ * Limits: 5 files max, 30 lines per file, 4000 chars total.
+ */
+export const buildDiffSnippets = async (files, perFileMaxLines = 30, totalMaxChars = 4000) => {
+    try {
+        const targetFiles = files.slice(0, 5);
+        const parts = [];
+        let remaining = totalMaxChars;
+        for (const file of targetFiles) {
+            const { stdout } = await execa("git", [
+                "diff",
+                "--cached",
+                "--unified=0",
+                "--",
+                file,
+            ]);
+            if (!stdout)
+                continue;
+            const lines = stdout.split("\n").filter(Boolean);
+            const picked = [];
+            let count = 0;
+            for (const line of lines) {
+                const isHunk = line.startsWith("@@");
+                const isChange = (line.startsWith("+") || line.startsWith("-")) &&
+                    !line.startsWith("+++") &&
+                    !line.startsWith("---");
+                if (isHunk || isChange) {
+                    picked.push(line);
+                    count++;
+                    if (count >= perFileMaxLines)
+                        break;
+                }
+            }
+            if (picked.length > 0) {
+                const block = [`# ${file}`, ...picked].join("\n");
+                if (block.length <= remaining) {
+                    parts.push(block);
+                    remaining -= block.length;
+                }
+                else {
+                    parts.push(block.slice(0, Math.max(0, remaining)));
+                    remaining = 0;
+                }
+            }
+            if (remaining <= 0)
+                break;
+        }
+        if (parts.length === 0)
+            return "";
+        return parts.join("\n\n");
+    }
+    catch {
+        return "";
+    }
+};
+// gets a high-level statistical summary
+export const getStagedSummary = async () => {
+    const { stdout } = await execa("git", [
+        "diff",
+        "--staged",
+        "--stat",
+        ...EXCLUDE,
+    ]);
+    return stdout;
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { intro, outro, spinner, select, text, isCancel } from "@clack/prompts";
+import pc from "picocolors";
+import { setConfig, getConfig } from "./config.js";
+import { assertGitRepo, hasStagedChanges, stageAllChanges, commitChanges, getStagedFiles, buildDiffSnippets, } from "./git.js";
+import { generateCommitMessages } from "./ai.js";
+import { KnownError, handleCliError } from "./error.js";
+const program = new Command();
+program
+    .name("nocommit")
+    .version("0.0.0")
+    .description("AI-powered git commit message generator")
+    .option("-a, --all", "Stage all tracked changes before committing")
+    .option("-y, --yes", "Skip confirmation and commit with first suggestion");
+// Main command execution logic for generating and committing messages
+program.action(async (options) => {
+    intro(pc.bgCyan(pc.black(" nocommit ")));
+    try {
+        await assertGitRepo();
+        if (options.all) {
+            await stageAllChanges();
+        }
+        if (!(await hasStagedChanges())) {
+            throw new KnownError('No staged changes found. Stage files with "git add ." or use --all flag.');
+        }
+        const s = spinner();
+        s.start("Detecting staged files...");
+        const files = await getStagedFiles();
+        s.stop(`Found ${files.length} staged file(s):`);
+        console.log(pc.dim(files.map((f) => `  ${f}`).join("\n")));
+        s.start("Analyzing changes with AI...");
+        const diffSnippets = await buildDiffSnippets(files);
+        const messages = await generateCommitMessages({
+            diffSnippets,
+            files,
+        });
+        s.stop("Generated commit message");
+        if (options.yes) {
+            const message = messages[0];
+            console.log(pc.dim(`Using: ${message}`));
+            await commitChanges(message);
+            outro(pc.green("✔ Committed!"));
+            return;
+        }
+        let selectedMessage = messages[0];
+        while (true) {
+            const action = await select({
+                message: `${pc.green(selectedMessage)}`,
+                options: [
+                    { value: "commit", label: "✔ Commit" },
+                    { value: "edit", label: "✎ Edit" },
+                    { value: "retry", label: "↻ Regenerate" },
+                    { value: "cancel", label: "✖ Cancel" },
+                ],
+            });
+            if (isCancel(action) || action === "cancel") {
+                outro("Cancelled");
+                process.exit(0);
+            }
+            if (action === "commit") {
+                await commitChanges(selectedMessage);
+                outro(pc.green("✔ Committed!"));
+                process.exit(0);
+            }
+            if (action === "edit") {
+                const newMessage = await text({
+                    message: "Edit message:",
+                    initialValue: selectedMessage,
+                    validate: (value) => {
+                        if (!value || value.trim().length === 0) {
+                            return "Message cannot be empty";
+                        }
+                        return undefined;
+                    },
+                });
+                if (!isCancel(newMessage)) {
+                    selectedMessage = newMessage.trim();
+                }
+            }
+            if (action === "retry") {
+                s.start("Regenerating...");
+                const newMessages = await generateCommitMessages({
+                    diffSnippets,
+                    files,
+                });
+                s.stop("New message generated");
+                selectedMessage = newMessages[0];
+            }
+        }
+    }
+    catch (error) {
+        outro(pc.red(error.message));
+        handleCliError(error);
+    }
+});
+// Command to manage application configuration, including API key and model settings
+const configCmd = program.command("config").description("Manage configuration");
+const VALID_CONFIG_KEYS = [
+    "GEMINI_API_KEY",
+    "model",
+    "maxLength",
+    "timeout",
+    "generate",
+];
+configCmd
+    .command("set <key=value>")
+    .description("Set a config value")
+    .action((str) => {
+    const eqIndex = str.indexOf("=");
+    if (eqIndex === -1) {
+        console.log(pc.red("Usage: config set KEY=VALUE"));
+        process.exit(1);
+    }
+    const key = str.slice(0, eqIndex);
+    const val = str.slice(eqIndex + 1);
+    if (!key || !val) {
+        console.log(pc.red("Usage: config set KEY=VALUE"));
+        process.exit(1);
+    }
+    if (!VALID_CONFIG_KEYS.includes(key)) {
+        console.log(pc.red(`Invalid key: ${key}`));
+        console.log(pc.yellow(`Valid keys: ${VALID_CONFIG_KEYS.join(", ")}`));
+        process.exit(1);
+    }
+    if (key === "maxLength") {
+        const num = parseInt(val, 10);
+        if (isNaN(num) || num < 20 || num > 500) {
+            console.log(pc.red("maxLength must be a number between 20 and 500"));
+            process.exit(1);
+        }
+        setConfig("maxLength", num);
+    }
+    else if (key === "timeout") {
+        const num = parseInt(val, 10);
+        if (isNaN(num) || num < 5000 || num > 120000) {
+            console.log(pc.red("timeout must be a number between 5000 and 120000 (ms)"));
+            process.exit(1);
+        }
+        setConfig("timeout", num);
+    }
+    else if (key === "generate") {
+        const num = parseInt(val, 10);
+        if (isNaN(num) || num < 1 || num > 5) {
+            console.log(pc.red("generate must be a number between 1 and 5"));
+            process.exit(1);
+        }
+        setConfig("generate", num);
+    }
+    else {
+        setConfig(key, val);
+    }
+    console.log(pc.green(`✔ Set ${key}`));
+});
+configCmd
+    .command("get [key]")
+    .description("Get config value(s)")
+    .action((key) => {
+    if (key) {
+        if (!VALID_CONFIG_KEYS.includes(key)) {
+            console.log(pc.red(`Invalid key: ${key}`));
+            console.log(pc.yellow(`Valid keys: ${VALID_CONFIG_KEYS.join(", ")}`));
+            process.exit(1);
+        }
+        const val = getConfig(key);
+        // Mask API key for security
+        if (key === "GEMINI_API_KEY" &&
+            typeof val === "string" &&
+            val.length > 8) {
+            console.log(`${key}: ${val.slice(0, 4)}...${val.slice(-4)}`);
+        }
+        else {
+            console.log(`${key}: ${val}`);
+        }
+    }
+    else {
+        console.log(pc.bold("Current configuration:"));
+        for (const k of VALID_CONFIG_KEYS) {
+            const val = getConfig(k);
+            if (k === "GEMINI_API_KEY" &&
+                typeof val === "string" &&
+                val.length > 8) {
+                console.log(`  ${k}: ${val.slice(0, 4)}...${val.slice(-4)}`);
+            }
+            else {
+                console.log(`  ${k}: ${val}`);
+            }
+        }
+    }
+});
+program.parse();

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "nocommit",
+  "version": "0.0.1",
+  "description": "Writes your git commit messages for you with AI using Gemini",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "nocommit": "dist/index.js",
+    "nc": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "git",
+    "commit",
+    "ai",
+    "gemini",
+    "cli"
+  ],
+  "author": "Asim Sk",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.10"
+  },
+  "peerDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "@google/genai": "^1.38.0",
+    "commander": "^14.0.2",
+    "conf": "^15.0.2",
+    "execa": "^9.6.1",
+    "picocolors": "^1.1.1"
+  }
+}