code-agent-auto-commit 1.1.1 → 1.3.0

package/README.md

@@ -21,13 +21,15 @@
 ## Installation
 
 ```bash
-pnpm add -g code-agent-auto-commit
+pnpm add -g code-agent-auto-commit@latest
 ```
 
 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:

package/dist/cli.js

@@ -9,6 +9,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const claude_1 = require("./adapters/claude");
 const codex_1 = require("./adapters/codex");
 const opencode_1 = require("./adapters/opencode");
+const ai_1 = require("./core/ai");
 const config_1 = require("./core/config");
 const fs_1 = require("./core/fs");
 const run_1 = require("./core/run");
@@ -89,6 +90,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 ai <message> [--config <path>]
   cac version
 `);
 }
@@ -240,6 +242,40 @@ 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})`);
+    }
+    if (result.aiWarning) {
+        console.warn(`\nWarning: AI commit message failed — ${result.aiWarning}`);
+        console.warn(`Using fallback prefix instead. Run "cac ai hello" to test your AI config.`);
+    }
+}
+async function commandAI(flags, positionals) {
+    const message = positionals.join(" ").trim();
+    if (!message) {
+        console.error(`Usage: cac ai <message>`);
+        console.error(`Example: cac ai "hello, are you there?"`);
+        process.exitCode = 1;
+        return;
+    }
+    const worktree = node_path_1.default.resolve(getStringFlag(flags, "worktree") ?? process.cwd());
+    const explicitConfig = getStringFlag(flags, "config");
+    const loaded = (0, config_1.loadConfig)({ explicitPath: explicitConfig, worktree });
+    console.log(`Provider: ${loaded.config.ai.defaultProvider}`);
+    console.log(`Model: ${loaded.config.ai.model}`);
+    console.log(`Sending: "${message}"`);
+    console.log();
+    const result = await (0, ai_1.testAI)(loaded.config.ai, message);
+    if (!result.ok) {
+        console.error(`AI test failed: ${result.error}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`Reply: ${result.reply}`);
+    if (result.usage) {
+        console.log(`Tokens: ${result.usage.totalTokens} (prompt: ${result.usage.promptTokens}, completion: ${result.usage.completionTokens})`);
+    }
+    console.log(`\nAI is configured correctly.`);
 }
 async function main() {
     const argv = process.argv.slice(2);
@@ -278,6 +314,10 @@ async function main() {
         await commandRun(parsed.flags, parsed.positionals);
         return;
     }
+    if (command === "ai") {
+        await commandAI(parsed.flags, parsed.positionals);
+        return;
+    }
     throw new Error(`Unknown command: ${command}`);
 }
 main().catch((error) => {

package/dist/core/ai.d.ts

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

package/dist/core/ai.js

@@ -1,52 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCommitMessage = generateCommitMessage;
-const DEFAULT_COMMIT_TYPE = "refector";
+exports.testAI = testAI;
+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";
+    if (VALID_TYPES.has(value)) {
+        return value;
     }
-    return undefined;
+    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) {
-        return "";
+    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 prefix = `${type}: `;
-    const full = `${prefix}${subjectCandidate}`;
-    if (full.length <= maxLength) {
+    const subject = raw.replace(/^['"`]+|['"`]+$/g, "").trim();
+    if (subject.length === 0)
+        return "";
+    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
@@ -108,6 +112,28 @@ function buildUserPrompt(summary, maxLength) {
         summary.patch || "(none)",
     ].join("\n");
 }
+function validateAIConfig(ai) {
+    if (!ai.enabled) {
+        return "ai.enabled is false";
+    }
+    const { provider, model } = splitModelRef(ai.model, ai.defaultProvider);
+    if (!provider || !model) {
+        return `invalid ai.model "${ai.model}" — expected "provider/model" format`;
+    }
+    const providerConfig = ai.providers[provider];
+    if (!providerConfig) {
+        return `provider "${provider}" not found in ai.providers (available: ${Object.keys(ai.providers).join(", ") || "none"})`;
+    }
+    const apiKey = getApiKey(providerConfig);
+    if (!apiKey) {
+        const envName = providerConfig.apiKeyEnv;
+        if (envName) {
+            return `API key not found — env var "${envName}" is not set. Run: export ${envName}='your-key'`;
+        }
+        return `no API key configured for provider "${provider}" — set apiKeyEnv or apiKey in config`;
+    }
+    return undefined;
+}
 async function generateOpenAiStyleMessage(provider, model, summary, maxLength, signal) {
     const apiKey = getApiKey(provider);
     const headers = {
@@ -137,15 +163,23 @@ async function generateOpenAiStyleMessage(provider, model, summary, maxLength, s
         signal,
     });
     if (!response.ok) {
-        return undefined;
+        const body = await response.text().catch(() => "");
+        return { content: undefined, usage: undefined, error: `HTTP ${response.status}: ${body.slice(0, 200)}` };
     }
     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, error: "no API key" };
     }
     const headers = {
         "Content-Type": "application/json",
@@ -171,39 +205,125 @@ async function generateAnthropicStyleMessage(provider, model, summary, maxLength
         signal,
     });
     if (!response.ok) {
-        return undefined;
+        const body = await response.text().catch(() => "");
+        return { content: undefined, usage: undefined, error: `HTTP ${response.status}: ${body.slice(0, 200)}` };
     }
     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) {
-    if (!ai.enabled) {
-        return undefined;
+    const configError = validateAIConfig(ai);
+    if (configError) {
+        return { message: undefined, usage: undefined, warning: configError };
     }
     const { provider, model } = splitModelRef(ai.model, ai.defaultProvider);
-    if (!provider || !model) {
-        return undefined;
-    }
     const providerConfig = ai.providers[provider];
-    if (!providerConfig) {
-        return undefined;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), ai.timeoutMs);
+    try {
+        let result;
+        if (providerConfig.api === "openai-completions") {
+            result = await generateOpenAiStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
+        }
+        else {
+            result = await generateAnthropicStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
+        }
+        if (result.error) {
+            return { message: undefined, usage: result.usage, warning: result.error };
+        }
+        const normalized = normalizeMessage(result.content ?? "", maxLength);
+        return { message: normalized || undefined, usage: result.usage };
+    }
+    catch (err) {
+        const msg = err instanceof Error && err.name === "AbortError"
+            ? `AI request timed out after ${ai.timeoutMs}ms`
+            : `AI request failed: ${err instanceof Error ? err.message : String(err)}`;
+        return { message: undefined, usage: undefined, warning: msg };
+    }
+    finally {
+        clearTimeout(timeout);
     }
+}
+async function testAI(ai, userMessage) {
+    const configError = validateAIConfig(ai);
+    if (configError) {
+        return { ok: false, error: configError };
+    }
+    const { provider, model } = splitModelRef(ai.model, ai.defaultProvider);
+    const providerConfig = ai.providers[provider];
+    const apiKey = getApiKey(providerConfig);
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), ai.timeoutMs);
     try {
-        let content;
         if (providerConfig.api === "openai-completions") {
-            content = await generateOpenAiStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
+            const headers = {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+                ...(providerConfig.headers ?? {}),
+            };
+            const response = await fetch(`${providerConfig.baseUrl.replace(/\/$/, "")}/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    model,
+                    temperature: 0.2,
+                    messages: [{ role: "user", content: userMessage }],
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const body = await response.text().catch(() => "");
+                return { ok: false, error: `HTTP ${response.status}: ${body.slice(0, 300)}` };
+            }
+            const payload = (await response.json());
+            const reply = 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 { ok: true, reply, usage };
         }
         else {
-            content = await generateAnthropicStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
+            const headers = {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+                ...(providerConfig.headers ?? {}),
+            };
+            const response = await fetch(`${providerConfig.baseUrl.replace(/\/$/, "")}/messages`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    model,
+                    max_tokens: 256,
+                    messages: [{ role: "user", content: userMessage }],
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const body = await response.text().catch(() => "");
+                return { ok: false, error: `HTTP ${response.status}: ${body.slice(0, 300)}` };
+            }
+            const payload = (await response.json());
+            const reply = payload.content?.find((item) => item.type === "text")?.text ?? "";
+            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 { ok: true, reply, usage };
         }
-        const normalized = normalizeMessage(content ?? "", maxLength);
-        return normalized || undefined;
     }
-    catch {
-        return undefined;
+    catch (err) {
+        const msg = err instanceof Error && err.name === "AbortError"
+            ? `request timed out after ${ai.timeoutMs}ms`
+            : `request failed: ${err instanceof Error ? err.message : String(err)}`;
+        return { ok: false, error: msg };
     }
     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, warning: result.warning };
 }
 async function runAutoCommit(context, configOptions) {
     const { config } = (0, config_1.loadConfig)(configOptions);
@@ -92,6 +93,15 @@ async function runAutoCommit(context, configOptions) {
         };
     }
     const commits = [];
+    const totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    let firstWarning;
+    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 +116,14 @@ 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);
+        if (result.warning && !firstWarning)
+            firstWarning = result.warning;
+        const hash = (0, git_1.commit)(worktree, result.message);
         commits.push({
             hash,
-            message,
+            message: result.message,
             files: changed.map((item) => item.path),
         });
     }
@@ -124,11 +137,14 @@ 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);
+            if (result.warning && !firstWarning)
+                firstWarning = result.warning;
+            const hash = (0, git_1.commit)(worktree, result.message);
             commits.push({
                 hash,
-                message,
+                message: result.message,
                 files: [file.path],
             });
         }
@@ -139,10 +155,13 @@ 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,
+        aiWarning: firstWarning,
     };
 }

package/dist/types.d.ts

@@ -57,12 +57,30 @@ 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;
+    warning?: string;
+}
+export interface AITestResult {
+    ok: boolean;
+    reply?: string;
+    usage?: TokenUsage;
+    error?: string;
+}
 export interface RunResult {
     skipped: boolean;
     reason?: string;
     worktree: string;
     committed: CommitRecord[];
     pushed: boolean;
+    tokenUsage?: TokenUsage;
+    aiWarning?: string;
 }
 export interface RunContext {
     tool: ToolName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-agent-auto-commit",
-  "version": "1.1.1",
+  "version": "1.3.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",