@ksw8954/git-ai-commit 1.0.0

package/src/commands/ai.ts

@@ -0,0 +1,266 @@
+import OpenAI from 'openai';
+import { generateCommitPrompt } from '../prompts/commit';
+import { generateTagPrompt } from '../prompts/tag';
+import { generatePullRequestPrompt } from '../prompts/pr';
+import { SupportedLanguage } from './config';
+
+export interface AIServiceConfig {
+  apiKey: string;
+  baseURL?: string;
+  model?: string;
+  language?: SupportedLanguage;
+  verbose?: boolean;
+}
+
+export interface CommitGenerationResult {
+  success: boolean;
+  message?: string;
+  error?: string;
+}
+
+export interface TagGenerationResult {
+  success: boolean;
+  notes?: string;
+  error?: string;
+}
+
+export interface PullRequestGenerationResult {
+  success: boolean;
+  message?: string;
+  error?: string;
+}
+
+export class AIService {
+  private openai: OpenAI;
+  private model: string;
+  private language: SupportedLanguage;
+  private verbose: boolean;
+
+  constructor(config: AIServiceConfig) {
+    this.openai = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseURL
+    });
+    this.model = config.model || 'zai-org/GLM-4.5-FP8';
+    this.language = config.language || 'ko';
+    this.verbose = config.verbose ?? true;
+  }
+
+  private debugLog(...args: unknown[]): void {
+    if (this.verbose) {
+      console.log(...args);
+    }
+  }
+
+  async generateCommitMessage(diff: string, extraInstructions?: string): Promise<CommitGenerationResult> {
+    try {
+      this.debugLog('Sending request to AI API...');
+      this.debugLog('Model:', this.model);
+      this.debugLog('Base URL:', this.openai.baseURL);
+      
+      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()}`
+        : 'Git diff will be provided separately in the user message.';
+      
+      const response = await this.openai.chat.completions.create({
+        model: this.model,
+        messages: [
+          {
+            role: 'system',
+            content: generateCommitPrompt(
+              '',
+              customInstructions,
+              this.language
+            )
+          },
+          {
+            role: 'user',
+            content: `Git diff:\n${diff}`
+          }
+        ],
+        max_tokens: 3000,
+        temperature: 0.1
+      });
+
+      this.debugLog('API Response received:', JSON.stringify(response, null, 2));
+
+      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 {
+          success: false,
+          error: 'No commit message generated'
+        };
+      }
+
+      // Clean up the message
+      finalMessage = finalMessage.replace(/^(The commit message is:|Commit message:|Message:)\s*/, '');
+      
+      // Ensure it follows conventional commit format
+      if (!finalMessage.match(/^(feat|fix|docs|style|refactor|test|chore|build|ci|perf|revert)(\(.+\))?!?: .+/)) {
+        // If it doesn't match the format, try to fix it
+        if (finalMessage.includes('version') || finalMessage.includes('update')) {
+          finalMessage = `chore: ${finalMessage}`;
+        } else if (finalMessage.includes('feature') || finalMessage.includes('add')) {
+          finalMessage = `feat: ${finalMessage}`;
+        } else if (finalMessage.includes('fix') || finalMessage.includes('bug')) {
+          finalMessage = `fix: ${finalMessage}`;
+        } else {
+          finalMessage = `chore: ${finalMessage}`;
+        }
+      }
+
+      return {
+        success: true,
+        message: finalMessage
+      };
+    } catch (error) {
+      console.error('API Error:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to generate commit message'
+      };
+    }
+  }
+
+  async generateTagNotes(tagName: string, commitLog: string, extraInstructions?: string): Promise<TagGenerationResult> {
+    try {
+      this.debugLog('Sending request to AI API for tag notes...');
+      this.debugLog('Model:', this.model);
+      this.debugLog('Base URL:', this.openai.baseURL);
+
+      const customInstructions = extraInstructions && extraInstructions.trim().length > 0
+        ? `${extraInstructions.trim()}`
+        : '';
+
+      const response = await this.openai.chat.completions.create({
+        model: this.model,
+        messages: [
+          {
+            role: 'system',
+            content: generateTagPrompt(tagName, customInstructions, this.language)
+          },
+          {
+            role: 'user',
+            content: `Commit log:\n${commitLog}`
+          }
+        ],
+        max_tokens: 3000,
+        temperature: 0.2
+      });
+
+      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;
+
+      if (!finalNotes) {
+        this.debugLog('No notes found in response');
+        return {
+          success: false,
+          error: 'No tag notes generated'
+        };
+      }
+
+      return {
+        success: true,
+        notes: finalNotes.trim()
+      };
+    } catch (error) {
+      console.error('API Error:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to generate tag notes'
+      };
+    }
+  }
+
+  async generatePullRequestMessage(
+    baseBranch: string,
+    compareBranch: string,
+    diff: string
+  ): Promise<PullRequestGenerationResult> {
+    try {
+      this.debugLog('Sending request to AI API for pull request message...');
+      this.debugLog('Model:', this.model);
+      this.debugLog('Base URL:', this.openai.baseURL);
+
+      const response = await this.openai.chat.completions.create({
+        model: this.model,
+        messages: [
+          {
+            role: 'system',
+            content: generatePullRequestPrompt(
+              baseBranch,
+              compareBranch,
+              '',
+              this.language
+            )
+          },
+          {
+            role: 'user',
+            content: `Git diff between ${baseBranch} and ${compareBranch}:\n${diff}`
+          }
+        ],
+        max_tokens: 4000,
+        temperature: 0.2
+      });
+
+      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;
+
+      if (!finalMessage) {
+        return {
+          success: false,
+          error: 'No pull request message generated'
+        };
+      }
+
+      return {
+        success: true,
+        message: finalMessage.trim()
+      };
+    } catch (error) {
+      console.error('API Error:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to generate pull request message'
+      };
+    }
+  }
+}

package/src/commands/commit.ts

@@ -0,0 +1,215 @@
+import { Command } from 'commander';
+import readline from 'readline';
+import { GitService, GitDiffResult } from './git';
+import { AIService, AIServiceConfig } from './ai';
+import { ConfigService } from './config';
+import { LogService } from './log';
+
+export interface CommitOptions {
+  apiKey?: string;
+  baseURL?: string;
+  model?: string;
+  push?: boolean;
+  messageOnly?: boolean;
+  prompt?: string;
+}
+
+export class CommitCommand {
+  private program: Command;
+
+  constructor() {
+    this.program = new Command('commit')
+      .description('Generate AI-powered commit message')
+      .option('-k, --api-key <key>', 'OpenAI API key (overrides env var)')
+      .option('-b, --base-url <url>', 'Custom API base URL (overrides env var)')
+      .option('--model <model>', 'Model to use (overrides env var)')
+      .option('-m, --message-only', 'Output only the generated commit message and skip git actions')
+      .option('-p, --push', 'Push current branch after creating the commit (implies --commit)')
+      .option('--prompt <text>', 'Additional instructions to append to the AI prompt for this commit')
+      .action(this.handleCommit.bind(this));
+  }
+
+  private async handleCommit(options: CommitOptions) {
+    const start = Date.now();
+    const safeArgs = {
+      ...options,
+      apiKey: options.apiKey ? '***' : undefined
+    } as Record<string, unknown>;
+    try {
+      const existingConfig = ConfigService.getConfig();
+
+      const mergedApiKey = options.apiKey || existingConfig.apiKey;
+      const mergedBaseURL = options.baseURL || existingConfig.baseURL;
+      const mergedModel = options.model || existingConfig.model;
+      const messageOnly = Boolean(options.messageOnly);
+
+      const log = (...args: unknown[]) => {
+        if (!messageOnly) {
+          console.log(...args);
+        }
+      };
+
+      ConfigService.validateConfig({
+        apiKey: mergedApiKey,
+        language: existingConfig.language
+      });
+
+      const aiConfig: AIServiceConfig = {
+        apiKey: mergedApiKey!,
+        baseURL: mergedBaseURL,
+        model: mergedModel,
+        language: existingConfig.language,
+        verbose: !messageOnly
+      };
+
+      log('Getting staged changes...');
+      
+      const diffResult: GitDiffResult = await GitService.getStagedDiff();
+      
+      if (!diffResult.success) {
+        console.error('Error:', diffResult.error);
+        await LogService.append({
+          command: 'commit',
+          args: safeArgs,
+          status: 'failure',
+          details: diffResult.error,
+          durationMs: Date.now() - start
+        });
+        process.exit(1);
+      }
+
+      log('Generating commit message...');
+      
+      const aiService = new AIService(aiConfig);
+      const aiResult = await aiService.generateCommitMessage(diffResult.diff!, options.prompt);
+
+      if (!aiResult.success) {
+        console.error('Error:', aiResult.error);
+        await LogService.append({
+          command: 'commit',
+          args: safeArgs,
+          status: 'failure',
+          details: aiResult.error,
+          durationMs: Date.now() - start
+        });
+        process.exit(1);
+      }
+
+      if (typeof aiResult.message !== 'string') {
+        console.error('Error: Failed to generate commit message');
+        process.exit(1);
+      }
+
+      if (messageOnly) {
+        console.log(aiResult.message);
+        await LogService.append({
+          command: 'commit',
+          args: { ...safeArgs, messageOnly: true },
+          status: 'success',
+          details: 'message-only output',
+          durationMs: Date.now() - start
+        });
+        return;
+      }
+
+      console.log('\nGenerated commit message:');
+      console.log(aiResult.message);
+
+      const confirmed = await this.confirmCommit();
+
+      if (!confirmed) {
+        console.log('Commit cancelled by user.');
+        await LogService.append({
+          command: 'commit',
+          args: safeArgs,
+          status: 'cancelled',
+          details: 'user declined commit',
+          durationMs: Date.now() - start
+        });
+        return;
+      }
+
+      console.log('\nCreating commit...');
+      const commitSuccess = await GitService.createCommit(aiResult.message!);
+
+      if (commitSuccess) {
+        console.log('✅ Commit created successfully!');
+
+        const pushRequested = Boolean(options.push);
+        const pushFromConfig = !pushRequested && existingConfig.autoPush;
+        const shouldPush = pushRequested || pushFromConfig;
+
+        if (shouldPush) {
+          if (pushFromConfig) {
+            console.log('Auto push enabled in config; pushing to remote...');
+          } else {
+            console.log('Pushing to remote...');
+          }
+
+          const pushSuccess = await GitService.push();
+
+          if (pushSuccess) {
+            console.log('✅ Push completed successfully!');
+          } else {
+            console.error('❌ Failed to push to remote');
+            await LogService.append({
+              command: 'commit',
+              args: { ...safeArgs, push: true },
+              status: 'failure',
+              details: 'push failed',
+              durationMs: Date.now() - start
+            });
+            process.exit(1);
+          }
+        }
+      } else {
+        console.error('❌ Failed to create commit');
+        await LogService.append({
+          command: 'commit',
+          args: safeArgs,
+          status: 'failure',
+          details: 'git commit failed',
+          durationMs: Date.now() - start
+        });
+        process.exit(1);
+      }
+      await LogService.append({
+        command: 'commit',
+        args: safeArgs,
+        status: 'success',
+        durationMs: Date.now() - start
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error('Error:', message);
+      await LogService.append({
+        command: 'commit',
+        args: safeArgs,
+        status: 'failure',
+        details: message,
+        durationMs: Date.now() - start
+      });
+      process.exit(1);
+    }
+  }
+
+  private async confirmCommit(): Promise<boolean> {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const answer: string = await new Promise(resolve => {
+      rl.question('Proceed with git commit? (y/n): ', resolve);
+    });
+
+    rl.close();
+
+    const normalized = answer.trim().toLowerCase();
+    return normalized === 'y' || normalized === 'yes';
+  }
+
+  getCommand(): Command {
+    return this.program;
+  }
+}

package/src/commands/config.ts

@@ -0,0 +1,182 @@
+import fs from 'fs';
+import { promises as fsPromises } from 'fs';
+import os from 'os';
+import path from 'path';
+
+export type SupportedLanguage = 'ko' | 'en';
+
+export interface EnvironmentConfig {
+  apiKey?: string;
+  baseURL?: string;
+  model?: string;
+  mode: 'custom' | 'openai';
+  language: SupportedLanguage;
+  autoPush: boolean;
+}
+
+interface StoredConfig {
+  apiKey?: string;
+  baseURL?: string;
+  model?: string;
+  mode?: 'custom' | 'openai';
+  language?: SupportedLanguage | string;
+  autoPush?: boolean;
+}
+
+const DEFAULT_MODEL = 'zai-org/GLM-4.5-FP8';
+const DEFAULT_MODE: 'custom' | 'openai' = 'custom';
+const DEFAULT_LANGUAGE: SupportedLanguage = 'ko';
+const DEFAULT_AUTO_PUSH = false;
+
+export class ConfigService {
+  private static getConfigFilePath(): string {
+    const overridePath = process.env.GIT_AI_COMMIT_CONFIG_PATH;
+    if (overridePath) {
+      return path.resolve(overridePath);
+    }
+
+    return path.join(os.homedir(), '.git-ai-commit', 'config.json');
+  }
+
+  private static loadFileConfig(): StoredConfig {
+    const filePath = this.getConfigFilePath();
+
+    try {
+      if (!fs.existsSync(filePath)) {
+        return {};
+      }
+
+      const raw = fs.readFileSync(filePath, 'utf-8');
+      if (!raw.trim()) {
+        return {};
+      }
+
+      const parsed = JSON.parse(raw);
+      return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    } catch (error) {
+      console.warn('Warning: Failed to read configuration file. Falling back to environment variables.');
+      return {};
+    }
+  }
+
+  private static normalizeLanguage(language?: string): SupportedLanguage {
+    if (!language) {
+      return DEFAULT_LANGUAGE;
+    }
+
+    const normalized = language.toLowerCase();
+    return normalized === 'en' ? 'en' : 'ko';
+  }
+
+  private static normalizeMode(mode?: string): 'custom' | 'openai' {
+    if (!mode) {
+      return DEFAULT_MODE;
+    }
+
+    const normalized = mode.toLowerCase();
+    return normalized === 'openai' ? 'openai' : 'custom';
+  }
+
+  private static resolveEnvConfig(modeOverride?: 'custom' | 'openai'): 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;
+
+    return {
+      apiKey: apiKey || undefined,
+      baseURL: baseURL || undefined,
+      model: model || DEFAULT_MODEL,
+      mode: resolvedMode,
+      language: DEFAULT_LANGUAGE,
+      autoPush: DEFAULT_AUTO_PUSH
+    };
+  }
+
+  static getConfig(): EnvironmentConfig {
+    const fileConfig = this.loadFileConfig();
+    const envConfig = this.resolveEnvConfig(fileConfig.mode);
+
+    const mode = this.normalizeMode(fileConfig.mode || envConfig.mode);
+    const apiKey = fileConfig.apiKey ?? envConfig.apiKey;
+    const baseURL = fileConfig.baseURL ?? envConfig.baseURL;
+    const model = fileConfig.model ?? envConfig.model ?? DEFAULT_MODEL;
+    const language = this.normalizeLanguage(fileConfig.language ?? envConfig.language);
+    const autoPush = typeof fileConfig.autoPush === 'boolean' ? fileConfig.autoPush : envConfig.autoPush;
+
+    return {
+      apiKey,
+      baseURL,
+      model,
+      mode,
+      language,
+      autoPush
+    };
+  }
+
+  static getEnvConfig(): EnvironmentConfig {
+    return this.getConfig();
+  }
+
+  static async updateConfig(updates: StoredConfig): Promise<void> {
+    const filePath = this.getConfigFilePath();
+    const current = this.loadFileConfig();
+
+    const next: StoredConfig = {
+      ...current,
+      ...updates
+    };
+
+    if (updates.language !== undefined) {
+      next.language = this.normalizeLanguage(updates.language);
+    }
+
+    if (updates.autoPush !== undefined) {
+      next.autoPush = Boolean(updates.autoPush);
+    }
+
+    if (updates.mode !== undefined) {
+      next.mode = this.normalizeMode(updates.mode);
+    }
+
+    if (next.model === DEFAULT_MODEL) {
+      delete next.model;
+    }
+
+    if (next.mode === DEFAULT_MODE) {
+      delete next.mode;
+    }
+
+    const sanitized = Object.entries(next).reduce<StoredConfig>((acc, [key, value]) => {
+      if (value !== undefined) {
+        acc[key as keyof StoredConfig] = value as any;
+      } else {
+        delete acc[key as keyof StoredConfig];
+      }
+      return acc;
+    }, {});
+
+    await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+    await fsPromises.writeFile(filePath, JSON.stringify(sanitized, null, 2), 'utf-8');
+  }
+
+  static validateConfig(config: { apiKey?: string; language?: string }): void {
+    if (!config.apiKey) {
+      throw new Error('API key is required');
+    }
+
+    if (config.language && !['ko', 'en'].includes(config.language)) {
+      throw new Error('Unsupported language. Use "ko" or "en".');
+    }
+  }
+}