commit-agent-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# commit-agent-cli
+
+AI-powered git commit CLI that analyzes your changes and generates conventional commit messages using Claude 4.5.
+
+## Features
+
+-   **🤖 AI-Powered**: Uses Claude 4.5 (via Anthropic) with LangGraph for intelligent commit message generation.
+-   **🕵️ Agentic Exploration**: The AI agent can autonomously explore your codebase and git history:
+    -   Read files to understand context
+    -   List directories to understand project structure
+    -   Check commit history to learn your project's conventions
+    -   View staged, unstaged, and untracked files
+    -   Examine detailed diffs for specific files
+-   **👁️ Transparent**: See exactly what the agent is doing with detailed console logs showing every file read, directory listed, and git command executed.
+-   **⚙️ Customizable**: First-time setup asks for your preferences:
+    -   Use conventional commit prefixes (feat:, fix:, chore:, etc.) or natural language
+    -   Choose between concise or descriptive commit messages
+-   **✨ Interactive**: Beautiful CLI interface built with `@clack/prompts`.
+-   **🔒 Secure**: API keys and preferences are stored locally in `~/.commit-cli.json`.
+
+## Installation
+
+```bash
+npm install -g commit-agent-cli
+```
+
+## Usage
+
+1.  Stage your changes:
+    ```bash
+    git add .
+    ```
+
+2.  Run the tool:
+    ```bash
+    commit
+    ```
+
+3.  **First Time Setup**:
+    -   You'll be prompted to enter your Anthropic API Key (`sk-...`)
+    -   Choose whether to use conventional commit prefixes
+    -   Select your preferred commit message style (concise vs descriptive)
+    -   These preferences are saved and can be changed by editing `~/.commit-cli.json`
+
+4.  **Watch the Agent Work**:
+    The CLI will show you exactly what the agent is doing:
+    ```
+    📜 Agent is checking last 10 commits
+    📋 Agent is listing staged files
+    🔍 Agent is reading: src/index.ts
+    📂 Agent is listing directory: src
+    ```
+
+5.  **Review and Commit**:
+    -   Review the generated commit message
+    -   Choose to commit, regenerate, or cancel
+    -   Optionally push changes immediately
+
+## Agent Capabilities
+
+The AI agent has access to these tools to understand your codebase:
+
+-   **read_file**: Read any file to understand code context
+-   **list_dir**: Explore directory structure
+-   **git_commit_history**: Learn from your previous commits
+-   **git_staged_files**: See what's being committed
+-   **git_unstaged_files**: View unstaged changes
+-   **git_untracked_files**: List untracked files
+-   **git_show_file_diff**: Examine detailed diffs
+
+The agent will intelligently use these tools to generate contextually appropriate commit messages.
+
+## Configuration
+
+Your configuration is stored in `~/.commit-cli.json`:
+
+```json
+{
+  "ANTHROPIC_API_KEY": "sk-ant-...",
+  "preferences": {
+    "useConventionalCommits": true,
+    "commitMessageStyle": "concise"
+  }
+}
+```
+
+You can manually edit this file to change your preferences.
+
+## Development
+
+```bash
+git clone https://github.com/sunggyeol/commit-agent-cli.git
+cd commit-agent-cli
+npm install
+npm run build
+npm start
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,575 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/index.ts
+import "dotenv/config";
+import { intro, outro, text, spinner, confirm, isCancel, cancel, note } from "@clack/prompts";
+
+// src/git.ts
+import { execa } from "execa";
+async function getStagedDiff() {
+  const { stdout } = await execa("git", ["diff", "--cached"], {
+    reject: false
+  });
+  return stdout;
+}
+async function commit(message) {
+  await execa("git", ["commit", "-m", message]);
+}
+async function push() {
+  await execa("git", ["push"]);
+}
+async function isGitRepository() {
+  try {
+    await execa("git", ["rev-parse", "--is-inside-work-tree"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/agent.ts
+import { ChatAnthropic } from "@langchain/anthropic";
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { StateGraph, MessagesAnnotation } from "@langchain/langgraph";
+import { ToolNode } from "@langchain/langgraph/prebuilt";
+
+// src/tools.ts
+import { z } from "zod";
+import { tool } from "@langchain/core/tools";
+import { readFile, readdir, stat } from "fs/promises";
+import { join } from "path";
+import { execa as execa2 } from "execa";
+var validatePath = (p) => {
+  if (p.includes("..")) throw new Error("Cannot access parent directories");
+  return p;
+};
+var readFileTool = tool(
+  async ({ filePath }) => {
+    try {
+      console.log(`  \u{1F50D} Agent is reading: ${filePath}`);
+      const stats = await stat(validatePath(filePath));
+      const MAX_SIZE = 5e4;
+      if (stats.size > MAX_SIZE) {
+        return `File ${filePath} is too large (${Math.round(stats.size / 1024)}KB). Please be more specific about what you need from this file, or ask about a smaller file.`;
+      }
+      const content = await readFile(validatePath(filePath), "utf-8");
+      const MAX_CHARS = 1e4;
+      if (content.length > MAX_CHARS) {
+        return content.substring(0, MAX_CHARS) + `
+
+... [File truncated - ${content.length - MAX_CHARS} more characters]`;
+      }
+      return content;
+    } catch (error) {
+      return `Error reading file ${filePath}: ${error.message}`;
+    }
+  },
+  {
+    name: "read_file",
+    description: "Read the contents of a file to understand code context. Limited to files under 50KB. Use sparingly.",
+    schema: z.object({
+      filePath: z.string().describe("The path to the file to read (relative to project root)")
+    })
+  }
+);
+var listDirTool = tool(
+  async ({ dirPath }) => {
+    try {
+      console.log(`  \u{1F4C2} Agent is listing directory: ${dirPath}`);
+      const files = await readdir(validatePath(dirPath));
+      const result = await Promise.all(files.map(async (f) => {
+        try {
+          const s = await stat(join(dirPath, f));
+          return `${f} ${s.isDirectory() ? "(DIR)" : "(FILE)"}`;
+        } catch {
+          return f;
+        }
+      }));
+      return result.join("\n");
+    } catch (error) {
+      return `Error listing directory ${dirPath}: ${error.message}`;
+    }
+  },
+  {
+    name: "list_dir",
+    description: "List files and directories in a given path.",
+    schema: z.object({
+      dirPath: z.string().describe('The directory path to list (relative to project root). defaults to "."')
+    })
+  }
+);
+var gitCommitHistoryTool = tool(
+  async ({ count }) => {
+    try {
+      const limitedCount = Math.min(count, 5);
+      console.log(`  \u{1F4DC} Agent is checking last ${limitedCount} commits`);
+      const { stdout } = await execa2("git", ["log", `-n${limitedCount}`, "--pretty=format:%s"], { reject: false });
+      return stdout || "No commit history found";
+    } catch (error) {
+      return `Error getting commit history: ${error.message}`;
+    }
+  },
+  {
+    name: "git_commit_history",
+    description: "Get recent commit messages to understand project conventions. Returns just the commit messages (no hashes/authors). Limited to 5 commits max.",
+    schema: z.object({
+      count: z.number().default(5).describe("Number of recent commits to retrieve (max: 5, default: 5)")
+    })
+  }
+);
+var gitStagedFilesTool = tool(
+  async () => {
+    try {
+      console.log(`  \u{1F4CB} Agent is listing staged files`);
+      const { stdout } = await execa2("git", ["diff", "--cached", "--name-status"], { reject: false });
+      return stdout || "No staged files";
+    } catch (error) {
+      return `Error getting staged files: ${error.message}`;
+    }
+  },
+  {
+    name: "git_staged_files",
+    description: "List all staged files with their status (Added, Modified, Deleted).",
+    schema: z.object({})
+  }
+);
+var gitUnstagedFilesTool = tool(
+  async () => {
+    try {
+      console.log(`  \u{1F4DD} Agent is listing unstaged files`);
+      const { stdout } = await execa2("git", ["diff", "--name-status"], { reject: false });
+      return stdout || "No unstaged changes";
+    } catch (error) {
+      return `Error getting unstaged files: ${error.message}`;
+    }
+  },
+  {
+    name: "git_unstaged_files",
+    description: "List all unstaged modified files.",
+    schema: z.object({})
+  }
+);
+var gitUntrackedFilesTool = tool(
+  async () => {
+    try {
+      console.log(`  \u2753 Agent is listing untracked files`);
+      const { stdout } = await execa2("git", ["ls-files", "--others", "--exclude-standard"], { reject: false });
+      return stdout || "No untracked files";
+    } catch (error) {
+      return `Error getting untracked files: ${error.message}`;
+    }
+  },
+  {
+    name: "git_untracked_files",
+    description: "List all untracked files (files not yet added to git).",
+    schema: z.object({})
+  }
+);
+var gitShowFileDiffTool = tool(
+  async ({ filePath }) => {
+    try {
+      console.log(`  \u{1F50E} Agent is viewing diff for: ${filePath}`);
+      const { stdout } = await execa2("git", ["diff", "--cached", filePath], { reject: false });
+      return stdout || "No changes in this file";
+    } catch (error) {
+      return `Error getting file diff: ${error.message}`;
+    }
+  },
+  {
+    name: "git_show_file_diff",
+    description: "Show the detailed diff for a specific staged file.",
+    schema: z.object({
+      filePath: z.string().describe("Path to the file to show diff for")
+    })
+  }
+);
+var tools = [
+  readFileTool,
+  listDirTool,
+  gitCommitHistoryTool,
+  gitStagedFilesTool,
+  gitUnstagedFilesTool,
+  gitUntrackedFilesTool,
+  gitShowFileDiffTool
+];
+
+// src/agent.ts
+var app = null;
+function getApp() {
+  if (app) return app;
+  const model = new ChatAnthropic({
+    model: "claude-sonnet-4-5-20250929",
+    temperature: 0,
+    // It will automatically look for ANTHROPIC_API_KEY in process.env if not provided,
+    // but explicit assignment ensures it picks up dynamic changes if any.
+    apiKey: process.env.ANTHROPIC_API_KEY
+  }).bindTools(tools);
+  const toolNode = new ToolNode(tools);
+  async function agent(state) {
+    const { messages } = state;
+    const result = await model.invoke(messages);
+    return { messages: [result] };
+  }
+  function shouldContinue(state) {
+    const lastMessage = state.messages[state.messages.length - 1];
+    if (lastMessage.additional_kwargs.tool_calls || lastMessage.tool_calls?.length > 0) {
+      return "tools";
+    }
+    return "__end__";
+  }
+  const workflow = new StateGraph(MessagesAnnotation).addNode("agent", agent).addNode("tools", toolNode).addEdge("__start__", "agent").addConditionalEdges("agent", shouldContinue).addEdge("tools", "agent");
+  app = workflow.compile();
+  return app;
+}
+async function generateCommitMessage(diff, preferences) {
+  const conventionalGuide = preferences.useConventionalCommits ? "Use conventional commit format with prefixes like feat:, fix:, chore:, docs:, style:, refactor:, test:, etc." : "Do NOT use conventional commit prefixes. Write natural commit messages.";
+  const styleGuide = preferences.commitMessageStyle === "descriptive" ? 'Be descriptive and detailed. Explain the "why" behind changes when relevant. Multi-line messages are encouraged.' : "Be concise and to the point. Keep it short, ideally one line.";
+  const systemPrompt = `You are an expert developer. Your task is to generate a commit message for the provided git diff.
+
+Available Tools (use SPARINGLY - only when absolutely necessary):
+- git_commit_history: Check last 3-5 commits to understand conventions (use ONLY if diff is ambiguous)
+- git_staged_files: See list of staged files (use ONLY if you need to understand scope)
+- read_file: Read a file (ONLY if diff references unclear code - read MAX 1-2 files, prefer small files)
+- list_dir: List directory contents (RARELY needed)
+
+EFFICIENCY RULES - CRITICAL:
+1. The diff contains ALL the information you need in 90% of cases. START by analyzing it thoroughly.
+2. DO NOT automatically call tools. Only use them if the diff is genuinely unclear.
+3. If using read_file, read ONLY the specific function/class mentioned, not entire files.
+4. NEVER read more than 2 files total.
+5. If checking commit history, limit to 3-5 recent commits maximum.
+6. DO NOT use list_dir unless absolutely critical to understand project structure.
+
+Commit Message Rules:
+1. ${conventionalGuide}
+2. ${styleGuide}
+3. Focus on WHAT changed and WHY (if clear from diff).
+4. OUTPUT FORMAT: Your response must be ONLY the commit message. No explanations, no "Here is...", no analysis.
+5. Do NOT use markdown code blocks or formatting.
+6. If multi-line, use proper git commit format (subject line, blank line, body).
+
+CRITICAL: Your ENTIRE response should be the commit message itself, nothing else. No preamble, no explanation.
+
+REMEMBER: The diff is your primary source. Tools are for edge cases only.
+`;
+  const messages = [
+    new SystemMessage(systemPrompt),
+    new HumanMessage(`Generate a commit message for this diff:
+
+${diff}`)
+  ];
+  const graph = getApp();
+  const result = await graph.invoke({ messages });
+  const lastMsg = result.messages[result.messages.length - 1];
+  let content = lastMsg.content;
+  content = content.trim();
+  const patterns = [
+    /^(?:Here is|Here's|Based on|Looking at|This is|The commit message is|Commit message).*?:\s*/i,
+    /^```[\w]*\n?/,
+    // Remove opening markdown code blocks
+    /\n?```$/
+    // Remove closing markdown code blocks
+  ];
+  for (const pattern of patterns) {
+    content = content.replace(pattern, "");
+  }
+  const lines = content.split("\n");
+  if (lines.length > 3 && preferences.useConventionalCommits) {
+    const commitPrefixes = ["feat:", "fix:", "chore:", "docs:", "style:", "refactor:", "test:", "perf:", "ci:", "build:", "revert:"];
+    const commitLineIndex = lines.findIndex(
+      (line) => commitPrefixes.some((prefix) => line.trim().toLowerCase().startsWith(prefix))
+    );
+    if (commitLineIndex > 0) {
+      content = lines.slice(commitLineIndex).join("\n").trim();
+    }
+  }
+  return content.trim();
+}
+
+// src/index.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { readFile as readFile2, writeFile } from "fs/promises";
+var CONFIG_PATH = join2(homedir(), ".commit-cli.json");
+async function getStoredKey() {
+  try {
+    const data = await readFile2(CONFIG_PATH, "utf-8");
+    return JSON.parse(data).ANTHROPIC_API_KEY;
+  } catch {
+    return null;
+  }
+}
+async function storeKey(key) {
+  try {
+    await writeFile(CONFIG_PATH, JSON.stringify({ ANTHROPIC_API_KEY: key }), { mode: 384 });
+  } catch (err) {
+  }
+}
+async function getStoredPreferences() {
+  try {
+    const data = await readFile2(CONFIG_PATH, "utf-8");
+    const config = JSON.parse(data);
+    return config.preferences || null;
+  } catch {
+    return null;
+  }
+}
+async function storePreferences(prefs) {
+  try {
+    let config = {};
+    try {
+      const data = await readFile2(CONFIG_PATH, "utf-8");
+      config = JSON.parse(data);
+    } catch {
+    }
+    config.preferences = prefs;
+    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+  } catch (err) {
+  }
+}
+async function main() {
+  intro(import_picocolors.default.bgBlue(import_picocolors.default.white(" commit-cli ")));
+  let apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    apiKey = await getStoredKey() || void 0;
+  }
+  if (!apiKey) {
+    const key = await text({
+      message: "Enter your Anthropic API Key (sk-...):",
+      placeholder: "sk-ant-api...",
+      validate: (value) => {
+        if (!value) return "API Key is required";
+        if (!value.startsWith("sk-")) return "Invalid API Key format (should start with sk-)";
+      }
+    });
+    if (isCancel(key)) {
+      cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    apiKey = key;
+    await storeKey(apiKey);
+  }
+  process.env.ANTHROPIC_API_KEY = apiKey;
+  const isRepo = await isGitRepository();
+  if (!isRepo) {
+    cancel("Current directory is not a git repository.");
+    process.exit(1);
+  }
+  let preferences = await getStoredPreferences();
+  if (!preferences) {
+    note("Let's set up your commit message preferences (one-time setup)", "First Time Setup");
+    const useConventional = await confirm({
+      message: "Use conventional commit prefixes (feat:, fix:, chore:, etc.)?",
+      initialValue: true
+    });
+    if (isCancel(useConventional)) {
+      cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const styleChoice = await confirm({
+      message: "Prefer descriptive commit messages?",
+      active: "Descriptive (detailed explanations)",
+      inactive: "Concise (short and to the point)",
+      initialValue: false
+    });
+    if (isCancel(styleChoice)) {
+      cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    preferences = {
+      useConventionalCommits: useConventional,
+      commitMessageStyle: styleChoice ? "descriptive" : "concise"
+    };
+    await storePreferences(preferences);
+    note(`Preferences saved! You can change these by editing ${CONFIG_PATH}`, "Setup Complete");
+  }
+  const s = spinner();
+  s.start("Analyzing staged changes...");
+  const diff = await getStagedDiff();
+  if (!diff) {
+    s.stop("No staged changes found.");
+    cancel('Please stage your changes using "git add" first.');
+    process.exit(0);
+  }
+  s.stop("Changes detected.");
+  let commitMessage = "";
+  let confirmed = false;
+  while (!confirmed) {
+    s.start("Generating commit message (Agent is exploring)...");
+    try {
+      commitMessage = await generateCommitMessage(diff, preferences);
+    } catch (error) {
+      s.stop("Generation failed.");
+      cancel(`Error: ${error.message}`);
+      return;
+    }
+    s.stop("Message generated.");
+    const maxWidth = 80;
+    const lines = commitMessage.split("\n");
+    const wrappedLines = [];
+    for (const line of lines) {
+      if (line.length <= maxWidth) {
+        wrappedLines.push(line);
+      } else {
+        const words = line.split(" ");
+        let currentLine = "";
+        for (const word of words) {
+          if ((currentLine + " " + word).trim().length <= maxWidth) {
+            currentLine = currentLine ? currentLine + " " + word : word;
+          } else {
+            if (currentLine) wrappedLines.push(currentLine);
+            currentLine = word;
+          }
+        }
+        if (currentLine) wrappedLines.push(currentLine);
+      }
+    }
+    const formattedMessage = wrappedLines.map((line) => import_picocolors.default.cyan(line)).join("\n");
+    note(formattedMessage, import_picocolors.default.bold("Proposed Commit Message"));
+    const action = await confirm({
+      message: "Do you want to use this message?",
+      active: "Yes, commit",
+      inactive: "No, regenerate or cancel"
+    });
+    if (isCancel(action)) {
+      cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    if (action) {
+      confirmed = true;
+    } else {
+      const nextStep = await confirm({
+        message: "Try again?",
+        active: "Regenerate",
+        inactive: "Cancel"
+      });
+      if (!nextStep || isCancel(nextStep)) {
+        cancel("Operation cancelled.");
+        process.exit(0);
+      }
+    }
+  }
+  s.start("Committing...");
+  await commit(commitMessage);
+  s.stop("Committed!");
+  const shouldPush = await confirm({
+    message: "Do you want to push changes now?"
+  });
+  if (isCancel(shouldPush)) {
+    outro(`Changes committed but NOT pushed.`);
+    process.exit(0);
+  }
+  if (shouldPush) {
+    s.start("Pushing...");
+    try {
+      await push();
+      s.stop("Pushed!");
+      outro("Successfully committed and pushed! \u{1F680}");
+    } catch (error) {
+      s.stop("Push failed.");
+      cancel(`Error pushing: ${error.message}`);
+    }
+  } else {
+    outro("Changes committed locally. \u{1F44D}");
+  }
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "commit-agent-cli",
+    "version": "0.1.0",
+    "description": "AI-powered git commit CLI using LangGraph and Claude 4.5",
+    "main": "dist/index.js",
+    "types": "./dist/index.d.ts",
+    "type": "module",
+    "files": [
+        "dist"
+    ],
+    "bin": {
+        "commit": "./dist/index.js"
+    },
+    "scripts": {
+        "build": "tsup src/index.ts --format esm --dts --clean",
+        "start": "node dist/index.js",
+        "dev": "tsup src/index.ts --watch --onSuccess \"node dist/index.js\"",
+        "lint": "eslint src/**",
+        "format": "prettier --write .",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "git",
+        "commit",
+        "ai",
+        "cli",
+        "claude",
+        "langgraph"
+    ],
+    "author": "Commit CLI Contributor",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/sunggyeol/commit-agent-cli.git"
+    },
+    "license": "MIT",
+    "dependencies": {
+        "@ai-sdk/anthropic": "^0.0.39",
+        "@clack/prompts": "^0.7.0",
+        "@langchain/anthropic": "^0.3.0",
+        "@langchain/core": "^0.3.0",
+        "@langchain/langgraph": "^0.2.0",
+        "ai": "^3.3.33",
+        "dotenv": "^16.4.5",
+        "execa": "^9.3.1",
+        "zod": "^3.23.8"
+    },
+    "devDependencies": {
+        "@types/node": "^22.5.4",
+        "tsup": "^8.2.4",
+        "typescript": "^5.5.4"
+    },
+    "engines": {
+        "node": ">=18"
+    }
+}