@ksw8954/git-ai-commit 1.1.7 → 1.2.0

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');

package/src/commands/hookCommand.ts

@@ -0,0 +1,193 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import { execFileSync } from 'child_process';
+
+const HOOK_NAME = 'prepare-commit-msg';
+const HOOK_SIGNATURE = '# installed by git-ai-commit';
+
+const HOOK_SCRIPT = `#!/bin/sh
+${HOOK_SIGNATURE}
+
+COMMIT_MSG_FILE="$1"
+COMMIT_SOURCE="$2"
+
+# Skip if message was provided via -m, merge, squash, or amend
+if [ -n "$COMMIT_SOURCE" ]; then
+  exit 0
+fi
+
+# Skip if no staged changes
+if ! git diff --cached --quiet --exit-code 2>/dev/null; then
+  # Generate AI commit message
+  AI_MSG=$(git-ai-commit commit --message-only 2>/dev/null)
+  if [ $? -eq 0 ] && [ -n "$AI_MSG" ]; then
+    # Prepend AI message, keep original commented lines below
+    ORIGINAL=$(cat "$COMMIT_MSG_FILE")
+    printf '%s\n\n%s' "$AI_MSG" "$ORIGINAL" > "$COMMIT_MSG_FILE"
+  fi
+fi
+`;
+
+export class HookCommand {
+  private program: Command;
+
+  constructor() {
+    this.program = new Command('hook')
+      .description('Manage git-ai-commit prepare-commit-msg hook');
+
+    this.program
+      .command('install')
+      .description('Install prepare-commit-msg hook in the current repository')
+      .action(this.handleInstall.bind(this));
+
+    this.program
+      .command('uninstall')
+      .description('Remove prepare-commit-msg hook from the current repository')
+      .action(this.handleUninstall.bind(this));
+
+    this.program
+      .command('status')
+      .description('Show hook installation status')
+      .action(this.handleStatus.bind(this));
+  }
+
+  private getGitRoot(): string | null {
+    try {
+      return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+        encoding: 'utf-8',
+      }).trim();
+    } catch {
+      return null;
+    }
+  }
+
+  private getHooksDir(): string | null {
+    try {
+      const hooksPath = execFileSync('git', ['rev-parse', '--git-path', 'hooks'], {
+        encoding: 'utf-8',
+      }).trim();
+      // git rev-parse --git-path returns relative path; resolve it
+      const gitRoot = this.getGitRoot();
+      if (!gitRoot) return null;
+      return path.resolve(gitRoot, hooksPath);
+    } catch {
+      return null;
+    }
+  }
+
+  private getHookPath(): string | null {
+    const hooksDir = this.getHooksDir();
+    if (!hooksDir) return null;
+    return path.join(hooksDir, HOOK_NAME);
+  }
+
+  private isOurHook(hookPath: string): boolean {
+    try {
+      const content = fs.readFileSync(hookPath, 'utf-8');
+      return content.includes(HOOK_SIGNATURE);
+    } catch {
+      return false;
+    }
+  }
+
+  private handleInstall(): void {
+    const gitRoot = this.getGitRoot();
+    if (!gitRoot) {
+      console.error('Error: Not a git repository.');
+      process.exit(1);
+    }
+
+    const hookPath = this.getHookPath();
+    if (!hookPath) {
+      console.error('Error: Could not determine git hooks directory.');
+      process.exit(1);
+    }
+
+    // Check if hook already exists
+    if (fs.existsSync(hookPath)) {
+      if (this.isOurHook(hookPath)) {
+        console.log('Hook is already installed. Use "git-ai-commit hook uninstall" to remove it.');
+        return;
+      }
+      console.error(`Error: ${HOOK_NAME} hook already exists and was not installed by git-ai-commit.`);
+      console.error(`Path: ${hookPath}`);
+      console.error('Remove or rename the existing hook first, then try again.');
+      process.exit(1);
+    }
+
+    // Create hooks directory if it doesn't exist
+    const hooksDir = path.dirname(hookPath);
+    if (!fs.existsSync(hooksDir)) {
+      fs.mkdirSync(hooksDir, { recursive: true });
+    }
+
+    fs.writeFileSync(hookPath, HOOK_SCRIPT, { mode: 0o755 });
+    console.log(`Installed ${HOOK_NAME} hook.`);
+    console.log(`Path: ${hookPath}`);
+    console.log('');
+    console.log('Now "git commit" will auto-generate an AI commit message.');
+    console.log('The message will be pre-filled in your editor for review.');
+    console.log('Use "git commit -m ..." to skip AI generation.');
+  }
+
+  private handleUninstall(): void {
+    const gitRoot = this.getGitRoot();
+    if (!gitRoot) {
+      console.error('Error: Not a git repository.');
+      process.exit(1);
+    }
+
+    const hookPath = this.getHookPath();
+    if (!hookPath) {
+      console.error('Error: Could not determine git hooks directory.');
+      process.exit(1);
+    }
+
+    if (!fs.existsSync(hookPath)) {
+      console.log('No hook installed.');
+      return;
+    }
+
+    if (!this.isOurHook(hookPath)) {
+      console.error(`Error: ${HOOK_NAME} hook exists but was not installed by git-ai-commit.`);
+      console.error('Will not remove hooks installed by other tools.');
+      process.exit(1);
+    }
+
+    fs.unlinkSync(hookPath);
+    console.log(`Removed ${HOOK_NAME} hook.`);
+  }
+
+  private handleStatus(): void {
+    const gitRoot = this.getGitRoot();
+    if (!gitRoot) {
+      console.error('Error: Not a git repository.');
+      process.exit(1);
+    }
+
+    const hookPath = this.getHookPath();
+    if (!hookPath) {
+      console.error('Error: Could not determine git hooks directory.');
+      process.exit(1);
+    }
+
+    if (!fs.existsSync(hookPath)) {
+      console.log('Not installed.');
+      console.log('Run "git-ai-commit hook install" to set up the prepare-commit-msg hook.');
+      return;
+    }
+
+    if (this.isOurHook(hookPath)) {
+      console.log('Installed.');
+      console.log(`Path: ${hookPath}`);
+    } else {
+      console.log(`A ${HOOK_NAME} hook exists but was not installed by git-ai-commit.`);
+      console.log(`Path: ${hookPath}`);
+    }
+  }
+
+  getCommand(): Command {
+    return this.program;
+  }
+}

package/src/commands/prCommand.ts

@@ -64,7 +64,9 @@ export class PullRequestCommand {
         fallbackModel: existingConfig.fallbackModel,
         reasoningEffort: existingConfig.reasoningEffort,
         language: existingConfig.language,
-        verbose: false
+        verbose: false,
+        mode: existingConfig.mode,
+        maxCompletionTokens: existingConfig.maxCompletionTokens,
       });
 
       const aiResult = await aiService.generatePullRequestMessage(

package/src/commands/tag.ts

@@ -68,7 +68,9 @@ export class TagCommand {
       model: mergedModel,
       fallbackModel: storedConfig.fallbackModel,
       reasoningEffort: storedConfig.reasoningEffort,
-      language: storedConfig.language
+      language: storedConfig.language,
+      mode: storedConfig.mode,
+      maxCompletionTokens: storedConfig.maxCompletionTokens,
     };
   }
 
@@ -436,8 +438,17 @@ export class TagCommand {
         } else {
           for (const remote of selectedRemotes) {
             console.log(`Pushing tag ${trimmedName} to ${remote}...`);
-            const pushSuccess = await GitService.pushTagToRemote(trimmedName, remote);
+            let pushSuccess = await GitService.pushTagToRemote(trimmedName, remote);
+
+            if (!pushSuccess) {
+              console.log(`⚠️  Normal push failed for ${remote}. Force push may be required.`);
+              const shouldForcePush = await this.confirmForcePush(trimmedName);
 
+              if (shouldForcePush) {
+                console.log(`Force pushing tag ${trimmedName} to ${remote}...`);
+                pushSuccess = await GitService.forcePushTag(trimmedName, remote);
+              }
+            }
             if (pushSuccess) {
               console.log(`✅ Tag ${trimmedName} pushed to ${remote} successfully!`);
             } else {

package/src/index.ts

@@ -9,6 +9,7 @@ import { PullRequestCommand } from './commands/prCommand';
 import { TagCommand } from './commands/tag';
 import { HistoryCommand } from './commands/history';
 import { CompletionCommand } from './commands/completion';
+import { HookCommand } from './commands/hookCommand';
 
 function getPackageVersion(): string {
   try {
@@ -36,6 +37,7 @@ const pullRequestCommand = new PullRequestCommand();
 const tagCommand = new TagCommand();
 const historyCommand = new HistoryCommand();
 const completionCommand = new CompletionCommand();
+const hookCommand = new HookCommand();
 
 program.addCommand(commitCommand.getCommand());
 program.addCommand(configCommand.getCommand());
@@ -43,5 +45,6 @@ program.addCommand(pullRequestCommand.getCommand());
 program.addCommand(tagCommand.getCommand());
 program.addCommand(historyCommand.getCommand());
 program.addCommand(completionCommand.getCommand());
+program.addCommand(hookCommand.getCommand());
 
 program.parse();

package/src/schema/config.schema.json

@@ -0,0 +1,72 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://raw.githubusercontent.com/onaries/git-ai-commit/main/src/schema/config.schema.json",
+  "title": "git-ai-commit configuration",
+  "description": "Configuration file for git-ai-commit CLI (~/.git-ai-commit/config.json)",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "JSON Schema reference for editor support"
+    },
+    "apiKey": {
+      "type": "string",
+      "description": "API key for AI requests. Overrides AI_API_KEY / OPENAI_API_KEY environment variables."
+    },
+    "baseURL": {
+      "type": "string",
+      "format": "uri",
+      "description": "Custom API base URL. Overrides AI_BASE_URL / OPENAI_BASE_URL environment variables. Not used in gemini mode."
+    },
+    "model": {
+      "type": "string",
+      "description": "AI model to use for generation.",
+      "default": "zai-org/GLM-4.5-FP8",
+      "examples": ["gpt-4o-mini", "gpt-4", "gemini-2.0-flash", "claude-3-haiku"]
+    },
+    "fallbackModel": {
+      "type": "string",
+      "description": "Fallback model used when the primary model returns a 429 (rate limit) error.",
+      "examples": ["glm-4-flash", "gpt-4o-mini"]
+    },
+    "reasoningEffort": {
+      "type": "string",
+      "enum": ["minimal", "low", "medium", "high"],
+      "description": "Thinking effort level for reasoning models."
+    },
+    "mode": {
+      "type": "string",
+      "enum": ["custom", "openai", "gemini"],
+      "default": "custom",
+      "description": "AI provider mode. 'custom' uses AI_* vars first, 'openai' prefers OPENAI_* vars, 'gemini' uses Google Gemini native SDK."
+    },
+    "language": {
+      "type": "string",
+      "enum": ["ko", "en"],
+      "default": "ko",
+      "description": "Default language for AI-generated output."
+    },
+    "autoPush": {
+      "type": "boolean",
+      "default": false,
+      "description": "Automatically push to remote after a successful commit."
+    },
+    "coAuthor": {
+      "oneOf": [
+        {
+          "type": "string",
+          "pattern": ".+<.+@.+>",
+          "description": "Co-authored-by trailer value in 'Name <email>' format."
+        },
+        {
+          "type": "boolean",
+          "const": false,
+          "description": "Set to false to disable the default Co-authored-by trailer."
+        }
+      ],
+      "default": "git-ai-commit <git-ai-commit@users.noreply.github.com>",
+      "description": "Co-authored-by trailer appended to AI-generated commit messages. Defaults to 'git-ai-commit <git-ai-commit@users.noreply.github.com>'. Set to false to disable."
+    }
+  },
+  "additionalProperties": false
+}