@ksw8954/git-ai-commit 1.0.0

package/src/__tests__/ai.test.ts

@@ -0,0 +1,185 @@
+import { AIService } from '../commands/ai';
+import { generateCommitPrompt } from '../prompts/commit';
+import { generatePullRequestPrompt } from '../prompts/pr';
+import OpenAI from 'openai';
+
+jest.mock('openai');
+const MockedOpenAI = OpenAI as jest.MockedClass<typeof OpenAI>;
+
+describe('AIService', () => {
+  let aiService: AIService;
+  let mockOpenai: jest.Mocked<OpenAI>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockOpenai = {
+      chat: {
+        completions: {
+          create: jest.fn()
+        }
+      }
+    } as any;
+
+    MockedOpenAI.mockImplementation(() => mockOpenai);
+
+    aiService = new AIService({
+      apiKey: 'test-api-key',
+      baseURL: 'https://api.test.com',
+      model: 'gpt-4'
+    });
+  });
+
+  describe('generateCommitMessage', () => {
+    it('should return success with commit message when API call succeeds', async () => {
+      const mockResponse = {
+        choices: [{
+          message: {
+            content: 'feat: add new feature'
+          }
+        }]
+      };
+
+      (mockOpenai.chat.completions.create as jest.Mock).mockResolvedValue(mockResponse);
+
+      const diff = 'diff --git a/file.txt b/file.txt\nnew file mode 100644';
+      const result = await aiService.generateCommitMessage(diff);
+
+      expect(result).toEqual({
+        success: true,
+        message: 'feat: add new feature'
+      });
+
+      expect(mockOpenai.chat.completions.create).toHaveBeenCalledWith({
+        model: 'gpt-4',
+        messages: [
+          {
+            role: 'system',
+            content: generateCommitPrompt(
+              '',
+              'Git diff will be provided separately in the user message.',
+              'ko'
+            )
+          },
+          {
+            role: 'user',
+            content: `Git diff:\n${diff}`
+          }
+        ],
+        max_tokens: 3000,
+        temperature: 0.1
+      });
+    });
+
+    it('should return error when API returns no message', async () => {
+      const mockResponse = {
+        choices: [{
+          message: {
+            content: null
+          }
+        }]
+      };
+
+      (mockOpenai.chat.completions.create as jest.Mock).mockResolvedValue(mockResponse);
+
+      const diff = 'diff --git a/file.txt b/file.txt\nnew file mode 100644';
+      const result = await aiService.generateCommitMessage(diff);
+
+      expect(result).toEqual({
+        success: false,
+        error: 'No commit message generated'
+      });
+    });
+
+    it('should return error when API call fails', async () => {
+      const error = new Error('API call failed');
+      (mockOpenai.chat.completions.create as jest.Mock).mockRejectedValue(error);
+
+      const diff = 'diff --git a/file.txt b/file.txt\nnew file mode 100644';
+      const result = await aiService.generateCommitMessage(diff);
+
+      expect(result).toEqual({
+        success: false,
+        error: 'API call failed'
+      });
+    });
+
+    it('should use default model when not specified', () => {
+      const aiServiceWithDefaults = new AIService({
+        apiKey: 'test-api-key'
+      });
+
+      expect((aiServiceWithDefaults as any).model).toBe('zai-org/GLM-4.5-FP8');
+    });
+  });
+
+  describe('generatePullRequestMessage', () => {
+    it('should return success with PR message when API call succeeds', async () => {
+      const mockResponse = {
+        choices: [{
+          message: {
+            content: 'Add caching layer\n\n## Summary\n- cache expensive queries to reduce latency\n\n## Testing\n- npm run test'
+          }
+        }]
+      };
+
+      (mockOpenai.chat.completions.create as jest.Mock).mockResolvedValue(mockResponse);
+
+      const diff = 'diff --git a/app.ts b/app.ts\nindex 123..456 100644';
+      const result = await aiService.generatePullRequestMessage('main', 'feature/cache', diff);
+
+      expect(result).toEqual({
+        success: true,
+        message: mockResponse.choices[0].message.content
+      });
+
+      expect(mockOpenai.chat.completions.create).toHaveBeenCalledWith({
+        model: 'gpt-4',
+        messages: [
+          {
+            role: 'system',
+            content: generatePullRequestPrompt('main', 'feature/cache', '', 'ko')
+          },
+          {
+            role: 'user',
+            content: `Git diff between main and feature/cache:\n${diff}`
+          }
+        ],
+        max_tokens: 4000,
+        temperature: 0.2
+      });
+    });
+
+    it('should return error when API returns no content', async () => {
+      const mockResponse = {
+        choices: [{
+          message: {
+            content: '',
+            reasoning_content: ''
+          }
+        }]
+      };
+
+      (mockOpenai.chat.completions.create as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await aiService.generatePullRequestMessage('main', 'feature/cache', 'diff');
+
+      expect(result).toEqual({
+        success: false,
+        error: 'No pull request message generated'
+      });
+    });
+
+    it('should return error when API call fails', async () => {
+      const error = new Error('API failure');
+      (mockOpenai.chat.completions.create as jest.Mock).mockRejectedValue(error);
+
+      const result = await aiService.generatePullRequestMessage('main', 'feature/cache', 'diff');
+
+      expect(result).toEqual({
+        success: false,
+        error: 'API failure'
+      });
+    });
+  });
+});

package/src/__tests__/commitCommand.test.ts

@@ -0,0 +1,155 @@
+import { CommitCommand } from '../commands/commit';
+import { GitService } from '../commands/git';
+import { AIService } from '../commands/ai';
+import { ConfigService } from '../commands/config';
+
+const mockGenerateCommitMessage = jest.fn();
+
+jest.mock('../commands/git', () => ({
+  GitService: {
+    getStagedDiff: jest.fn(),
+    createCommit: jest.fn(),
+    push: jest.fn()
+  }
+}));
+
+jest.mock('../commands/ai', () => ({
+  AIService: jest.fn().mockImplementation(() => ({
+    generateCommitMessage: mockGenerateCommitMessage
+  }))
+}));
+
+jest.mock('../commands/config', () => ({
+  ConfigService: {
+    getConfig: jest.fn(),
+    validateConfig: jest.fn()
+  }
+}));
+
+describe('CommitCommand', () => {
+  const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => undefined) as any);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (ConfigService.getConfig as jest.Mock).mockReturnValue({
+      apiKey: 'env-key',
+      baseURL: 'https://api.test',
+      model: 'test-model',
+      language: 'ko',
+      autoPush: false
+    });
+
+    (ConfigService.validateConfig as jest.Mock).mockReturnValue(undefined);
+
+    (GitService.getStagedDiff as jest.Mock).mockResolvedValue({
+      success: true,
+      diff: 'diff --git a/file b/file'
+    });
+
+    mockGenerateCommitMessage.mockResolvedValue({
+      success: true,
+      message: 'feat: test commit'
+    });
+  });
+
+  afterAll(() => {
+    exitSpy.mockRestore();
+  });
+
+  const createCommand = () => new CommitCommand();
+
+  it('should create commit after user confirmation', async () => {
+    (GitService.createCommit as jest.Mock).mockResolvedValue(true);
+
+    const command = createCommand();
+    const confirmSpy = jest
+      .spyOn(command as any, 'confirmCommit')
+      .mockResolvedValue(true);
+
+    await (command as any).handleCommit({});
+
+    expect(confirmSpy).toHaveBeenCalled();
+    expect(GitService.createCommit).toHaveBeenCalledWith('feat: test commit');
+    expect(GitService.push).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should skip commit when user declines confirmation', async () => {
+    const command = createCommand();
+    jest.spyOn(command as any, 'confirmCommit').mockResolvedValue(false);
+
+    await (command as any).handleCommit({});
+
+    expect(GitService.createCommit).not.toHaveBeenCalled();
+    expect(GitService.push).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should output message only without git actions when message-only option is set', async () => {
+    const command = createCommand();
+    const confirmSpy = jest.spyOn(command as any, 'confirmCommit');
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    try {
+      await (command as any).handleCommit({ messageOnly: true });
+
+      expect(confirmSpy).not.toHaveBeenCalled();
+      expect(GitService.createCommit).not.toHaveBeenCalled();
+      expect(GitService.push).not.toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalledTimes(1);
+      expect(logSpy).toHaveBeenCalledWith('feat: test commit');
+      expect(exitSpy).not.toHaveBeenCalled();
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('should commit and push when push option is provided', async () => {
+    (GitService.createCommit as jest.Mock).mockResolvedValue(true);
+    (GitService.push as jest.Mock).mockResolvedValue(true);
+
+    const command = createCommand();
+    jest.spyOn(command as any, 'confirmCommit').mockResolvedValue(true);
+
+    await (command as any).handleCommit({ push: true });
+
+    expect(GitService.createCommit).toHaveBeenCalledWith('feat: test commit');
+    expect(GitService.push).toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should exit when commit creation fails', async () => {
+    (GitService.createCommit as jest.Mock).mockResolvedValue(false);
+
+    const command = createCommand();
+    jest.spyOn(command as any, 'confirmCommit').mockResolvedValue(true);
+
+    await (command as any).handleCommit({});
+
+    expect(GitService.createCommit).toHaveBeenCalledWith('feat: test commit');
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('should push automatically when autoPush is enabled in config', async () => {
+    (GitService.createCommit as jest.Mock).mockResolvedValue(true);
+    (GitService.push as jest.Mock).mockResolvedValue(true);
+
+    (ConfigService.getConfig as jest.Mock).mockReturnValueOnce({
+      apiKey: 'env-key',
+      baseURL: 'https://api.test',
+      model: 'test-model',
+      language: 'ko',
+      autoPush: true
+    });
+
+    const command = createCommand();
+    jest.spyOn(command as any, 'confirmCommit').mockResolvedValue(true);
+
+    await (command as any).handleCommit({});
+
+    expect(GitService.createCommit).toHaveBeenCalledWith('feat: test commit');
+    expect(GitService.push).toHaveBeenCalledTimes(1);
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/config.test.ts

@@ -0,0 +1,238 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { ConfigService } from '../commands/config';
+
+describe('ConfigService', () => {
+  const originalEnv = process.env;
+  let tempDir: string;
+  let configPath: string;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = {
+      PATH: originalEnv.PATH,
+      NODE_ENV: 'test'
+    } as NodeJS.ProcessEnv;
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'git-ai-config-'));
+    configPath = path.join(tempDir, 'config.json');
+    process.env.GIT_AI_COMMIT_CONFIG_PATH = configPath;
+    if (fs.existsSync(configPath)) {
+      fs.rmSync(configPath, { force: true });
+    }
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(configPath)) {
+      fs.rmSync(configPath, { force: true });
+    }
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.env = originalEnv;
+  });
+
+  describe('getConfig', () => {
+
+    it('uses OPENAI_API_KEY values when present', () => {
+      process.env.OPENAI_API_KEY = 'test-api-key';
+      process.env.OPENAI_BASE_URL = 'https://api.test.com';
+      process.env.OPENAI_MODEL = 'gpt-4';
+
+      const config = ConfigService.getConfig();
+
+      expect(config).toEqual({
+        apiKey: 'test-api-key',
+        baseURL: 'https://api.test.com',
+        model: 'gpt-4',
+        mode: 'custom',
+        language: 'ko',
+        autoPush: false
+      });
+    });
+
+    it('falls back to AI_API_KEY when others are missing', () => {
+      process.env.AI_API_KEY = 'fallback-api-key';
+      process.env.AI_BASE_URL = 'https://fallback.test.com';
+      process.env.AI_MODEL = 'claude-3';
+
+      const config = ConfigService.getConfig();
+
+      expect(config).toEqual({
+        apiKey: 'fallback-api-key',
+        baseURL: 'https://fallback.test.com',
+        model: 'claude-3',
+        mode: 'custom',
+        language: 'ko',
+        autoPush: false
+      });
+    });
+
+    it('prefers AI_* variables over others in custom mode', () => {
+      process.env.AI_API_KEY = 'ai-key';
+      process.env.OPENAI_API_KEY = 'openai-key';
+      process.env.AI_BASE_URL = 'ai-url';
+      process.env.OPENAI_BASE_URL = 'openai-url';
+
+      const config = ConfigService.getConfig();
+
+      expect(config).toEqual({
+        apiKey: 'ai-key',
+        baseURL: 'ai-url',
+        model: 'zai-org/GLM-4.5-FP8',
+        mode: 'custom',
+        language: 'ko',
+        autoPush: false
+      });
+    });
+
+    it('uses OPENAI_* variables when mode is openai', () => {
+      process.env.AI_MODE = 'openai';
+      process.env.OPENAI_API_KEY = 'openai-key';
+      process.env.AI_API_KEY = 'ai-key';
+      process.env.OPENAI_BASE_URL = 'openai-url';
+      process.env.AI_BASE_URL = 'ai-url';
+      process.env.OPENAI_MODEL = 'gpt-4';
+      process.env.AI_MODEL = 'claude-3';
+
+      const config = ConfigService.getConfig();
+
+      expect(config).toEqual({
+        apiKey: 'openai-key',
+        baseURL: 'openai-url',
+        model: 'gpt-4',
+        mode: 'openai',
+        language: 'ko',
+        autoPush: false
+      });
+    });
+
+    it('falls back to AI_* variables in openai mode when OPENAI_* missing', () => {
+      process.env.AI_MODE = 'openai';
+      process.env.AI_API_KEY = 'ai-key';
+      process.env.AI_BASE_URL = 'ai-url';
+      process.env.AI_MODEL = 'claude-3';
+
+      const config = ConfigService.getConfig();
+
+      expect(config).toEqual({
+        apiKey: 'ai-key',
+        baseURL: 'ai-url',
+        model: 'claude-3',
+        mode: 'openai',
+        language: 'ko',
+        autoPush: false
+      });
+    });
+
+    it('uses default model when none provided', () => {
+      process.env.OPENAI_API_KEY = 'test-key';
+      delete process.env.OPENAI_MODEL;
+      delete process.env.AI_MODEL;
+
+      const config = ConfigService.getConfig();
+
+      expect(config.model).toBe('zai-org/GLM-4.5-FP8');
+      expect(config.mode).toBe('custom');
+    });
+
+    it('allows configuration file to override environment values', async () => {
+      process.env.AI_API_KEY = 'env-key';
+      process.env.AI_BASE_URL = 'https://env.example';
+      process.env.AI_MODEL = 'env-model';
+
+      await ConfigService.updateConfig({
+        apiKey: 'file-key',
+        baseURL: 'https://file.example',
+        model: 'file-model',
+        language: 'en',
+        autoPush: true,
+        mode: 'openai'
+      });
+
+      const config = ConfigService.getConfig();
+
+      expect(config).toEqual({
+        apiKey: 'file-key',
+        baseURL: 'https://file.example',
+        model: 'file-model',
+        mode: 'openai',
+        language: 'en',
+        autoPush: true
+      });
+    });
+
+    it('persists mode and model updates from config file', async () => {
+      await ConfigService.updateConfig({
+        apiKey: 'file-key',
+        baseURL: 'https://file.example',
+        model: 'gpt-4o-mini',
+        mode: 'openai'
+      });
+
+      const config = ConfigService.getConfig();
+
+      expect(config.model).toBe('gpt-4o-mini');
+      expect(config.mode).toBe('openai');
+    });
+
+    it('normalizes invalid mode values to the default', async () => {
+      const filePath = process.env.GIT_AI_COMMIT_CONFIG_PATH!;
+      fs.writeFileSync(filePath, JSON.stringify({ mode: 'invalid-mode' }));
+
+      const config = ConfigService.getConfig();
+
+      expect(config.mode).toBe('custom');
+    });
+
+    it('removes stored mode when resetting to the default', async () => {
+      await ConfigService.updateConfig({ mode: 'openai' });
+
+      let raw = fs.readFileSync(process.env.GIT_AI_COMMIT_CONFIG_PATH!, 'utf-8');
+      let parsed = JSON.parse(raw);
+      expect(parsed.mode).toBe('openai');
+
+      await ConfigService.updateConfig({ mode: 'custom' });
+
+      raw = fs.readFileSync(process.env.GIT_AI_COMMIT_CONFIG_PATH!, 'utf-8');
+      parsed = JSON.parse(raw);
+      expect(parsed.mode).toBeUndefined();
+    });
+  });
+
+  describe('validateConfig', () => {
+    it('does not throw for valid configuration', () => {
+      const config = {
+        apiKey: 'test-key',
+        language: 'ko'
+      };
+
+      expect(() => ConfigService.validateConfig(config)).not.toThrow();
+    });
+
+    it('throws when API key is missing', () => {
+      const config = {
+        apiKey: '',
+        language: 'en'
+      };
+
+      expect(() => ConfigService.validateConfig(config)).toThrow('API key is required');
+    });
+
+    it('throws when language is invalid', () => {
+      const config = {
+        apiKey: 'test',
+        language: 'jp'
+      } as any;
+
+      expect(() => ConfigService.validateConfig(config)).toThrow('Unsupported language. Use "ko" or "en".');
+    });
+
+    it('throws when merged configuration lacks API key', () => {
+      delete process.env.OPENAI_API_KEY;
+      delete process.env.AI_API_KEY;
+
+      const config = ConfigService.getConfig();
+
+      expect(() => ConfigService.validateConfig(config)).toThrow('API key is required');
+    });
+  });
+});

package/src/__tests__/git.test.ts

@@ -0,0 +1,88 @@
+import { GitService } from '../commands/git';
+
+// Mock the entire module at the top level
+jest.mock('../commands/git', () => {
+  const getStagedDiff = jest.fn().mockResolvedValue({
+    success: true,
+    diff: 'mock diff'
+  });
+  const createCommit = jest.fn().mockResolvedValue(true);
+
+  return {
+    GitService: {
+      getStagedDiff,
+      createCommit
+    }
+  };
+});
+
+describe('GitService', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getStagedDiff', () => {
+    it('should return success with diff when staged changes exist', async () => {
+      const mockDiff = 'diff --git a/file.txt b/file.txt\nnew file mode 100644';
+      
+      // Mock the implementation for this specific test
+      (GitService.getStagedDiff as jest.Mock).mockResolvedValueOnce({
+        success: true,
+        diff: mockDiff
+      });
+
+      const result = await GitService.getStagedDiff();
+
+      expect(result).toEqual({
+        success: true,
+        diff: mockDiff
+      });
+    });
+
+    it('should return error when no staged changes', async () => {
+      (GitService.getStagedDiff as jest.Mock).mockResolvedValueOnce({
+        success: false,
+        error: 'No staged changes found. Please stage your changes first.'
+      });
+
+      const result = await GitService.getStagedDiff();
+
+      expect(result).toEqual({
+        success: false,
+        error: 'No staged changes found. Please stage your changes first.'
+      });
+    });
+
+    it('should return error when git command fails', async () => {
+      (GitService.getStagedDiff as jest.Mock).mockResolvedValueOnce({
+        success: false,
+        error: 'Git command failed'
+      });
+
+      const result = await GitService.getStagedDiff();
+
+      expect(result).toEqual({
+        success: false,
+        error: 'Git command failed'
+      });
+    });
+  });
+
+  describe('createCommit', () => {
+    it('should return true when commit is successful', async () => {
+      (GitService.createCommit as jest.Mock).mockResolvedValueOnce(true);
+
+      const result = await GitService.createCommit('feat: add new feature');
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false when commit fails', async () => {
+      (GitService.createCommit as jest.Mock).mockResolvedValueOnce(false);
+
+      const result = await GitService.createCommit('feat: add new feature');
+
+      expect(result).toBe(false);
+    });
+  });
+});