@ksw8954/git-ai-commit 1.1.5 → 1.1.7

package/src/__tests__/tagCommand.test.ts

@@ -15,7 +15,10 @@ jest.mock('../commands/git', () => ({
     deleteLocalTag: jest.fn(),
     deleteRemoteTag: jest.fn(),
     forcePushTag: jest.fn(),
-    getRemotes: jest.fn()
+    getRemotes: jest.fn(),
+    getTagMessage: jest.fn(),
+    getTagBefore: jest.fn(),
+    getRecentTags: jest.fn()
   }
 }));
 
@@ -55,6 +58,10 @@ describe('TagCommand', () => {
     (GitService.tagExists as jest.Mock).mockResolvedValue(false);
     (GitService.remoteTagExists as jest.Mock).mockResolvedValue(false);
 
+    (GitService.getTagMessage as jest.Mock).mockResolvedValue(null);
+    (GitService.getTagBefore as jest.Mock).mockResolvedValue({ success: false, error: 'No earlier tag found.' });
+    (GitService.getRecentTags as jest.Mock).mockResolvedValue([]);
+
     // Default: no remotes configured (skip push flow)
     (GitService.getRemotes as jest.Mock).mockResolvedValue([]);
 
@@ -120,7 +127,7 @@ describe('TagCommand', () => {
       model: 'gpt-test',
       language: 'ko'
     });
-    expect(mockGenerateTagNotes).toHaveBeenCalledWith('v1.3.0', '- feat: add feature\n- fix: bug fix', undefined);
+    expect(mockGenerateTagNotes).toHaveBeenCalledWith('v1.3.0', '- feat: add feature\n- fix: bug fix', undefined, null, null);
     expect(GitService.createAnnotatedTag).toHaveBeenCalledWith('v1.3.0', '- Added feature\n- Fixed bug');
     expect(GitService.pushTag).not.toHaveBeenCalled();
   });

package/src/commands/ai.ts

@@ -1,13 +1,18 @@
 import OpenAI from 'openai';
+import { type ChatCompletionCreateParamsNonStreaming } from 'openai/resources/chat/completions';
 import { generateCommitPrompt } from '../prompts/commit';
 import { generateTagPrompt } from '../prompts/tag';
 import { generatePullRequestPrompt } from '../prompts/pr';
 import { SupportedLanguage } from './config';
 
+export type ReasoningEffort = 'minimal' | 'low' | 'medium' | 'high';
+
 export interface AIServiceConfig {
   apiKey: string;
   baseURL?: string;
   model?: string;
+  fallbackModel?: string;
+  reasoningEffort?: ReasoningEffort;
   language?: SupportedLanguage;
   verbose?: boolean;
 }
@@ -33,6 +38,8 @@ export interface PullRequestGenerationResult {
 export class AIService {
   private openai: OpenAI;
   private model: string;
+  private fallbackModel?: string;
+  private reasoningEffort?: ReasoningEffort;
   private language: SupportedLanguage;
   private verbose: boolean;
 
@@ -42,6 +49,8 @@ export class AIService {
       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;
   }
@@ -52,6 +61,12 @@ export class AIService {
     }
   }
 
+  private isRateLimitError(error: unknown): boolean {
+    if (!error || typeof error !== 'object') return false;
+    const status = (error as { status?: number }).status;
+    return status === 429;
+  }
+
   private isUnsupportedTokenParamError(
     error: unknown,
     param: 'max_tokens' | 'max_completion_tokens'
@@ -134,29 +149,132 @@ export class AIService {
     return { ...rest };
   }
 
-  private async createChatCompletion(
-    request: OpenAI.ChatCompletionCreateParamsNonStreaming,
+  private readonly spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+  private formatElapsed(ms: number): string {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 1) return '0s';
+    return `${seconds}s`;
+  }
+
+  private async createStreamingCompletion(
+    request: ChatCompletionCreateParamsNonStreaming,
     attempt = 0
-  ): Promise<OpenAI.ChatCompletion> {
+  ): Promise<string> {
+    let waitingTimer: ReturnType<typeof setInterval> | null = null;
+
     try {
-      return await this.openai.chat.completions.create(request);
+      const startTime = Date.now();
+      let frameIndex = 0;
+
+      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 streamParams = {
+        ...request,
+        stream: true as const,
+        ...(this.reasoningEffort ? { reasoning_effort: this.reasoningEffort } : {})
+      };
+
+      const stream = await this.openai.chat.completions.create(streamParams);
+
+      const contentChunks: string[] = [];
+      let reasoningTokens = 0;
+      let contentTokens = 0;
+      let phase: 'waiting' | 'thinking' | 'content' = 'waiting';
+
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        const content = delta?.content;
+        const reasoning = (delta as Record<string, unknown>)?.reasoning_content as string | undefined;
+
+        if (reasoning) {
+          reasoningTokens++;
+
+          if (phase === 'waiting' && waitingTimer) {
+            clearInterval(waitingTimer);
+            waitingTimer = null;
+            phase = 'thinking';
+          }
+
+          if (this.verbose && phase === 'thinking') {
+            const frame = this.spinnerFrames[frameIndex++ % this.spinnerFrames.length];
+            const elapsed = this.formatElapsed(Date.now() - startTime);
+            process.stdout.write(`\r${frame} Thinking... (${reasoningTokens} tokens, ${elapsed})`);
+          }
+        }
+
+        if (content) {
+          contentChunks.push(content);
+          contentTokens++;
+
+          if (phase !== 'content') {
+            if (waitingTimer) {
+              clearInterval(waitingTimer);
+              waitingTimer = null;
+            }
+            phase = 'content';
+          }
+
+          if (this.verbose) {
+            const frame = this.spinnerFrames[frameIndex++ % this.spinnerFrames.length];
+            const elapsed = this.formatElapsed(Date.now() - startTime);
+            process.stdout.write(`\r${frame} Streaming response... (${contentTokens} tokens, ${elapsed})`);
+          }
+        }
+      }
+
+      if (waitingTimer) {
+        clearInterval(waitingTimer);
+        waitingTimer = null;
+      }
+
+      if (this.verbose) {
+        const totalTokens = reasoningTokens + contentTokens;
+        const elapsed = this.formatElapsed(Date.now() - startTime);
+        const detail = reasoningTokens > 0
+          ? `${totalTokens} tokens (thinking: ${reasoningTokens}, response: ${contentTokens}), ${elapsed}`
+          : `${contentTokens} tokens, ${elapsed}`;
+        process.stdout.write(`\r✅ Complete (${detail})\n`);
+      }
+
+      return contentChunks.join('');
     } catch (error) {
+      if (waitingTimer) {
+        clearInterval(waitingTimer);
+        waitingTimer = null;
+      }
+      if (this.verbose) {
+        process.stdout.write('\n');
+      }
+
       if (attempt < 3 && this.isUnsupportedValueError(error, 'temperature')) {
         const fallbackRequest = this.removeTemperature(request);
         this.debugLog('Retrying without temperature due to unsupported value error.');
-        return await this.createChatCompletion(fallbackRequest, attempt + 1);
+        return await this.createStreamingCompletion(fallbackRequest, attempt + 1);
       }
 
       if (this.isUnsupportedTokenParamError(error, 'max_completion_tokens')) {
         const fallbackRequest = this.swapTokenParam(request, 'max_tokens');
         this.debugLog('Retrying with max_tokens due to unsupported max_completion_tokens error.');
-        return await this.createChatCompletion(fallbackRequest, attempt + 1);
+        return await this.createStreamingCompletion(fallbackRequest, attempt + 1);
       }
 
       if (this.isUnsupportedTokenParamError(error, 'max_tokens')) {
         const fallbackRequest = this.swapTokenParam(request, 'max_completion_tokens');
         this.debugLog('Retrying with max_completion_tokens due to unsupported max_tokens error.');
-        return await this.createChatCompletion(fallbackRequest, attempt + 1);
+        return await this.createStreamingCompletion(fallbackRequest, attempt + 1);
+      }
+
+      if (this.isRateLimitError(error) && this.fallbackModel && request.model !== this.fallbackModel) {
+        this.debugLog(`Rate limited (429). Retrying with fallback model: ${this.fallbackModel}`);
+        const fallbackRequest = { ...request, model: this.fallbackModel };
+        return await this.createStreamingCompletion(fallbackRequest, attempt + 1);
       }
 
       throw error;
@@ -205,7 +323,7 @@ export class AIService {
         ? `Git diff will be provided separately in the user message.\n\n## Additional User Instructions\n${extraInstructions.trim()}`
         : 'Git diff will be provided separately in the user message.';
       
-      const response = await this.createChatCompletion({
+      const content = await this.createStreamingCompletion({
         model: this.model,
         messages: [
           {
@@ -224,36 +342,8 @@ export class AIService {
         max_completion_tokens: 3000
       });
 
-      this.debugLog('API Response received:', JSON.stringify(response, null, 2));
+      let finalMessage = content.trim() || null;
 
-      const choice = response.choices[0];
-      const message = choice?.message?.content?.trim();
-      
-      // Handle reasoning content if available (type assertion for custom API response)
-      const messageAny = choice?.message as any;
-      const reasoningMessage = messageAny?.reasoning_content?.trim();
-      
-      // Try to extract commit message from reasoning content if regular content is null
-      let finalMessage = message;
-      if (!finalMessage && reasoningMessage) {
-        // Look for commit message pattern in reasoning content
-        const commitMatch = reasoningMessage.match(/(?:feat|fix|docs|style|refactor|test|chore|build|ci|perf|revert): .+/);
-        if (commitMatch) {
-          finalMessage = commitMatch[0].trim();
-        } else {
-          // Look for any line that starts with conventional commit types
-          const typeMatch = reasoningMessage.match(/(?:feat|fix|docs|style|refactor|test|chore|build|ci|perf|revert)[^:]*: .+/);
-          if (typeMatch) {
-            finalMessage = typeMatch[0].trim();
-          } else {
-            // Try to find a short descriptive line
-            const lines = reasoningMessage.split('\n').filter((line: string) => line.trim().length > 0);
-            const shortLine = lines.find((line: string) => line.length < 100 && line.includes('version'));
-            finalMessage = shortLine ? `chore: ${shortLine.trim()}` : `chore: update files`;
-          }
-        }
-      }
-      
       if (!finalMessage) {
         this.debugLog('No message found in response');
         return {
@@ -381,7 +471,7 @@ export class AIService {
         userContent += `\n\n---\nPrevious release notes for this tag (improve upon this):\n${previousMessage}`;
       }
 
-      const response = await this.createChatCompletion({
+      const content = await this.createStreamingCompletion({
         model: this.model,
         messages: [
           {
@@ -396,13 +486,7 @@ export class AIService {
         max_completion_tokens: 3000
       });
 
-      const choice = response.choices[0];
-      const message = choice?.message?.content?.trim();
-
-      const messageAny = choice?.message as any;
-      const reasoningMessage = messageAny?.reasoning_content?.trim();
-
-      const finalNotes = message || reasoningMessage;
+      const finalNotes = content.trim() || null;
 
       if (!finalNotes) {
         this.debugLog('No notes found in response');
@@ -435,7 +519,7 @@ export class AIService {
       this.debugLog('Model:', this.model);
       this.debugLog('Base URL:', this.openai.baseURL);
 
-      const response = await this.createChatCompletion({
+      const content = await this.createStreamingCompletion({
         model: this.model,
         messages: [
           {
@@ -455,13 +539,7 @@ export class AIService {
         max_completion_tokens: 4000
       });
 
-      const choice = response.choices[0];
-      const message = choice?.message?.content?.trim();
-
-      const messageAny = choice?.message as any;
-      const reasoningMessage = messageAny?.reasoning_content?.trim();
-
-      const finalMessage = message || reasoningMessage;
+      const finalMessage = content.trim() || null;
 
       if (!finalMessage) {
         return {

package/src/commands/commit.ts

@@ -161,6 +161,8 @@ export class CommitCommand {
         apiKey: mergedApiKey!,
         baseURL: mergedBaseURL,
         model: mergedModel,
+        fallbackModel: existingConfig.fallbackModel,
+        reasoningEffort: existingConfig.reasoningEffort,
         language: existingConfig.language,
         verbose: !messageOnly,
       };

package/src/commands/completion.ts

@@ -40,7 +40,7 @@ _git_ai_commit() {
 
     # 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 --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"
     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"

package/src/commands/config.ts

@@ -5,10 +5,14 @@ import path from 'path';
 
 export type SupportedLanguage = 'ko' | 'en';
 
+export type ReasoningEffort = 'minimal' | 'low' | 'medium' | 'high';
+
 export interface EnvironmentConfig {
   apiKey?: string;
   baseURL?: string;
   model?: string;
+  fallbackModel?: string;
+  reasoningEffort?: ReasoningEffort;
   mode: 'custom' | 'openai';
   language: SupportedLanguage;
   autoPush: boolean;
@@ -18,6 +22,8 @@ interface StoredConfig {
   apiKey?: string;
   baseURL?: string;
   model?: string;
+  fallbackModel?: string;
+  reasoningEffort?: ReasoningEffort | string;
   mode?: 'custom' | 'openai';
   language?: SupportedLanguage | string;
   autoPush?: boolean;
@@ -68,6 +74,15 @@ export class ConfigService {
     return normalized === 'en' ? 'en' : 'ko';
   }
 
+  private static normalizeReasoningEffort(effort?: string): ReasoningEffort | undefined {
+    if (!effort) return undefined;
+    const normalized = effort.toLowerCase();
+    if (['minimal', 'low', 'medium', 'high'].includes(normalized)) {
+      return normalized as ReasoningEffort;
+    }
+    return undefined;
+  }
+
   private static normalizeMode(mode?: string): 'custom' | 'openai' {
     if (!mode) {
       return DEFAULT_MODE;
@@ -111,6 +126,8 @@ export class ConfigService {
     const apiKey = fileConfig.apiKey ?? envConfig.apiKey;
     const baseURL = fileConfig.baseURL ?? envConfig.baseURL;
     const model = fileConfig.model ?? envConfig.model ?? DEFAULT_MODEL;
+    const fallbackModel = fileConfig.fallbackModel;
+    const reasoningEffort = this.normalizeReasoningEffort(fileConfig.reasoningEffort);
     const language = this.normalizeLanguage(fileConfig.language ?? envConfig.language);
     const autoPush = typeof fileConfig.autoPush === 'boolean' ? fileConfig.autoPush : envConfig.autoPush;
 
@@ -118,6 +135,8 @@ export class ConfigService {
       apiKey,
       baseURL,
       model,
+      fallbackModel,
+      reasoningEffort,
       mode,
       language,
       autoPush

package/src/commands/configCommand.ts

@@ -8,6 +8,8 @@ export interface ConfigOptions {
   apiKey?: string;
   baseUrl?: string;
   model?: string;
+  fallbackModel?: string;
+  reasoningEffort?: string;
   mode?: 'custom' | 'openai';
 }
 
@@ -24,6 +26,8 @@ export class ConfigCommand {
       .option('-k, --api-key <key>', 'Persist API key for AI requests (overrides environment variables)')
       .option('-b, --base-url <url>', 'Persist API base URL (overrides environment variables)')
       .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)')
       .action(this.handleConfig.bind(this));
   }
@@ -62,6 +66,8 @@ export class ConfigCommand {
       apiKey?: string;
       baseURL?: string;
       model?: string;
+      fallbackModel?: string;
+      reasoningEffort?: string;
       mode?: 'custom' | 'openai';
       language?: SupportedLanguage;
       autoPush?: boolean;
@@ -87,6 +93,19 @@ export class ConfigCommand {
       updates.model = this.sanitizeStringValue(options.model);
     }
 
+    if (options.fallbackModel !== undefined) {
+      updates.fallbackModel = this.sanitizeStringValue(options.fallbackModel);
+    }
+
+    if (options.reasoningEffort !== undefined) {
+      const effort = options.reasoningEffort.toLowerCase();
+      if (!['minimal', 'low', 'medium', 'high'].includes(effort)) {
+        console.error('Reasoning effort must be one of: minimal, low, medium, high');
+        process.exit(1);
+      }
+      updates.reasoningEffort = effort;
+    }
+
     if (options.mode) {
       updates.mode = this.validateMode(options.mode);
     }
@@ -102,6 +121,7 @@ export class ConfigCommand {
       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 --model gpt-4o-mini    # Persist preferred AI model');
+      console.log('  git-ai-commit config --fallback-model glm-4-flash  # Fallback model for 429 retry');
       return;
     }
 
@@ -125,6 +145,8 @@ export class ConfigCommand {
         console.log(`API Key: ${config.apiKey ? '***' + config.apiKey.slice(-4) : 'Not set'}`);
         console.log(`Base URL: ${config.baseURL || 'Not set (using provider default)'}`);
         console.log(`Model: ${config.model || 'zai-org/GLM-4.5-FP8 (default)'}`);
+        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)'}`);
       } catch (error) {
         console.error('Error reading configuration:', error instanceof Error ? error.message : error);

package/src/commands/git.ts

@@ -210,6 +210,41 @@ export class GitService {
     }
   }
 
+  static async getRecentTags(count = 10): Promise<string[]> {
+    try {
+      const { stdout } = await execAsync(
+        `git tag --sort=-creatordate | head -n ${count}`
+      );
+      return stdout
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line.length > 0);
+    } catch {
+      return [];
+    }
+  }
+
+  static async getTagBefore(tagName: string): Promise<GitTagResult> {
+    try {
+      const { stdout: tagCommit } = await execAsync(`git rev-list -n 1 ${tagName}`);
+      const commit = tagCommit.trim();
+      if (!commit) {
+        return { success: false, error: 'Could not resolve tag to a commit.' };
+      }
+
+      const { stdout } = await execAsync(`git describe --tags --abbrev=0 ${commit}~1`);
+      const tag = stdout.trim();
+
+      if (!tag) {
+        return { success: false, error: 'No earlier tag found.' };
+      }
+
+      return { success: true, tag };
+    } catch {
+      return { success: false, error: 'No earlier tag found.' };
+    }
+  }
+
   static async getCommitSummariesSince(tag?: string): Promise<GitLogResult> {
     try {
       const logCommand = tag

package/src/commands/prCommand.ts

@@ -61,6 +61,8 @@ export class PullRequestCommand {
         apiKey: mergedApiKey!,
         baseURL: mergedBaseURL,
         model: mergedModel,
+        fallbackModel: existingConfig.fallbackModel,
+        reasoningEffort: existingConfig.reasoningEffort,
         language: existingConfig.language,
         verbose: false
       });