code-agent-auto-commit 1.1.0 → 1.2.0

package/README.md

@@ -24,6 +24,14 @@
 pnpm add -g code-agent-auto-commit
 ```
 
+To update to the latest version:
+
+```bash
+pnpm update -g code-agent-auto-commit
+OR:
+pnpm add -g code-agent-auto-commit@latest
+```
+
 Then use the short command:
 
 ```bash

package/dist/cli.js

@@ -89,6 +89,7 @@ Usage:
   cac status [--scope project|global] [--worktree <path>] [--config <path>]
   cac run [--tool opencode|codex|claude|manual] [--worktree <path>] [--config <path>] [--event-json <json>] [--event-stdin]
   cac set-worktree <path> [--config <path>]
+  cac version
 `);
 }
 async function commandInit(flags) {
@@ -239,6 +240,9 @@ async function commandRun(flags, positionals) {
         console.log(`- ${item.hash.slice(0, 12)} ${item.message}`);
     }
     console.log(`Pushed: ${result.pushed ? "yes" : "no"}`);
+    if (result.tokenUsage) {
+        console.log(`AI tokens: ${result.tokenUsage.totalTokens} (prompt: ${result.tokenUsage.promptTokens}, completion: ${result.tokenUsage.completionTokens})`);
+    }
 }
 async function main() {
     const argv = process.argv.slice(2);
@@ -248,6 +252,11 @@ async function main() {
         printHelp();
         return;
     }
+    if (command === "version" || command === "--version" || command === "-v") {
+        const pkg = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, "..", "package.json"), "utf-8"));
+        console.log(pkg.version);
+        return;
+    }
     if (command === "init") {
         await commandInit(parsed.flags);
         return;

package/dist/core/ai.d.ts

@@ -1,2 +1,2 @@
-import type { AIConfig, CommitSummary } from "../types";
-export declare function generateCommitMessage(ai: AIConfig, summary: CommitSummary, maxLength: number): Promise<string | undefined>;
+import type { AIConfig, AIGenerateResult, CommitSummary } from "../types";
+export declare function generateCommitMessage(ai: AIConfig, summary: CommitSummary, maxLength: number): Promise<AIGenerateResult>;

package/dist/core/ai.js

@@ -1,52 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCommitMessage = generateCommitMessage;
-const DEFAULT_COMMIT_TYPE = "refector";
+const VALID_TYPES = new Set([
+    "feat", "fix", "refactor", "docs", "style", "test",
+    "chore", "perf", "ci", "build", "revert",
+]);
+const TYPE_ALIASES = {
+    feature: "feat",
+    bugfix: "fix",
+    hotfix: "fix",
+    refactoring: "refactor",
+    refector: "refactor",
+};
 function normalizeCommitType(raw) {
     const value = raw.trim().toLowerCase();
-    if (value === "feat" || value === "feature") {
-        return "feat";
-    }
-    if (value === "fix" || value === "bugfix" || value === "hotfix") {
-        return "fix";
-    }
-    if (value === "refector"
-        || value === "refactor"
-        || value === "refactoring"
-        || value === "chore"
-        || value === "docs"
-        || value === "style"
-        || value === "test"
-        || value === "perf"
-        || value === "build"
-        || value === "ci"
-        || value === "revert") {
-        return "refector";
-    }
-    return undefined;
+    if (VALID_TYPES.has(value)) {
+        return value;
+    }
+    return TYPE_ALIASES[value] ?? undefined;
 }
 function formatTypedMessage(raw, maxLength) {
-    const conventional = raw.match(/^([a-zA-Z-]+)(?:\([^)]*\))?\s*:\s*(.+)$/);
-    const shorthand = raw.match(/^(feat|feature|fix|bugfix|hotfix|refactor|refector)\b[\s:-]+(.+)$/i);
-    const detectedType = normalizeCommitType(conventional?.[1] ?? shorthand?.[1] ?? "");
-    const type = detectedType ?? DEFAULT_COMMIT_TYPE;
-    const subjectCandidate = (conventional?.[2] ?? shorthand?.[2] ?? raw)
-        .replace(/^['"`]+|['"`]+$/g, "")
-        .replace(/^[-:]+/, "")
-        .trim();
-    if (subjectCandidate.length === 0) {
+    const conventional = raw.match(/^([a-zA-Z-]+)(\([^)]*\))?\s*:\s*(.+)$/);
+    if (conventional) {
+        const type = normalizeCommitType(conventional[1]) ?? "chore";
+        const scope = conventional[2] ?? "";
+        const subject = conventional[3]
+            .replace(/^['"`]+|['"`]+$/g, "")
+            .replace(/^[-:]+/, "")
+            .trim();
+        if (subject.length === 0)
+            return "";
+        const full = `${type}${scope}: ${subject}`;
+        if (full.length <= maxLength)
+            return full;
+        const prefix = `${type}${scope}: `;
+        const available = maxLength - prefix.length;
+        if (available <= 1)
+            return prefix.trimEnd().slice(0, maxLength);
+        return `${prefix}${subject.slice(0, available - 1).trimEnd()}…`;
+    }
+    const subject = raw.replace(/^['"`]+|['"`]+$/g, "").trim();
+    if (subject.length === 0)
         return "";
-    }
-    const prefix = `${type}: `;
-    const full = `${prefix}${subjectCandidate}`;
-    if (full.length <= maxLength) {
+    const prefix = "chore: ";
+    const full = `${prefix}${subject}`;
+    if (full.length <= maxLength)
         return full;
-    }
     const available = maxLength - prefix.length;
-    if (available <= 1) {
+    if (available <= 1)
         return prefix.trimEnd().slice(0, maxLength);
-    }
-    return `${prefix}${subjectCandidate.slice(0, available - 1).trimEnd()}…`;
+    return `${prefix}${subject.slice(0, available - 1).trimEnd()}…`;
 }
 function normalizeMessage(raw, maxLength) {
     const withoutThinking = raw
@@ -137,15 +140,22 @@ async function generateOpenAiStyleMessage(provider, model, summary, maxLength, s
         signal,
     });
     if (!response.ok) {
-        return undefined;
+        return { content: undefined, usage: undefined };
     }
     const payload = (await response.json());
-    return payload.choices?.[0]?.message?.content;
+    const usage = payload.usage
+        ? {
+            promptTokens: payload.usage.prompt_tokens ?? 0,
+            completionTokens: payload.usage.completion_tokens ?? 0,
+            totalTokens: payload.usage.total_tokens ?? 0,
+        }
+        : undefined;
+    return { content: payload.choices?.[0]?.message?.content, usage };
 }
 async function generateAnthropicStyleMessage(provider, model, summary, maxLength, signal) {
     const apiKey = getApiKey(provider);
     if (!apiKey) {
-        return undefined;
+        return { content: undefined, usage: undefined };
     }
     const headers = {
         "Content-Type": "application/json",
@@ -171,39 +181,47 @@ async function generateAnthropicStyleMessage(provider, model, summary, maxLength
         signal,
     });
     if (!response.ok) {
-        return undefined;
+        return { content: undefined, usage: undefined };
     }
     const payload = (await response.json());
     const firstText = payload.content?.find((item) => item.type === "text")?.text;
-    return firstText;
+    const usage = payload.usage
+        ? {
+            promptTokens: payload.usage.input_tokens ?? 0,
+            completionTokens: payload.usage.output_tokens ?? 0,
+            totalTokens: (payload.usage.input_tokens ?? 0) + (payload.usage.output_tokens ?? 0),
+        }
+        : undefined;
+    return { content: firstText, usage };
 }
 async function generateCommitMessage(ai, summary, maxLength) {
+    const empty = { message: undefined, usage: undefined };
     if (!ai.enabled) {
-        return undefined;
+        return empty;
     }
     const { provider, model } = splitModelRef(ai.model, ai.defaultProvider);
     if (!provider || !model) {
-        return undefined;
+        return empty;
     }
     const providerConfig = ai.providers[provider];
     if (!providerConfig) {
-        return undefined;
+        return empty;
     }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), ai.timeoutMs);
     try {
-        let content;
+        let result;
         if (providerConfig.api === "openai-completions") {
-            content = await generateOpenAiStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
+            result = await generateOpenAiStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
         }
         else {
-            content = await generateAnthropicStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
+            result = await generateAnthropicStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
         }
-        const normalized = normalizeMessage(content ?? "", maxLength);
-        return normalized || undefined;
+        const normalized = normalizeMessage(result.content ?? "", maxLength);
+        return { message: normalized || undefined, usage: result.usage };
     }
     catch {
-        return undefined;
+        return empty;
     }
     finally {
         clearTimeout(timeout);

package/dist/core/run.js

@@ -17,10 +17,11 @@ function normalizeFallbackType(prefix) {
     if (/(^|[^a-z])(fix|bugfix|hotfix)([^a-z]|$)/.test(value)) {
         return "fix";
     }
-    if (/(^|[^a-z])(refector|refactor|chore|docs|style|test|perf|build|ci|revert)([^a-z]|$)/.test(value)) {
-        return "refector";
+    if (/(^|[^a-z])(refactor|chore|docs|style|test|perf|build|ci|revert)([^a-z]|$)/.test(value)) {
+        const match = value.match(/(refactor|chore|docs|style|test|perf|build|ci|revert)/);
+        return match ? match[1] : "chore";
     }
-    return "refector";
+    return "chore";
 }
 function fallbackSingleMessage(prefix, count) {
     const suffix = count === 1 ? "file" : "files";
@@ -59,14 +60,14 @@ function filterFiles(files, include, exclude) {
 }
 async function buildMessage(prefix, maxLength, aiConfig, stagedPath, fallback, worktree) {
     const summary = (0, git_1.getStagedSummary)(worktree, stagedPath);
-    const generated = await (0, ai_1.generateCommitMessage)(aiConfig, summary, maxLength);
-    if (generated) {
-        return generated;
+    const result = await (0, ai_1.generateCommitMessage)(aiConfig, summary, maxLength);
+    if (result.message) {
+        return { message: result.message, usage: result.usage };
     }
-    if (fallback.length <= maxLength) {
-        return fallback;
-    }
-    return `${normalizeFallbackType(prefix)}: update changes`;
+    const msg = fallback.length <= maxLength
+        ? fallback
+        : `${normalizeFallbackType(prefix)}: update changes`;
+    return { message: msg, usage: result.usage };
 }
 async function runAutoCommit(context, configOptions) {
     const { config } = (0, config_1.loadConfig)(configOptions);
@@ -92,6 +93,14 @@ async function runAutoCommit(context, configOptions) {
         };
     }
     const commits = [];
+    const totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    function addUsage(usage) {
+        if (!usage)
+            return;
+        totalUsage.promptTokens += usage.promptTokens;
+        totalUsage.completionTokens += usage.completionTokens;
+        totalUsage.totalTokens += usage.totalTokens;
+    }
     if (config.commit.mode === "single") {
         for (const file of changed) {
             (0, git_1.stagePath)(worktree, file.path);
@@ -106,11 +115,12 @@ async function runAutoCommit(context, configOptions) {
             };
         }
         const fallback = fallbackSingleMessage(config.commit.fallbackPrefix, changed.length);
-        const message = await buildMessage(config.commit.fallbackPrefix, config.commit.maxMessageLength, config.ai, undefined, fallback, worktree);
-        const hash = (0, git_1.commit)(worktree, message);
+        const result = await buildMessage(config.commit.fallbackPrefix, config.commit.maxMessageLength, config.ai, undefined, fallback, worktree);
+        addUsage(result.usage);
+        const hash = (0, git_1.commit)(worktree, result.message);
         commits.push({
             hash,
-            message,
+            message: result.message,
             files: changed.map((item) => item.path),
         });
     }
@@ -124,11 +134,12 @@ async function runAutoCommit(context, configOptions) {
                 continue;
             }
             const fallback = fallbackPerFileMessage(config.commit.fallbackPrefix, file);
-            const message = await buildMessage(config.commit.fallbackPrefix, config.commit.maxMessageLength, config.ai, file.path, fallback, worktree);
-            const hash = (0, git_1.commit)(worktree, message);
+            const result = await buildMessage(config.commit.fallbackPrefix, config.commit.maxMessageLength, config.ai, file.path, fallback, worktree);
+            addUsage(result.usage);
+            const hash = (0, git_1.commit)(worktree, result.message);
             commits.push({
                 hash,
-                message,
+                message: result.message,
                 files: [file.path],
             });
         }
@@ -139,10 +150,12 @@ async function runAutoCommit(context, configOptions) {
         (0, git_1.push)(worktree, config.push.remote, branch, config.push.provider);
         pushed = true;
     }
+    const hasUsage = totalUsage.totalTokens > 0;
     return {
         skipped: false,
         worktree,
         committed: commits,
         pushed,
+        tokenUsage: hasUsage ? totalUsage : undefined,
     };
 }

package/dist/types.d.ts

@@ -57,12 +57,22 @@ export interface CommitRecord {
     message: string;
     files: string[];
 }
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+export interface AIGenerateResult {
+    message: string | undefined;
+    usage: TokenUsage | undefined;
+}
 export interface RunResult {
     skipped: boolean;
     reason?: string;
     worktree: string;
     committed: CommitRecord[];
     pushed: boolean;
+    tokenUsage?: TokenUsage;
 }
 export interface RunContext {
     tool: ToolName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-agent-auto-commit",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "CAC provides configurable AI auto-commit(using your git account) for OpenCode, Claude Code, Codex, and other AI code agents",
   "license": "MIT",
   "type": "commonjs",