code-agent-auto-commit 1.2.0 → 1.3.1

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",
@@ -12,6 +13,32 @@ const TYPE_ALIASES = {
     refactoring: "refactor",
     refector: "refactor",
 };
+const MINIMAX_MODEL_ALIASES = {
+    "minimax-m2.5": "MiniMax-M2.5",
+    "minimax-m2.5-highspeed": "MiniMax-M2.5-highspeed",
+    "minimax-m2.1": "MiniMax-M2.1",
+    "minimax-m2.1-highspeed": "MiniMax-M2.1-highspeed",
+    "minimax-m2": "MiniMax-M2",
+    "minimax-text-01": "MiniMax-Text-01",
+    "text-01": "MiniMax-Text-01",
+};
+function normalizeProviderModel(provider, model) {
+    const trimmed = model.trim();
+    const raw = trimmed.includes("/") ? trimmed.slice(trimmed.lastIndexOf("/") + 1) : trimmed;
+    if (provider !== "minimax") {
+        return raw;
+    }
+    return MINIMAX_MODEL_ALIASES[raw.toLowerCase()] ?? raw;
+}
+function minimaxFallbackModel(model) {
+    return model === "MiniMax-Text-01" ? undefined : "MiniMax-Text-01";
+}
+function isUnknownModelError(status, body) {
+    if (status < 400 || status >= 500) {
+        return false;
+    }
+    return /unknown\s+model|invalid\s+model|model.*not\s+found|does\s+not\s+exist|not\s+supported/i.test(body);
+}
 function normalizeCommitType(raw) {
     const value = raw.trim().toLowerCase();
     if (VALID_TYPES.has(value)) {
@@ -111,7 +138,29 @@ function buildUserPrompt(summary, maxLength) {
         summary.patch || "(none)",
     ].join("\n");
 }
-async function generateOpenAiStyleMessage(provider, model, summary, maxLength, signal) {
+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(providerName, provider, model, summary, maxLength, signal) {
     const apiKey = getApiKey(provider);
     const headers = {
         "Content-Type": "application/json",
@@ -120,42 +169,64 @@ async function generateOpenAiStyleMessage(provider, model, summary, maxLength, s
     if (apiKey) {
         headers.Authorization = `Bearer ${apiKey}`;
     }
-    const response = await fetch(`${provider.baseUrl.replace(/\/$/, "")}/chat/completions`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-            model,
-            temperature: 0.2,
-            messages: [
-                {
-                    role: "system",
-                    content: "You generate exactly one conventional commit message. Format: '<type>(<scope>): <description>'. Scope is optional. Allowed types: feat, fix, refactor, docs, style, test, chore, perf, ci, build. Description must be imperative, lowercase, no period. Describe the actual change, not just 'update <file>'. No quotes. No code block.",
-                },
-                {
-                    role: "user",
-                    content: buildUserPrompt(summary, maxLength),
-                },
-            ],
-        }),
-        signal,
-    });
-    if (!response.ok) {
-        return { content: undefined, usage: undefined };
+    async function requestModel(modelName) {
+        const response = await fetch(`${provider.baseUrl.replace(/\/$/, "")}/chat/completions`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                model: modelName,
+                temperature: 0.2,
+                messages: [
+                    {
+                        role: "system",
+                        content: "You generate exactly one conventional commit message. Format: '<type>(<scope>): <description>'. Scope is optional. Allowed types: feat, fix, refactor, docs, style, test, chore, perf, ci, build. Description must be imperative, lowercase, no period. Describe the actual change, not just 'update <file>'. No quotes. No code block.",
+                    },
+                    {
+                        role: "user",
+                        content: buildUserPrompt(summary, maxLength),
+                    },
+                ],
+            }),
+            signal,
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            return { ok: false, status: response.status, body };
+        }
+        const payload = (await response.json());
+        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, content: payload.choices?.[0]?.message?.content, usage };
     }
-    const payload = (await response.json());
-    const usage = payload.usage
-        ? {
-            promptTokens: payload.usage.prompt_tokens ?? 0,
-            completionTokens: payload.usage.completion_tokens ?? 0,
-            totalTokens: payload.usage.total_tokens ?? 0,
+    const first = await requestModel(model);
+    if (first.ok) {
+        return { content: first.content, usage: first.usage };
+    }
+    if (providerName === "minimax" && isUnknownModelError(first.status, first.body)) {
+        const fallback = minimaxFallbackModel(model);
+        if (fallback) {
+            const retry = await requestModel(fallback);
+            if (retry.ok) {
+                return { content: retry.content, usage: retry.usage };
+            }
+            return {
+                content: undefined,
+                usage: undefined,
+                error: `HTTP ${first.status}: ${first.body.slice(0, 200)} | retry(${fallback}) HTTP ${retry.status}: ${retry.body.slice(0, 120)}`,
+            };
         }
-        : undefined;
-    return { content: payload.choices?.[0]?.message?.content, usage };
+    }
+    return { content: undefined, usage: undefined, error: `HTTP ${first.status}: ${first.body.slice(0, 200)}` };
 }
 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 +252,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,33 +267,135 @@ 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 resolvedModel = normalizeProviderModel(provider, model);
     const providerConfig = ai.providers[provider];
-    if (!providerConfig) {
-        return empty;
-    }
     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);
+            result = await generateOpenAiStyleMessage(provider, providerConfig, resolvedModel, summary, maxLength, controller.signal);
         }
         else {
-            result = await generateAnthropicStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
+            result = await generateAnthropicStyleMessage(providerConfig, resolvedModel, 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 resolvedModel = normalizeProviderModel(provider, model);
+    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 ?? {}),
+            };
+            async function requestModel(modelName) {
+                const response = await fetch(`${providerConfig.baseUrl.replace(/\/$/, "")}/chat/completions`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({
+                        model: modelName,
+                        temperature: 0.2,
+                        messages: [{ role: "user", content: userMessage }],
+                    }),
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    const body = await response.text().catch(() => "");
+                    return { ok: false, status: response.status, body };
+                }
+                const payload = (await response.json());
+                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: payload.choices?.[0]?.message?.content ?? "", usage };
+            }
+            const first = await requestModel(resolvedModel);
+            if (first.ok) {
+                return { ok: true, reply: first.reply, usage: first.usage };
+            }
+            if (provider === "minimax" && isUnknownModelError(first.status, first.body)) {
+                const fallback = minimaxFallbackModel(resolvedModel);
+                if (fallback) {
+                    const retry = await requestModel(fallback);
+                    if (retry.ok) {
+                        return { ok: true, reply: retry.reply, usage: retry.usage };
+                    }
+                    return {
+                        ok: false,
+                        error: `HTTP ${first.status}: ${first.body.slice(0, 300)} | retry(${fallback}) HTTP ${retry.status}: ${retry.body.slice(0, 200)}`,
+                    };
+                }
+            }
+            return { ok: false, error: `HTTP ${first.status}: ${first.body.slice(0, 300)}` };
+        }
+        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: resolvedModel,
+                    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.1",
   "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",