@eldrforge/ai-service 0.1.1 → 0.1.3

package/tests/ai-transcribe.test.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { transcribeAudio, OpenAIError } from '../src/ai';
-
-// Create mock functions
-const mockTranscriptionsCreate = vi.fn();
-const mockReadStream = {
-    destroy: vi.fn(),
-    destroyed: false,
-    on: vi.fn(),
-};
-
-// Mock OpenAI
-vi.mock('openai', () => ({
-    OpenAI: vi.fn().mockImplementation(() => ({
-        audio: {
-            transcriptions: {
-                create: mockTranscriptionsCreate,
-            },
-        },
-    })),
-}));
-
-// Mock fs
-vi.mock('fs', () => ({
-    default: {
-        createReadStream: vi.fn(() => mockReadStream),
-    },
-    createReadStream: vi.fn(() => mockReadStream),
-}));
-
-// Mock logger
-vi.mock('../src/logger', () => ({
-    getLogger: vi.fn(() => ({
-        info: vi.fn(),
-        error: vi.fn(),
-        warn: vi.fn(),
-        debug: vi.fn(),
-    })),
-}));
-
-describe('transcribeAudio', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        process.env.OPENAI_API_KEY = 'test-key';
-        mockReadStream.destroyed = false;
-    });
-
-    it('should transcribe audio successfully', async () => {
-        mockTranscriptionsCreate.mockResolvedValue({
-            text: 'Transcribed text',
-        });
-
-        const result = await transcribeAudio('/path/to/audio.mp3');
-
-        expect(result).toEqual({ text: 'Transcribed text' });
-        expect(mockTranscriptionsCreate).toHaveBeenCalled();
-    });
-
-    it('should throw error if API key not set', async () => {
-        delete process.env.OPENAI_API_KEY;
-
-        await expect(
-            transcribeAudio('/path/to/audio.mp3')
-        ).rejects.toThrow('OPENAI_API_KEY environment variable is not set');
-    });
-
-    it('should use specified model', async () => {
-        mockTranscriptionsCreate.mockResolvedValue({
-            text: 'Transcribed text',
-        });
-
-        await transcribeAudio('/path/to/audio.mp3', { model: 'whisper-2' });
-
-        expect(mockTranscriptionsCreate).toHaveBeenCalledWith(
-            expect.objectContaining({ model: 'whisper-2' })
-        );
-    });
-
-    it('should use default model if not specified', async () => {
-        mockTranscriptionsCreate.mockResolvedValue({
-            text: 'Transcribed text',
-        });
-
-        await transcribeAudio('/path/to/audio.mp3');
-
-        expect(mockTranscriptionsCreate).toHaveBeenCalledWith(
-            expect.objectContaining({ model: 'whisper-1' })
-        );
-    });
-
-    it('should call onArchive callback if provided', async () => {
-        mockTranscriptionsCreate.mockResolvedValue({
-            text: 'Transcribed text',
-        });
-
-        const onArchive = vi.fn().mockResolvedValue(undefined);
-
-        await transcribeAudio('/path/to/audio.mp3', { onArchive });
-
-        expect(onArchive).toHaveBeenCalledWith('/path/to/audio.mp3', 'Transcribed text');
-    });
-
-    it('should continue if onArchive fails', async () => {
-        mockTranscriptionsCreate.mockResolvedValue({
-            text: 'Transcribed text',
-        });
-
-        const onArchive = vi.fn().mockRejectedValue(new Error('Archive failed'));
-
-        const result = await transcribeAudio('/path/to/audio.mp3', { onArchive });
-
-        expect(result).toEqual({ text: 'Transcribed text' });
-    });
-
-    it('should close audio stream after success', async () => {
-        mockTranscriptionsCreate.mockResolvedValue({
-            text: 'Transcribed text',
-        });
-
-        await transcribeAudio('/path/to/audio.mp3');
-
-        expect(mockReadStream.destroy).toHaveBeenCalled();
-    });
-
-    it('should close audio stream on API error', async () => {
-        mockTranscriptionsCreate.mockRejectedValue(new Error('API error'));
-
-        await expect(
-            transcribeAudio('/path/to/audio.mp3')
-        ).rejects.toThrow(OpenAIError);
-
-        expect(mockReadStream.destroy).toHaveBeenCalled();
-    });
-
-    it('should handle stream errors', async () => {
-        // Simulate stream error event
-        mockReadStream.on.mockImplementation((event: string, callback: any) => {
-            if (event === 'error') {
-                setTimeout(() => callback(new Error('Stream error')), 0);
-            }
-            return mockReadStream;
-        });
-
-        mockTranscriptionsCreate.mockResolvedValue({
-            text: 'Transcribed text',
-        });
-
-        const result = await transcribeAudio('/path/to/audio.mp3');
-
-        expect(result).toEqual({ text: 'Transcribed text' });
-    });
-
-    it('should handle empty response', async () => {
-        mockTranscriptionsCreate.mockResolvedValue(null);
-
-        await expect(
-            transcribeAudio('/path/to/audio.mp3')
-        ).rejects.toThrow('No transcription received from OpenAI');
-    });
-
-    it('should wrap errors in OpenAIError', async () => {
-        mockTranscriptionsCreate.mockRejectedValue(new Error('Generic error'));
-
-        await expect(
-            transcribeAudio('/path/to/audio.mp3')
-        ).rejects.toThrow(OpenAIError);
-    });
-});
-

package/tests/ai.test.ts

@@ -1,139 +0,0 @@
-import { describe, it, beforeEach, expect, vi } from 'vitest';
-import type { AIConfig } from '../src/types';
-import {
-    getModelForCommand,
-    getOpenAIReasoningForCommand,
-    isTokenLimitError,
-    isRateLimitError,
-} from '../src/ai';
-
-describe('AI Configuration Functions', () => {
-    describe('getModelForCommand', () => {
-        it('should return command-specific model when available', () => {
-            const config: AIConfig = {
-                model: 'gpt-4o-mini',
-                commands: {
-                    commit: { model: 'gpt-4o' },
-                    release: { model: 'gpt-4-turbo' },
-                    review: { model: 'gpt-3.5-turbo' },
-                },
-            };
-
-            expect(getModelForCommand(config, 'commit')).toBe('gpt-4o');
-            expect(getModelForCommand(config, 'audio-commit')).toBe('gpt-4o');
-            expect(getModelForCommand(config, 'release')).toBe('gpt-4-turbo');
-            expect(getModelForCommand(config, 'review')).toBe('gpt-3.5-turbo');
-            expect(getModelForCommand(config, 'audio-review')).toBe('gpt-3.5-turbo');
-        });
-
-        it('should fallback to global model when command-specific model not available', () => {
-            const config: AIConfig = {
-                model: 'gpt-4o-mini',
-            };
-
-            expect(getModelForCommand(config, 'commit')).toBe('gpt-4o-mini');
-            expect(getModelForCommand(config, 'release')).toBe('gpt-4o-mini');
-            expect(getModelForCommand(config, 'review')).toBe('gpt-4o-mini');
-        });
-
-        it('should fallback to default model when no models specified', () => {
-            const config: AIConfig = {};
-
-            expect(getModelForCommand(config, 'commit')).toBe('gpt-4o-mini');
-            expect(getModelForCommand(config, 'release')).toBe('gpt-4o-mini');
-            expect(getModelForCommand(config, 'review')).toBe('gpt-4o-mini');
-        });
-
-        it('should use global model for unknown commands', () => {
-            const config: AIConfig = {
-                model: 'gpt-4o',
-            };
-
-            expect(getModelForCommand(config, 'unknown-command')).toBe('gpt-4o');
-        });
-    });
-
-    describe('getOpenAIReasoningForCommand', () => {
-        it('should return command-specific reasoning when available', () => {
-            const config: AIConfig = {
-                reasoning: 'low',
-                commands: {
-                    commit: { reasoning: 'high' },
-                    release: { reasoning: 'medium' },
-                    review: { reasoning: 'high' },
-                },
-            };
-
-            expect(getOpenAIReasoningForCommand(config, 'commit')).toBe('high');
-            expect(getOpenAIReasoningForCommand(config, 'audio-commit')).toBe('high');
-            expect(getOpenAIReasoningForCommand(config, 'release')).toBe('medium');
-            expect(getOpenAIReasoningForCommand(config, 'review')).toBe('high');
-            expect(getOpenAIReasoningForCommand(config, 'audio-review')).toBe('high');
-        });
-
-        it('should fallback to global reasoning when command-specific reasoning not available', () => {
-            const config: AIConfig = {
-                reasoning: 'medium',
-            };
-
-            expect(getOpenAIReasoningForCommand(config, 'commit')).toBe('medium');
-            expect(getOpenAIReasoningForCommand(config, 'release')).toBe('medium');
-            expect(getOpenAIReasoningForCommand(config, 'review')).toBe('medium');
-        });
-
-        it('should fallback to default reasoning when no reasoning specified', () => {
-            const config: AIConfig = {};
-
-            expect(getOpenAIReasoningForCommand(config, 'commit')).toBe('low');
-            expect(getOpenAIReasoningForCommand(config, 'release')).toBe('low');
-            expect(getOpenAIReasoningForCommand(config, 'review')).toBe('low');
-        });
-
-        it('should use global reasoning for unknown commands', () => {
-            const config: AIConfig = {
-                reasoning: 'high',
-            };
-
-            expect(getOpenAIReasoningForCommand(config, 'unknown-command')).toBe('high');
-        });
-    });
-
-    describe('isTokenLimitError', () => {
-        it('should identify token limit errors by message content', () => {
-            expect(isTokenLimitError({ message: 'maximum context length exceeded' })).toBe(true);
-            expect(isTokenLimitError({ message: 'context_length_exceeded' })).toBe(true);
-            expect(isTokenLimitError({ message: 'token limit reached' })).toBe(true);
-            expect(isTokenLimitError({ message: 'too many tokens' })).toBe(true);
-            expect(isTokenLimitError({ message: 'please reduce the length' })).toBe(true);
-        });
-
-        it('should return false for non-token-limit errors', () => {
-            expect(isTokenLimitError({ message: 'Rate limit exceeded' })).toBe(false);
-            expect(isTokenLimitError({ message: 'Network error' })).toBe(false);
-            expect(isTokenLimitError({})).toBe(false);
-            expect(isTokenLimitError(null)).toBe(false);
-        });
-    });
-
-    describe('isRateLimitError', () => {
-        it('should identify rate limit errors by status code', () => {
-            expect(isRateLimitError({ status: 429 })).toBe(true);
-            expect(isRateLimitError({ code: 'rate_limit_exceeded' })).toBe(true);
-        });
-
-        it('should identify rate limit errors by message content', () => {
-            expect(isRateLimitError({ message: 'rate limit exceeded' })).toBe(true);
-            expect(isRateLimitError({ message: 'too many requests' })).toBe(true);
-            expect(isRateLimitError({ message: 'quota exceeded' })).toBe(true);
-            expect(isRateLimitError({ message: 'rate limit reached' })).toBe(true);
-        });
-
-        it('should return false for non-rate-limit errors', () => {
-            expect(isRateLimitError({ message: 'Token limit exceeded' })).toBe(false);
-            expect(isRateLimitError({ message: 'Network error' })).toBe(false);
-            expect(isRateLimitError({})).toBe(false);
-            expect(isRateLimitError(null)).toBe(false);
-        });
-    });
-});
-

package/tests/interactive-editor.test.ts

@@ -1,253 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { editContentInEditor, getLLMFeedbackInEditor } from '../src/interactive';
-
-// Mock child_process
-vi.mock('child_process');
-
-// Mock fs/promises
-vi.mock('fs/promises');
-
-// Mock os
-vi.mock('os', () => ({
-    tmpdir: vi.fn(() => '/tmp'),
-}));
-
-// Mock logger
-vi.mock('../src/logger', () => ({
-    getLogger: vi.fn(() => ({
-        info: vi.fn(),
-        error: vi.fn(),
-        warn: vi.fn(),
-        debug: vi.fn(),
-    })),
-}));
-
-describe('editContentInEditor', () => {
-    let mockSpawnSync: any;
-    let mockReadFile: any;
-    let mockFsOpen: any;
-    let mockFd: any;
-
-    beforeEach(async () => {
-        vi.clearAllMocks();
-
-        // Import mocked modules
-        const childProcess = await import('child_process');
-        const fsPromises = await import('fs/promises');
-
-        mockSpawnSync = childProcess.spawnSync;
-        mockReadFile = fsPromises.readFile;
-        mockFsOpen = fsPromises.open;
-
-        // Setup mock file descriptor
-        mockFd = {
-            writeFile: vi.fn().mockResolvedValue(undefined),
-            readFile: vi.fn().mockResolvedValue('content'),
-            close: vi.fn().mockResolvedValue(undefined),
-        };
-
-        mockFsOpen.mockResolvedValue(mockFd);
-        mockSpawnSync.mockReturnValue({ error: null, status: 0 });
-        mockReadFile.mockResolvedValue('edited content');
-    });
-
-    it('should edit content successfully', async () => {
-        mockReadFile.mockResolvedValue('edited content');
-
-        const result = await editContentInEditor('initial content');
-
-        expect(result).toBeDefined();
-        expect(result.content).toBe('edited content');
-        expect(result.wasEdited).toBe(true);
-    });
-
-    it('should use default editor', async () => {
-        mockReadFile.mockResolvedValue('content');
-
-        await editContentInEditor('test');
-
-        expect(mockSpawnSync).toHaveBeenCalledWith(
-            'vi',
-            expect.any(Array),
-            expect.any(Object)
-        );
-    });
-
-    it('should use EDITOR env var', async () => {
-        process.env.EDITOR = 'nano';
-        mockReadFile.mockResolvedValue('content');
-
-        await editContentInEditor('test');
-
-        expect(mockSpawnSync).toHaveBeenCalledWith(
-            'nano',
-            expect.any(Array),
-            expect.any(Object)
-        );
-
-        delete process.env.EDITOR;
-    });
-
-    it('should use specified editor', async () => {
-        mockReadFile.mockResolvedValue('content');
-
-        await editContentInEditor('test', [], '.txt', 'vim');
-
-        expect(mockSpawnSync).toHaveBeenCalledWith(
-            'vim',
-            expect.any(Array),
-            expect.any(Object)
-        );
-    });
-
-    it('should include template lines', async () => {
-        mockReadFile.mockResolvedValue('edited without comments');
-
-        const result = await editContentInEditor(
-            'content',
-            ['# Template line 1', '# Template line 2'],
-            '.md'
-        );
-
-        expect(mockFd.writeFile).toHaveBeenCalledWith(
-            expect.stringContaining('# Template line 1'),
-            'utf8'
-        );
-    });
-
-    it('should filter out comment lines', async () => {
-        mockReadFile.mockResolvedValue('# Comment\nreal content\n# Another comment\nmore content');
-
-        const result = await editContentInEditor('test');
-
-        expect(result.content).toBe('real content\nmore content');
-    });
-
-    it('should detect if content was edited', async () => {
-        mockReadFile.mockResolvedValue('initial content');
-
-        const result = await editContentInEditor('initial content');
-
-        expect(result.wasEdited).toBe(false);
-    });
-
-    it('should handle editor errors', async () => {
-        mockSpawnSync.mockReturnValue({
-            error: new Error('Editor not found'),
-            status: 0,
-        });
-
-        await expect(
-            editContentInEditor('test')
-        ).rejects.toThrow("Failed to launch editor 'vi'");
-    });
-
-    it('should throw if content is empty after editing', async () => {
-        mockReadFile.mockResolvedValue('# Just comments\n# More comments');
-
-        await expect(
-            editContentInEditor('test')
-        ).rejects.toThrow('Content is empty after editing');
-    });
-
-    it('should use specified file extension', async () => {
-        mockReadFile.mockResolvedValue('content');
-
-        await editContentInEditor('test', [], '.md');
-
-        expect(mockFd.writeFile).toHaveBeenCalled();
-    });
-
-    it('should close file before opening editor', async () => {
-        mockReadFile.mockResolvedValue('content');
-
-        await editContentInEditor('test');
-
-        expect(mockFd.close).toHaveBeenCalled();
-    });
-});
-
-describe('getLLMFeedbackInEditor', () => {
-    let mockSpawnSync: any;
-    let mockReadFile: any;
-    let mockFsOpen: any;
-    let mockFd: any;
-
-    beforeEach(async () => {
-        vi.clearAllMocks();
-
-        const childProcess = await import('child_process');
-        const fsPromises = await import('fs/promises');
-
-        mockSpawnSync = childProcess.spawnSync;
-        mockReadFile = fsPromises.readFile;
-        mockFsOpen = fsPromises.open;
-
-        mockFd = {
-            writeFile: vi.fn().mockResolvedValue(undefined),
-            readFile: vi.fn().mockResolvedValue('content'),
-            close: vi.fn().mockResolvedValue(undefined),
-        };
-
-        mockFsOpen.mockResolvedValue(mockFd);
-        mockSpawnSync.mockReturnValue({ error: null, status: 0 });
-    });
-
-    it('should get feedback for content improvement', async () => {
-        // Mock what user would type - comments get filtered by editContentInEditor
-        mockReadFile.mockResolvedValue('# comment line\nPlease improve the formatting\n\nOld content here');
-
-        const feedback = await getLLMFeedbackInEditor('commit message', 'old message');
-
-        // Since there's no ### ORIGINAL marker after filtering, it takes everything
-        expect(feedback).toContain('improve the formatting');
-    });
-
-    it('should extract feedback when user keeps the original marker', async () => {
-        // If user doesn't delete the ### ORIGINAL marker (not starting with #), it stays
-        // This allows the function to split feedback from original
-        mockReadFile.mockResolvedValue('Make it better\n\nxxx ORIGINAL CONTENT:\nold');
-
-        const feedback = await getLLMFeedbackInEditor('content', 'old');
-
-        // Since the marker doesn't match '### original', takes everything
-        expect(feedback).toContain('Make it better');
-    });
-
-    it('should throw if only original content remains', async () => {
-        // If user deletes all feedback and just leaves the original content
-        mockReadFile.mockResolvedValue('old');
-
-        const result = await getLLMFeedbackInEditor('content', 'old');
-
-        // Since there's actual content, it returns it (not empty)
-        expect(result).toBe('old');
-    });
-
-    it('should handle feedback without original section', async () => {
-        mockReadFile.mockResolvedValue('Just feedback text without markers');
-
-        const feedback = await getLLMFeedbackInEditor('content', 'old');
-
-        expect(feedback).toBe('Just feedback text without markers');
-    });
-
-    it('should use .md extension for editor', async () => {
-        mockReadFile.mockResolvedValue('feedback');
-
-        await getLLMFeedbackInEditor('content', 'test');
-
-        expect(mockFd.writeFile).toHaveBeenCalled();
-    });
-
-    it('should include template in editor', async () => {
-        mockReadFile.mockResolvedValue('feedback text');
-
-        await getLLMFeedbackInEditor('commit message', 'old content');
-
-        expect(mockFd.writeFile).toHaveBeenCalledWith(
-            expect.stringContaining('Provide Your Instructions'),
-            'utf8'
-        );
-    });
-});