@ksw8954/git-ai-commit 1.1.8 → 1.2.1

package/src/commands/ai.ts

@@ -1,9 +1,10 @@
 import OpenAI from 'openai';
 import { type ChatCompletionCreateParamsNonStreaming } from 'openai/resources/chat/completions';
+import { GoogleGenAI } from '@google/genai';
 import { generateCommitPrompt } from '../prompts/commit';
 import { generateTagPrompt } from '../prompts/tag';
 import { generatePullRequestPrompt } from '../prompts/pr';
-import { SupportedLanguage } from './config';
+import { SupportedLanguage, AIMode } from './config';
 
 export type ReasoningEffort = 'minimal' | 'low' | 'medium' | 'high';
 
@@ -15,6 +16,8 @@ export interface AIServiceConfig {
   reasoningEffort?: ReasoningEffort;
   language?: SupportedLanguage;
   verbose?: boolean;
+  mode?: AIMode;
+  maxCompletionTokens?: number;
 }
 
 export interface CommitGenerationResult {
@@ -36,23 +39,35 @@ export interface PullRequestGenerationResult {
 }
 
 export class AIService {
-  private openai: OpenAI;
+  private openai: OpenAI | null = null;
+  private gemini: GoogleGenAI | null = null;
+  private mode: AIMode;
   private model: string;
   private fallbackModel?: string;
   private reasoningEffort?: ReasoningEffort;
   private language: SupportedLanguage;
   private verbose: boolean;
+  private maxCompletionTokens?: number;
 
   constructor(config: AIServiceConfig) {
-    this.openai = new OpenAI({
-      apiKey: config.apiKey,
-      baseURL: config.baseURL
-    });
-    this.model = config.model || 'zai-org/GLM-4.5-FP8';
+    this.mode = config.mode || 'custom';
+
+    if (this.mode === 'gemini') {
+      this.gemini = new GoogleGenAI({ apiKey: config.apiKey });
+      this.model = config.model || 'gemini-2.0-flash';
+    } else {
+      this.openai = new OpenAI({
+        apiKey: config.apiKey,
+        baseURL: config.baseURL
+      });
+      this.model = config.model || 'zai-org/GLM-4.5-FP8';
+    }
+
     this.fallbackModel = config.fallbackModel;
     this.reasoningEffort = config.reasoningEffort;
     this.language = config.language || 'ko';
     this.verbose = config.verbose ?? true;
+    this.maxCompletionTokens = config.maxCompletionTokens;
   }
 
   private debugLog(...args: unknown[]): void {
@@ -157,10 +172,110 @@ export class AIService {
     return `${seconds}s`;
   }
 
+  private async createGeminiStreamingCompletion(
+    request: ChatCompletionCreateParamsNonStreaming
+  ): Promise<string> {
+    if (!this.gemini) throw new Error('Gemini client not initialized');
+
+    let waitingTimer: ReturnType<typeof setInterval> | null = null;
+    const startTime = Date.now();
+    let frameIndex = 0;
+
+    try {
+      if (this.verbose) {
+        waitingTimer = setInterval(() => {
+          const frame = this.spinnerFrames[frameIndex++ % this.spinnerFrames.length];
+          const elapsed = this.formatElapsed(Date.now() - startTime);
+          process.stdout.write(`\r${frame} Waiting for response... (${elapsed})`);
+        }, 100);
+      }
+
+      const systemMessage = request.messages.find(m => m.role === 'system');
+      const userMessages = request.messages.filter(m => m.role !== 'system');
+      const contents = userMessages.map(m => ({
+        role: m.role === 'assistant' ? 'model' as const : 'user' as const,
+        parts: [{ text: typeof m.content === 'string' ? m.content : '' }]
+      }));
+
+      const maxTokens = (request as unknown as Record<string, unknown>).max_completion_tokens as number | undefined
+        ?? request.max_tokens
+        ?? 3000;
+
+      const stream = await this.gemini.models.generateContentStream({
+        model: this.model,
+        contents,
+        config: {
+          ...(systemMessage ? { systemInstruction: typeof systemMessage.content === 'string' ? systemMessage.content : '' } : {}),
+          maxOutputTokens: maxTokens,
+        }
+      });
+
+      const contentChunks: string[] = [];
+      let chunkCount = 0;
+      let lastChunkUsage: { promptTokenCount?: number; candidatesTokenCount?: number; totalTokenCount?: number } | undefined;
+
+      for await (const chunk of stream) {
+        if (chunk.usageMetadata) {
+          lastChunkUsage = chunk.usageMetadata;
+        }
+
+        const text = chunk.text;
+        if (text) {
+          contentChunks.push(text);
+          chunkCount++;
+
+          if (waitingTimer) {
+            clearInterval(waitingTimer);
+            waitingTimer = null;
+          }
+
+          if (this.verbose) {
+            const frame = this.spinnerFrames[frameIndex++ % this.spinnerFrames.length];
+            const elapsed = this.formatElapsed(Date.now() - startTime);
+            process.stdout.write(`\r${frame} Streaming... (${chunkCount} chunks, ${elapsed})`);
+          }
+        }
+      }
+
+      if (waitingTimer) {
+        clearInterval(waitingTimer);
+        waitingTimer = null;
+      }
+
+      if (this.verbose) {
+        const elapsed = this.formatElapsed(Date.now() - startTime);
+        if (lastChunkUsage) {
+          const prompt = lastChunkUsage.promptTokenCount ?? 0;
+          const response = lastChunkUsage.candidatesTokenCount ?? 0;
+          process.stdout.write(`\r✅ Complete (response: ${response}, prompt: ${prompt} tokens, ${elapsed})\n`);
+        } else {
+          process.stdout.write(`\r✅ Complete (~${chunkCount} chunks, ${elapsed})\n`);
+        }
+      }
+
+      return contentChunks.join('');
+    } catch (error) {
+      if (waitingTimer) {
+        clearInterval(waitingTimer);
+        waitingTimer = null;
+      }
+      if (this.verbose) {
+        process.stdout.write('\n');
+      }
+      throw error;
+    }
+  }
+
   private async createStreamingCompletion(
     request: ChatCompletionCreateParamsNonStreaming,
     attempt = 0
   ): Promise<string> {
+    if (this.mode === 'gemini') {
+      return this.createGeminiStreamingCompletion(request);
+    }
+
+    if (!this.openai) throw new Error('OpenAI client not initialized');
+
     let waitingTimer: ReturnType<typeof setInterval> | null = null;
 
     try {
@@ -353,7 +468,7 @@ export class AIService {
     try {
       this.debugLog('Sending request to AI API...');
       this.debugLog('Model:', this.model);
-      this.debugLog('Base URL:', this.openai.baseURL);
+      this.debugLog('Base URL:', this.openai?.baseURL ?? 'Gemini native');
       
       const customInstructions = extraInstructions && extraInstructions.trim().length > 0
         ? `Git diff will be provided separately in the user message.\n\n## Additional User Instructions\n${extraInstructions.trim()}`
@@ -375,7 +490,7 @@ export class AIService {
             content: `Git diff:\n${diff}`
           }
         ],
-        max_completion_tokens: 3000
+        max_completion_tokens: this.maxCompletionTokens ?? 1000
       });
 
       let finalMessage = content.trim() || null;
@@ -491,7 +606,7 @@ export class AIService {
     try {
       this.debugLog('Sending request to AI API for tag notes...');
       this.debugLog('Model:', this.model);
-      this.debugLog('Base URL:', this.openai.baseURL);
+      this.debugLog('Base URL:', this.openai?.baseURL ?? 'Gemini native');
 
       const customInstructions = extraInstructions && extraInstructions.trim().length > 0
         ? `${extraInstructions.trim()}`
@@ -519,7 +634,7 @@ export class AIService {
             content: userContent
           }
         ],
-        max_completion_tokens: 3000
+        max_completion_tokens: this.maxCompletionTokens ?? 3000
       });
 
       const finalNotes = content.trim() || null;
@@ -553,7 +668,7 @@ export class AIService {
     try {
       this.debugLog('Sending request to AI API for pull request message...');
       this.debugLog('Model:', this.model);
-      this.debugLog('Base URL:', this.openai.baseURL);
+      this.debugLog('Base URL:', this.openai?.baseURL ?? 'Gemini native');
 
       const content = await this.createStreamingCompletion({
         model: this.model,
@@ -572,7 +687,7 @@ export class AIService {
             content: `Git diff between ${baseBranch} and ${compareBranch}:\n${diff}`
           }
         ],
-        max_completion_tokens: 4000
+        max_completion_tokens: this.maxCompletionTokens ?? 4000
       });
 
       const finalMessage = content.trim() || null;

package/src/commands/commit.ts

@@ -2,7 +2,7 @@ import { Command } from "commander";
 import readline from "readline";
 import fs from "fs";
 import path from "path";
-import { spawn } from "child_process";
+import { spawn, execFileSync } from "child_process";
 import { GitService, GitDiffResult } from "./git";
 import { AIService, AIServiceConfig } from "./ai";
 import { ConfigService } from "./config";
@@ -46,6 +46,16 @@ export class CommitCommand {
       .action(this.handleCommit.bind(this));
   }
 
+  private isCommandAvailable(command: string): boolean {
+    const checker = process.platform === "win32" ? "where" : "which";
+    try {
+      execFileSync(checker, [command], { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   private async runPreCommitHook(): Promise<void> {
     // 1. Check for npm pre-commit script
     const packageJsonPath = path.resolve(process.cwd(), "package.json");
@@ -88,43 +98,33 @@ export class CommitCommand {
     // 2. Check for .pre-commit-config.yaml (Python/General pre-commit)
     const preCommitConfigPath = path.resolve(process.cwd(), ".pre-commit-config.yaml");
     if (fs.existsSync(preCommitConfigPath)) {
+      if (!this.isCommandAvailable("pre-commit")) {
+        console.warn("⚠️ .pre-commit-config.yaml found but 'pre-commit' is not installed. Skipping hooks.");
+        return;
+      }
+
       console.log("Found .pre-commit-config.yaml, running pre-commit hooks...");
-      
-      try {
-        await new Promise<void>((resolve, reject) => {
-          const child = spawn("pre-commit", ["run"], {
-            stdio: "inherit",
-            shell: true,
-          });
 
-          child.on("close", (code) => {
-            if (code === 0) {
-              console.log("✅ pre-commit hooks passed");
-              resolve();
-            } else {
-              console.error(`❌ pre-commit hooks failed with code ${code}`);
-              reject(new Error(`pre-commit hooks failed with code ${code}`));
-            }
-          });
+      await new Promise<void>((resolve, reject) => {
+        const child = spawn("pre-commit", ["run"], {
+          stdio: "inherit",
+          shell: true,
+        });
 
-          child.on("error", (err) => {
-            // If pre-commit is not installed/found, we might want to warn instead of fail?
-            // But usually 'error' event on spawn (with shell:true) is rare for command not found (it usually exits with 127).
-            // However, if it fails to spawn, we reject.
-            reject(err);
-          });
+        child.on("close", (code) => {
+          if (code === 0) {
+            console.log("✅ pre-commit hooks passed");
+            resolve();
+          } else {
+            console.error(`❌ pre-commit hooks failed with code ${code}`);
+            reject(new Error(`pre-commit hooks failed with code ${code}`));
+          }
         });
-      } catch (error) {
-        // If the error suggests command not found, we might warn.
-        // But since we use shell:true, 'command not found' usually results in exit code 127, which goes to 'close' event.
-        // So we catch the error from the promise rejection above.
-        const msg = error instanceof Error ? error.message : String(error);
-        if (msg.includes("code 127") || msg.includes("ENOENT")) {
-           console.warn("⚠️ 'pre-commit' command not found, skipping hooks despite configuration file presence.");
-           return;
-        }
-        throw error;
-      }
+
+        child.on("error", (err) => {
+          reject(err);
+        });
+      });
     }
   }
 
@@ -165,6 +165,8 @@ export class CommitCommand {
         reasoningEffort: existingConfig.reasoningEffort,
         language: existingConfig.language,
         verbose: !messageOnly,
+        mode: existingConfig.mode,
+        maxCompletionTokens: existingConfig.maxCompletionTokens,
       };
 
       log("Getting staged changes...");
@@ -210,6 +212,10 @@ export class CommitCommand {
         process.exit(1);
       }
 
+
+      if (existingConfig.coAuthor) {
+        aiResult.message = `${aiResult.message}\n\nCo-authored-by: ${existingConfig.coAuthor}`;
+      }
       if (messageOnly) {
         console.log(aiResult.message);
         await LogService.append({

package/src/commands/completion.ts

@@ -33,14 +33,14 @@ _git_ai_commit() {
     local cur prev words cword
     _init_completion || return
 
-    local commands="commit config pr tag history completion"
+    local commands="commit config pr tag history completion hook"
     
     # Global options
     local global_opts="-v --version -h --help"
 
     # Command-specific options
     local commit_opts="-k --api-key -b --base-url --model -m --message-only -p --push --prompt --no-verify"
-    local config_opts="-s --show -l --language --auto-push --no-auto-push -k --api-key -b --base-url -m --model --fallback-model --reasoning-effort --mode"
+    local config_opts="-s --show -l --language --auto-push --no-auto-push -k --api-key -b --base-url -m --model --fallback-model --reasoning-effort --mode --co-author --no-co-author"
     local pr_opts="--base --compare -k --api-key -b --base-url --model"
     local tag_opts="-k --api-key --base-url -m --model --message -t --base-tag --prompt"
     local history_opts="-l --limit --json --clear"
@@ -71,10 +71,10 @@ _git_ai_commit() {
                     return
                     ;;
                 --mode)
-                    COMPREPLY=( \$(compgen -W "custom openai" -- "\${cur}") )
+                    COMPREPLY=( \$(compgen -W "custom openai gemini" -- "\${cur}") )
                     return
                     ;;
-                -k|--api-key|-b|--base-url|-m|--model)
+                -k|--api-key|-b|--base-url|-m|--model|--co-author)
                     return
                     ;;
             esac
@@ -119,6 +119,9 @@ _git_ai_commit() {
         completion)
             COMPREPLY=( \$(compgen -W "bash zsh" -- "\${cur}") )
             ;;
+        hook)
+            COMPREPLY=( \$(compgen -W "install uninstall status" -- "\${cur}") )
+            ;;
     esac
 }
 
@@ -157,6 +160,7 @@ _git-ai-commit() {
                 'tag:Create an annotated git tag with AI-generated notes'
                 'history:Manage git-ai-commit command history'
                 'completion:Generate shell completion scripts'
+                'hook:Manage prepare-commit-msg git hook'
             )
             _describe -t commands 'git-ai-commit commands' commands
             ;;
@@ -190,7 +194,9 @@ _git-ai-commit() {
                         '--base-url[Persist API base URL]:url:' \\
                         '-m[Persist default AI model]:model:' \\
                         '--model[Persist default AI model]:model:' \\
-                        '--mode[Persist AI mode]:mode:(custom openai)'
+                        '--mode[Persist AI mode]:mode:(custom openai gemini)' \\
+                        '--co-author[Set Co-authored-by trailer for commits]:author:' \\
+                        '--no-co-author[Remove Co-authored-by trailer]'
                     ;;
                 pr)
                     _arguments \\
@@ -236,6 +242,10 @@ _git-ai-commit() {
                     _arguments \\
                         '1:shell:(bash zsh)'
                     ;;
+                hook)
+                    _arguments \\
+                        '1:action:(install uninstall status)'
+                    ;;
             esac
             ;;
     esac

package/src/commands/config.ts

@@ -7,15 +7,19 @@ export type SupportedLanguage = 'ko' | 'en';
 
 export type ReasoningEffort = 'minimal' | 'low' | 'medium' | 'high';
 
+export type AIMode = 'custom' | 'openai' | 'gemini';
+
 export interface EnvironmentConfig {
   apiKey?: string;
   baseURL?: string;
   model?: string;
   fallbackModel?: string;
   reasoningEffort?: ReasoningEffort;
-  mode: 'custom' | 'openai';
+  mode: AIMode;
   language: SupportedLanguage;
   autoPush: boolean;
+  coAuthor?: string | false;
+  maxCompletionTokens?: number;
 }
 
 interface StoredConfig {
@@ -24,15 +28,19 @@ interface StoredConfig {
   model?: string;
   fallbackModel?: string;
   reasoningEffort?: ReasoningEffort | string;
-  mode?: 'custom' | 'openai';
+  mode?: AIMode;
   language?: SupportedLanguage | string;
   autoPush?: boolean;
+  coAuthor?: string | false;
+  maxCompletionTokens?: number;
 }
 
 const DEFAULT_MODEL = 'zai-org/GLM-4.5-FP8';
-const DEFAULT_MODE: 'custom' | 'openai' = 'custom';
+const DEFAULT_MODE: AIMode = 'custom';
 const DEFAULT_LANGUAGE: SupportedLanguage = 'ko';
 const DEFAULT_AUTO_PUSH = false;
+const DEFAULT_CO_AUTHOR = 'git-ai-commit <git-ai-commit@users.noreply.github.com>';
+const CONFIG_SCHEMA_URL = 'https://raw.githubusercontent.com/onaries/git-ai-commit/main/src/schema/config.schema.json';
 
 export class ConfigService {
   private static getConfigFilePath(): string {
@@ -58,7 +66,8 @@ export class ConfigService {
       }
 
       const parsed = JSON.parse(raw);
-      return typeof parsed === 'object' && parsed !== null ? parsed : {};
+      const { $schema, ...config } = typeof parsed === 'object' && parsed !== null ? parsed : {} as Record<string, unknown>;
+      return config as StoredConfig;
     } catch (error) {
       console.warn('Warning: Failed to read configuration file. Falling back to environment variables.');
       return {};
@@ -83,35 +92,42 @@ export class ConfigService {
     return undefined;
   }
 
-  private static normalizeMode(mode?: string): 'custom' | 'openai' {
+  private static normalizeMode(mode?: string): AIMode {
     if (!mode) {
       return DEFAULT_MODE;
     }
 
     const normalized = mode.toLowerCase();
-    return normalized === 'openai' ? 'openai' : 'custom';
+    if (normalized === 'openai') return 'openai';
+    if (normalized === 'gemini') return 'gemini';
+    return 'custom';
   }
 
-  private static resolveEnvConfig(modeOverride?: 'custom' | 'openai'): EnvironmentConfig {
+  private static resolveEnvConfig(modeOverride?: AIMode): EnvironmentConfig {
     const resolvedMode = this.normalizeMode(modeOverride || process.env.AI_MODE);
-    const isOpenAI = resolvedMode === 'openai';
-
-    const apiKey = isOpenAI
-      ? process.env.OPENAI_API_KEY || process.env.AI_API_KEY
-      : process.env.AI_API_KEY || process.env.OPENAI_API_KEY;
 
-    const baseURL = isOpenAI
-      ? process.env.OPENAI_BASE_URL || process.env.AI_BASE_URL
-      : process.env.AI_BASE_URL || process.env.OPENAI_BASE_URL;
-
-    const model = isOpenAI
-      ? process.env.OPENAI_MODEL || process.env.AI_MODEL || DEFAULT_MODEL
-      : process.env.AI_MODEL || process.env.OPENAI_MODEL || DEFAULT_MODEL;
+    let apiKey: string | undefined;
+    let baseURL: string | undefined;
+    let model: string;
+
+    if (resolvedMode === 'gemini') {
+      apiKey = process.env.GEMINI_API_KEY || process.env.AI_API_KEY;
+      baseURL = undefined;
+      model = process.env.AI_MODEL || 'gemini-2.0-flash';
+    } else if (resolvedMode === 'openai') {
+      apiKey = process.env.OPENAI_API_KEY || process.env.AI_API_KEY;
+      baseURL = process.env.OPENAI_BASE_URL || process.env.AI_BASE_URL;
+      model = process.env.OPENAI_MODEL || process.env.AI_MODEL || DEFAULT_MODEL;
+    } else {
+      apiKey = process.env.AI_API_KEY || process.env.OPENAI_API_KEY;
+      baseURL = process.env.AI_BASE_URL || process.env.OPENAI_BASE_URL;
+      model = process.env.AI_MODEL || process.env.OPENAI_MODEL || DEFAULT_MODEL;
+    }
 
     return {
       apiKey: apiKey || undefined,
       baseURL: baseURL || undefined,
-      model: model || DEFAULT_MODEL,
+      model,
       mode: resolvedMode,
       language: DEFAULT_LANGUAGE,
       autoPush: DEFAULT_AUTO_PUSH
@@ -130,7 +146,10 @@ export class ConfigService {
     const reasoningEffort = this.normalizeReasoningEffort(fileConfig.reasoningEffort);
     const language = this.normalizeLanguage(fileConfig.language ?? envConfig.language);
     const autoPush = typeof fileConfig.autoPush === 'boolean' ? fileConfig.autoPush : envConfig.autoPush;
-
+    const coAuthor = fileConfig.coAuthor === false ? false : (fileConfig.coAuthor || DEFAULT_CO_AUTHOR);
+    const maxCompletionTokens = typeof fileConfig.maxCompletionTokens === 'number' && fileConfig.maxCompletionTokens > 0
+      ? fileConfig.maxCompletionTokens
+      : undefined;
     return {
       apiKey,
       baseURL,
@@ -139,7 +158,9 @@ export class ConfigService {
       reasoningEffort,
       mode,
       language,
-      autoPush
+      autoPush,
+      coAuthor,
+      maxCompletionTokens,
     };
   }
 
@@ -176,6 +197,8 @@ export class ConfigService {
       delete next.mode;
     }
 
+    // coAuthor: false means explicitly disabled — persist it so getConfig() sees it
+
     const sanitized = Object.entries(next).reduce<StoredConfig>((acc, [key, value]) => {
       if (value !== undefined) {
         acc[key as keyof StoredConfig] = value as any;
@@ -186,7 +209,7 @@ export class ConfigService {
     }, {});
 
     await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
-    await fsPromises.writeFile(filePath, JSON.stringify(sanitized, null, 2), 'utf-8');
+    await fsPromises.writeFile(filePath, JSON.stringify({ $schema: CONFIG_SCHEMA_URL, ...sanitized }, null, 2), 'utf-8');
   }
 
   static validateConfig(config: { apiKey?: string; language?: string }): void {

package/src/commands/configCommand.ts

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { ConfigService, SupportedLanguage } from './config';
+import { ConfigService, SupportedLanguage, AIMode } from './config';
 
 export interface ConfigOptions {
   show?: boolean;
@@ -10,7 +10,10 @@ export interface ConfigOptions {
   model?: string;
   fallbackModel?: string;
   reasoningEffort?: string;
-  mode?: 'custom' | 'openai';
+  mode?: AIMode;
+  coAuthor?: string;
+  noCoAuthor?: boolean;
+  maxTokens?: string;
 }
 
 export class ConfigCommand {
@@ -28,7 +31,10 @@ export class ConfigCommand {
       .option('-m, --model <model>', 'Persist default AI model')
       .option('--fallback-model <model>', 'Persist fallback model for rate limit (429) retry')
       .option('--reasoning-effort <level>', 'Thinking effort for reasoning models (minimal | low | medium | high)')
-      .option('--mode <mode>', 'Persist AI mode (custom | openai)')
+      .option('--mode <mode>', 'Persist AI mode (custom | openai | gemini)')
+      .option('--co-author <value>', 'Set co-author for commits (e.g. "Name <email>")')
+      .option('--no-co-author', 'Disable co-author')
+      .option('--max-tokens <number>', 'Persist max completion tokens for AI responses')
       .action(this.handleConfig.bind(this));
   }
 
@@ -42,14 +48,14 @@ export class ConfigCommand {
     return normalized;
   }
 
-  private validateMode(mode: string): 'custom' | 'openai' {
+  private validateMode(mode: string): AIMode {
     const normalized = mode?.toLowerCase();
-    if (normalized !== 'custom' && normalized !== 'openai') {
-      console.error('Mode must be either "custom" or "openai".');
+    if (normalized !== 'custom' && normalized !== 'openai' && normalized !== 'gemini') {
+      console.error('Mode must be one of: "custom", "openai", "gemini".');
       process.exit(1);
     }
 
-    return normalized;
+    return normalized as AIMode;
   }
 
   private sanitizeStringValue(value?: string): string | undefined {
@@ -68,9 +74,11 @@ export class ConfigCommand {
       model?: string;
       fallbackModel?: string;
       reasoningEffort?: string;
-      mode?: 'custom' | 'openai';
+      mode?: AIMode;
       language?: SupportedLanguage;
       autoPush?: boolean;
+      coAuthor?: string | false;
+      maxCompletionTokens?: number;
     } = {};
 
     if (options.language) {
@@ -110,6 +118,26 @@ export class ConfigCommand {
       updates.mode = this.validateMode(options.mode);
     }
 
+
+    if (options.noCoAuthor) {
+      updates.coAuthor = false;
+    } else if (options.coAuthor !== undefined) {
+      const coAuthor = this.sanitizeStringValue(options.coAuthor);
+      if (coAuthor && !/.+<.+@.+>/.test(coAuthor)) {
+        console.error('Co-author must be in "Name <email>" format.');
+        process.exit(1);
+      }
+      updates.coAuthor = coAuthor;
+    }
+    if (options.maxTokens !== undefined) {
+      const parsed = parseInt(options.maxTokens, 10);
+      if (isNaN(parsed) || parsed <= 0) {
+        console.error('Max tokens must be a positive number.');
+        process.exit(1);
+      }
+      updates.maxCompletionTokens = parsed;
+    }
+
     const hasUpdates = Object.keys(updates).length > 0;
 
     if (!options.show && !hasUpdates) {
@@ -120,8 +148,11 @@ export class ConfigCommand {
       console.log('  git-ai-commit config -k sk-xxx              # Persist API key securely on disk');
       console.log('  git-ai-commit config -b https://api.test    # Persist custom API base URL');
       console.log('  git-ai-commit config --mode openai          # Use OpenAI-compatible environment defaults');
+      console.log('  git-ai-commit config --mode gemini          # Use Gemini native SDK (GEMINI_API_KEY)');
       console.log('  git-ai-commit config --model gpt-4o-mini    # Persist preferred AI model');
       console.log('  git-ai-commit config --fallback-model glm-4-flash  # Fallback model for 429 retry');
+      console.log('  git-ai-commit config --co-author "Name <email>"  # Set co-author for commits');
+      console.log('  git-ai-commit config --max-tokens 2000        # Set max completion tokens for AI');
       return;
     }
 
@@ -148,6 +179,8 @@ export class ConfigCommand {
         console.log(`Fallback Model: ${config.fallbackModel || 'Not set'}`);
         console.log(`Reasoning Effort: ${config.reasoningEffort || 'Not set (model default)'}`);
         console.log(`Mode: ${config.mode || 'custom (default)'}`);
+        console.log(`Co-author: ${config.coAuthor === false ? 'disabled' : config.coAuthor}`);
+        console.log(`Max Completion Tokens: ${config.maxCompletionTokens || 'Not set (using per-command defaults)'}`);
       } catch (error) {
         console.error('Error reading configuration:', error instanceof Error ? error.message : error);
         process.exit(1);

package/src/commands/git.ts

@@ -4,11 +4,11 @@ import { promisify } from 'util';
 const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 const GIT_DIFF_MAX_BUFFER = 50 * 1024 * 1024;
-const MAX_DIFF_TOKENS = 50000;
+const MAX_DIFF_TOKENS = 25000;
 const APPROX_CHARS_PER_TOKEN = 4;
 const MAX_DIFF_CHARS = MAX_DIFF_TOKENS * APPROX_CHARS_PER_TOKEN;
-const MAX_FILE_LINES = 400;
-const MAX_NEW_FILE_LINES = 200;
+const MAX_FILE_LINES = 200;
+const MAX_NEW_FILE_LINES = 100;
 
 const splitDiffSections = (diff: string): string[] => {
   const lines = diff.split('\n');