code-agent-auto-commit 1.2.0 → 1.3.0

package/README.md

@@ -21,7 +21,7 @@
 ## Installation
 
 ```bash
-pnpm add -g code-agent-auto-commit
+pnpm add -g code-agent-auto-commit@latest
 ```
 
 To update to the latest version:

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
 `);
 }
@@ -243,6 +245,37 @@ async function commandRun(flags, positionals) {
     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);
@@ -281,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, AIGenerateResult, CommitSummary } from "../types";
+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,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCommitMessage = generateCommitMessage;
+exports.testAI = testAI;
 const VALID_TYPES = new Set([
     "feat", "fix", "refactor", "docs", "style", "test",
     "chore", "perf", "ci", "build", "revert",
@@ -111,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 = {
@@ -140,7 +163,8 @@ async function generateOpenAiStyleMessage(provider, model, summary, maxLength, s
         signal,
     });
     if (!response.ok) {
-        return { content: undefined, usage: 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 usage = payload.usage
@@ -155,7 +179,7 @@ async function generateOpenAiStyleMessage(provider, model, summary, maxLength, s
 async function generateAnthropicStyleMessage(provider, model, summary, maxLength, signal) {
     const apiKey = getApiKey(provider);
     if (!apiKey) {
-        return { content: undefined, usage: undefined };
+        return { content: undefined, usage: undefined, error: "no API key" };
     }
     const headers = {
         "Content-Type": "application/json",
@@ -181,7 +205,8 @@ async function generateAnthropicStyleMessage(provider, model, summary, maxLength
         signal,
     });
     if (!response.ok) {
-        return { content: undefined, usage: 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;
@@ -195,18 +220,12 @@ async function generateAnthropicStyleMessage(provider, model, summary, maxLength
     return { content: firstText, usage };
 }
 async function generateCommitMessage(ai, summary, maxLength) {
-    const empty = { message: undefined, usage: undefined };
-    if (!ai.enabled) {
-        return empty;
+    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 empty;
-    }
     const providerConfig = ai.providers[provider];
-    if (!providerConfig) {
-        return empty;
-    }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), ai.timeoutMs);
     try {
@@ -217,11 +236,94 @@ async function generateCommitMessage(ai, summary, maxLength) {
         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 {
-        return empty;
+    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 {
+        if (providerConfig.api === "openai-completions") {
+            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 {
+            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 };
+        }
+    }
+    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

@@ -67,7 +67,7 @@ async function buildMessage(prefix, maxLength, aiConfig, stagedPath, fallback, w
     const msg = fallback.length <= maxLength
         ? fallback
         : `${normalizeFallbackType(prefix)}: update changes`;
-    return { message: msg, usage: result.usage };
+    return { message: msg, usage: result.usage, warning: result.warning };
 }
 async function runAutoCommit(context, configOptions) {
     const { config } = (0, config_1.loadConfig)(configOptions);
@@ -94,6 +94,7 @@ async function runAutoCommit(context, configOptions) {
     }
     const commits = [];
     const totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    let firstWarning;
     function addUsage(usage) {
         if (!usage)
             return;
@@ -117,6 +118,8 @@ async function runAutoCommit(context, configOptions) {
         const fallback = fallbackSingleMessage(config.commit.fallbackPrefix, changed.length);
         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,
@@ -136,6 +139,8 @@ async function runAutoCommit(context, configOptions) {
             const fallback = fallbackPerFileMessage(config.commit.fallbackPrefix, file);
             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,
@@ -157,5 +162,6 @@ async function runAutoCommit(context, configOptions) {
         committed: commits,
         pushed,
         tokenUsage: hasUsage ? totalUsage : undefined,
+        aiWarning: firstWarning,
     };
 }

package/dist/types.d.ts

@@ -65,6 +65,13 @@ export interface TokenUsage {
 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;
@@ -73,6 +80,7 @@ export interface RunResult {
     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.2.0",
+  "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",