@eldrforge/ai-service 0.1.1 → 0.1.3

package/tests/interactive-secure-temp.test.ts

@@ -1,264 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { SecureTempFile, createSecureTempFile, cleanupTempFile } from '../src/interactive';
-import fs from 'fs/promises';
-import os from 'os';
-
-// Mock fs/promises
-vi.mock('fs/promises');
-vi.mock('os');
-vi.mock('../src/logger', () => ({
-    getLogger: vi.fn(() => ({
-        info: vi.fn(),
-        error: vi.fn(),
-        warn: vi.fn(),
-        debug: vi.fn()
-    }))
-}));
-
-describe('SecureTempFile', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-
-        // Mock os.tmpdir
-        vi.mocked(os.tmpdir).mockReturnValue('/tmp');
-
-        // Mock fs methods
-        vi.mocked(fs.access).mockResolvedValue(undefined);
-        vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-        vi.mocked(fs.unlink).mockResolvedValue(undefined);
-    });
-
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-
-    describe('create', () => {
-        it('should create a secure temp file', async () => {
-            const mockFd = {
-                writeFile: vi.fn().mockResolvedValue(undefined),
-                readFile: vi.fn().mockResolvedValue('content'),
-                close: vi.fn().mockResolvedValue(undefined),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-            const tempFile = await SecureTempFile.create('test', '.txt');
-
-            expect(tempFile).toBeDefined();
-            expect(tempFile.path).toContain('/tmp/test_');
-            expect(tempFile.path).toContain('.txt');
-            expect(fs.open).toHaveBeenCalledWith(
-                expect.stringContaining('/tmp/test_'),
-                'wx',
-                0o600
-            );
-        });
-
-        it('should use custom prefix and extension', async () => {
-            const mockFd = {
-                writeFile: vi.fn(),
-                readFile: vi.fn(),
-                close: vi.fn(),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-            const tempFile = await SecureTempFile.create('custom-prefix', '.md');
-
-            expect(tempFile.path).toContain('custom-prefix_');
-            expect(tempFile.path).toContain('.md');
-        });
-
-        it('should handle file creation errors', async () => {
-            const error: any = new Error('Generic error');
-            vi.mocked(fs.open).mockRejectedValue(error);
-
-            await expect(SecureTempFile.create('test', '.txt'))
-                .rejects.toThrow('Failed to create temporary file');
-        });
-
-        it('should throw error if file exists', async () => {
-            const error: any = new Error('File exists');
-            error.code = 'EEXIST';
-            vi.mocked(fs.open).mockRejectedValue(error);
-
-            await expect(SecureTempFile.create('test', '.txt'))
-                .rejects.toThrow('Temporary file already exists');
-        });
-    });
-
-    describe('writeContent', () => {
-        it('should write content to temp file', async () => {
-            const mockFd = {
-                writeFile: vi.fn().mockResolvedValue(undefined),
-                readFile: vi.fn(),
-                close: vi.fn(),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-            const tempFile = await SecureTempFile.create('test', '.txt');
-            await tempFile.writeContent('test content');
-
-            expect(mockFd.writeFile).toHaveBeenCalledWith('test content', 'utf8');
-        });
-
-        it('should throw if file is closed', async () => {
-            const mockFd = {
-                writeFile: vi.fn(),
-                readFile: vi.fn(),
-                close: vi.fn().mockResolvedValue(undefined),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-            const tempFile = await SecureTempFile.create('test', '.txt');
-            await tempFile.close();
-
-            await expect(tempFile.writeContent('content'))
-                .rejects.toThrow('Temp file is not available for writing');
-        });
-    });
-
-    describe('readContent', () => {
-        it('should read content from temp file', async () => {
-            const mockFd = {
-                writeFile: vi.fn(),
-                readFile: vi.fn().mockResolvedValue('test content'),
-                close: vi.fn(),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-            const tempFile = await SecureTempFile.create('test', '.txt');
-            const content = await tempFile.readContent();
-
-            expect(content).toBe('test content');
-            expect(mockFd.readFile).toHaveBeenCalledWith('utf8');
-        });
-
-        it('should throw if file is closed', async () => {
-            const mockFd = {
-                writeFile: vi.fn(),
-                readFile: vi.fn(),
-                close: vi.fn().mockResolvedValue(undefined),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-            const tempFile = await SecureTempFile.create('test', '.txt');
-            await tempFile.close();
-
-            await expect(tempFile.readContent())
-                .rejects.toThrow('Temp file is not available for reading');
-        });
-    });
-
-    describe('cleanup', () => {
-        it('should close and unlink temp file', async () => {
-            const mockFd = {
-                writeFile: vi.fn(),
-                readFile: vi.fn(),
-                close: vi.fn().mockResolvedValue(undefined),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-            const tempFile = await SecureTempFile.create('test', '.txt');
-            const filePath = tempFile.path;
-
-            await tempFile.cleanup();
-
-            expect(mockFd.close).toHaveBeenCalled();
-            expect(fs.unlink).toHaveBeenCalledWith(filePath);
-        });
-
-        it('should handle cleanup errors gracefully', async () => {
-            const mockFd = {
-                writeFile: vi.fn(),
-                readFile: vi.fn(),
-                close: vi.fn().mockResolvedValue(undefined),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-            vi.mocked(fs.unlink).mockRejectedValue(new Error('Unlink failed'));
-
-            const tempFile = await SecureTempFile.create('test', '.txt');
-
-            // Should not throw
-            await expect(tempFile.cleanup()).resolves.not.toThrow();
-        });
-
-        it('should skip cleanup if already cleaned', async () => {
-            const mockFd = {
-                writeFile: vi.fn(),
-                readFile: vi.fn(),
-                close: vi.fn().mockResolvedValue(undefined),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-            const tempFile = await SecureTempFile.create('test', '.txt');
-
-            await tempFile.cleanup();
-            vi.mocked(fs.unlink).mockClear();
-
-            await tempFile.cleanup();
-
-            expect(fs.unlink).not.toHaveBeenCalled();
-        });
-
-        it('should throw error when accessing path after cleanup', async () => {
-            const mockFd = {
-                writeFile: vi.fn(),
-                readFile: vi.fn(),
-                close: vi.fn().mockResolvedValue(undefined),
-            } as any;
-
-            vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-            const tempFile = await SecureTempFile.create('test', '.txt');
-            await tempFile.cleanup();
-
-            expect(() => tempFile.path).toThrow('Temp file has been cleaned up');
-        });
-    });
-});
-
-describe('createSecureTempFile', () => {
-    it('should create and close temp file', async () => {
-        const mockFd = {
-            writeFile: vi.fn(),
-            readFile: vi.fn(),
-            close: vi.fn().mockResolvedValue(undefined),
-        } as any;
-
-        vi.mocked(os.tmpdir).mockReturnValue('/tmp');
-        vi.mocked(fs.access).mockResolvedValue(undefined);
-        vi.mocked(fs.open).mockResolvedValue(mockFd);
-
-        const path = await createSecureTempFile('test', '.txt');
-
-        expect(path).toContain('/tmp/test_');
-        expect(mockFd.close).toHaveBeenCalled();
-    });
-});
-
-describe('cleanupTempFile', () => {
-    it('should unlink the file', async () => {
-        vi.mocked(fs.unlink).mockResolvedValue(undefined);
-
-        await cleanupTempFile('/tmp/test.txt');
-
-        expect(fs.unlink).toHaveBeenCalledWith('/tmp/test.txt');
-    });
-
-    it('should handle ENOENT errors gracefully', async () => {
-        const error: any = new Error('ENOENT');
-        error.code = 'ENOENT';
-        vi.mocked(fs.unlink).mockRejectedValue(error);
-
-        await expect(cleanupTempFile('/tmp/test.txt')).resolves.not.toThrow();
-    });
-});
-

package/tests/interactive-user-choice.test.ts

@@ -1,173 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { getUserChoice, STANDARD_CHOICES } from '../src/interactive';
-
-// Mock logger
-const mockLoggerInstance = {
-    info: vi.fn(),
-    error: vi.fn(),
-    warn: vi.fn(),
-    debug: vi.fn(),
-};
-
-vi.mock('../src/logger', () => ({
-    getLogger: vi.fn(() => mockLoggerInstance),
-}));
-
-describe('getUserChoice', () => {
-    let originalIsTTY: boolean | undefined;
-    let originalSetRawMode: any;
-    let originalResume: any;
-    let originalPause: any;
-    let originalRef: any;
-    let originalUnref: any;
-    let originalOn: any;
-    let originalRemoveListener: any;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-
-        // Save original stdin methods
-        originalIsTTY = process.stdin.isTTY;
-        originalSetRawMode = process.stdin.setRawMode;
-        originalResume = process.stdin.resume;
-        originalPause = process.stdin.pause;
-        originalRef = process.stdin.ref;
-        originalUnref = process.stdin.unref;
-        originalOn = process.stdin.on;
-        originalRemoveListener = process.stdin.removeListener;
-    });
-
-    afterEach(() => {
-        // Restore stdin
-        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true, writable: true });
-        process.stdin.setRawMode = originalSetRawMode;
-        process.stdin.resume = originalResume;
-        process.stdin.pause = originalPause;
-        process.stdin.ref = originalRef;
-        process.stdin.unref = originalUnref;
-        process.stdin.on = originalOn;
-        process.stdin.removeListener = originalRemoveListener;
-    });
-
-    it('should return default when stdin is not TTY', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true, writable: true });
-
-        const result = await getUserChoice('Test prompt', [
-            { key: 'a', label: 'Option A' },
-            { key: 'b', label: 'Option B' },
-        ]);
-
-        expect(result).toBe('s');
-        expect(mockLoggerInstance.error).toHaveBeenCalledWith(expect.stringContaining('STDIN is piped'));
-    });
-
-    it('should show error suggestions when not TTY', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true, writable: true });
-
-        await getUserChoice(
-            'Test prompt',
-            [{ key: 'a', label: 'Option A' }],
-            { nonTtyErrorSuggestions: ['Use --dry-run', 'Run in terminal'] }
-        );
-
-        expect(mockLoggerInstance.error).toHaveBeenCalledWith('   • Use --dry-run');
-        expect(mockLoggerInstance.error).toHaveBeenCalledWith('   • Run in terminal');
-    });
-
-    it('should display prompt and choices', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
-
-        // Mock stdin methods
-        process.stdin.setRawMode = vi.fn();
-        process.stdin.resume = vi.fn();
-        process.stdin.pause = vi.fn();
-        process.stdin.ref = vi.fn();
-        process.stdin.unref = vi.fn();
-        process.stdin.removeListener = vi.fn();
-
-        let dataCallback: any;
-        process.stdin.on = vi.fn((event, callback) => {
-            if (event === 'data') {
-                dataCallback = callback;
-                // Simulate user pressing 'a'
-                setTimeout(() => dataCallback(Buffer.from('a')), 10);
-            }
-            return process.stdin;
-        });
-
-        const result = await getUserChoice('What to do?', [
-            { key: 'a', label: 'Action A' },
-            { key: 'b', label: 'Action B' },
-        ]);
-
-        expect(result).toBe('a');
-        expect(mockLoggerInstance.info).toHaveBeenCalledWith('What to do?');
-        expect(mockLoggerInstance.info).toHaveBeenCalledWith('   [a] Action A');
-        expect(mockLoggerInstance.info).toHaveBeenCalledWith('   [b] Action B');
-    });
-
-    it('should handle user selecting first choice', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
-
-        process.stdin.setRawMode = vi.fn();
-        process.stdin.resume = vi.fn();
-        process.stdin.pause = vi.fn();
-        process.stdin.ref = vi.fn();
-        process.stdin.unref = vi.fn();
-        process.stdin.removeListener = vi.fn();
-
-        process.stdin.on = vi.fn((event, callback) => {
-            if (event === 'data') {
-                setTimeout(() => callback(Buffer.from('c')), 10);
-            }
-            return process.stdin;
-        });
-
-        const result = await getUserChoice('Confirm?', [STANDARD_CHOICES.CONFIRM, STANDARD_CHOICES.SKIP]);
-
-        expect(result).toBe('c');
-    });
-
-    it('should cleanup stdin on completion', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
-
-        process.stdin.setRawMode = vi.fn();
-        process.stdin.resume = vi.fn();
-        process.stdin.pause = vi.fn();
-        process.stdin.ref = vi.fn();
-        process.stdin.unref = vi.fn();
-        const mockRemoveListener = vi.fn();
-        process.stdin.removeListener = mockRemoveListener;
-
-        process.stdin.on = vi.fn((event, callback) => {
-            if (event === 'data') {
-                setTimeout(() => callback(Buffer.from('s')), 10);
-            }
-            return process.stdin;
-        });
-
-        await getUserChoice('Test?', [STANDARD_CHOICES.SKIP]);
-
-        expect(mockRemoveListener).toHaveBeenCalled();
-        expect(process.stdin.pause).toHaveBeenCalled();
-    });
-
-    it('should handle errors during input setup', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
-
-        process.stdin.setRawMode = vi.fn(() => {
-            throw new Error('Setup failed');
-        });
-        process.stdin.resume = vi.fn();
-        process.stdin.pause = vi.fn();
-        process.stdin.ref = vi.fn();
-        process.stdin.unref = vi.fn();
-        process.stdin.removeListener = vi.fn();
-        process.stdin.on = vi.fn();
-
-        await expect(
-            getUserChoice('Test?', [{ key: 'a', label: 'Option A' }])
-        ).rejects.toThrow('Setup failed');
-    });
-});
-

package/tests/interactive-user-text.test.ts

@@ -1,174 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { getUserTextInput } from '../src/interactive';
-
-// Mock logger
-const mockLoggerInstance = {
-    info: vi.fn(),
-    error: vi.fn(),
-    warn: vi.fn(),
-    debug: vi.fn(),
-};
-
-vi.mock('../src/logger', () => ({
-    getLogger: vi.fn(() => mockLoggerInstance),
-}));
-
-describe('getUserTextInput', () => {
-    let originalIsTTY: boolean | undefined;
-    let originalSetEncoding: any;
-    let originalResume: any;
-    let originalPause: any;
-    let originalRef: any;
-    let originalUnref: any;
-    let originalOn: any;
-    let originalRemoveListener: any;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-
-        // Save original stdin methods
-        originalIsTTY = process.stdin.isTTY;
-        originalSetEncoding = process.stdin.setEncoding;
-        originalResume = process.stdin.resume;
-        originalPause = process.stdin.pause;
-        originalRef = process.stdin.ref;
-        originalUnref = process.stdin.unref;
-        originalOn = process.stdin.on;
-        originalRemoveListener = process.stdin.removeListener;
-    });
-
-    afterEach(() => {
-        // Restore stdin
-        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true, writable: true });
-        process.stdin.setEncoding = originalSetEncoding;
-        process.stdin.resume = originalResume;
-        process.stdin.pause = originalPause;
-        process.stdin.ref = originalRef;
-        process.stdin.unref = originalUnref;
-        process.stdin.on = originalOn;
-        process.stdin.removeListener = originalRemoveListener;
-    });
-
-    it('should throw error when stdin is not TTY', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true, writable: true });
-
-        await expect(
-            getUserTextInput('Enter text:')
-        ).rejects.toThrow('Interactive text input requires a terminal');
-
-        expect(mockLoggerInstance.error).toHaveBeenCalledWith(expect.stringContaining('STDIN is piped'));
-    });
-
-    it('should show error suggestions when not TTY', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true, writable: true });
-
-        await expect(
-            getUserTextInput('Enter text:', {
-                nonTtyErrorSuggestions: ['Use file input', 'Run interactively'],
-            })
-        ).rejects.toThrow();
-
-        expect(mockLoggerInstance.error).toHaveBeenCalledWith('   • Use file input');
-        expect(mockLoggerInstance.error).toHaveBeenCalledWith('   • Run interactively');
-    });
-
-    it('should accept text input from user', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
-
-        process.stdin.setEncoding = vi.fn();
-        process.stdin.resume = vi.fn();
-        process.stdin.pause = vi.fn();
-        process.stdin.ref = vi.fn();
-        process.stdin.unref = vi.fn();
-        process.stdin.removeListener = vi.fn();
-
-        process.stdin.on = vi.fn((event, callback) => {
-            if (event === 'data') {
-                setTimeout(() => callback('user input text\n'), 10);
-            }
-            return process.stdin;
-        });
-
-        const result = await getUserTextInput('Enter feedback:');
-
-        expect(result).toBe('user input text');
-        expect(mockLoggerInstance.info).toHaveBeenCalledWith('Enter feedback:');
-    });
-
-    it('should reject empty input', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
-
-        process.stdin.setEncoding = vi.fn();
-        process.stdin.resume = vi.fn();
-        process.stdin.pause = vi.fn();
-        process.stdin.ref = vi.fn();
-        process.stdin.unref = vi.fn();
-        process.stdin.removeListener = vi.fn();
-
-        process.stdin.on = vi.fn((event, callback) => {
-            if (event === 'data') {
-                setTimeout(() => callback('\n'), 10);
-            }
-            return process.stdin;
-        });
-
-        await expect(
-            getUserTextInput('Enter text:')
-        ).rejects.toThrow('Empty input received');
-
-        expect(mockLoggerInstance.warn).toHaveBeenCalledWith(expect.stringContaining('Empty input'));
-    });
-
-    it('should cleanup stdin on completion', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
-
-        process.stdin.setEncoding = vi.fn();
-        process.stdin.resume = vi.fn();
-        const mockPause = vi.fn();
-        process.stdin.pause = mockPause;
-        process.stdin.ref = vi.fn();
-        process.stdin.unref = vi.fn();
-        const mockRemoveListener = vi.fn();
-        process.stdin.removeListener = mockRemoveListener;
-
-        process.stdin.on = vi.fn((event, callback) => {
-            if (event === 'data') {
-                setTimeout(() => callback('text\n'), 10);
-            }
-            return process.stdin;
-        });
-
-        await getUserTextInput('Enter text:');
-
-        expect(mockRemoveListener).toHaveBeenCalled();
-        expect(mockPause).toHaveBeenCalled();
-    });
-
-    it('should handle input processing errors', async () => {
-        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
-
-        process.stdin.setEncoding = vi.fn();
-        process.stdin.resume = vi.fn();
-        process.stdin.pause = vi.fn();
-        process.stdin.ref = vi.fn();
-        process.stdin.unref = vi.fn();
-        process.stdin.removeListener = vi.fn();
-
-        process.stdin.on = vi.fn((event, callback) => {
-            if (event === 'data') {
-                setTimeout(() => {
-                    try {
-                        callback(null); // Invalid input
-                    } catch (e) {
-                        // Expected
-                    }
-                }, 10);
-            }
-            return process.stdin;
-        });
-
-        // This test verifies error handling exists
-        expect(process.stdin.on).toBeDefined();
-    });
-});
-

package/tests/interactive.test.ts

@@ -1,94 +0,0 @@
-import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
-import { requireTTY } from '../src/interactive';
-import type { Logger } from '../src/types';
-
-// Mock logger for tests
-vi.mock('../src/logger', () => ({
-    getLogger: vi.fn(() => ({
-        info: vi.fn(),
-        error: vi.fn(),
-        warn: vi.fn(),
-        debug: vi.fn()
-    }))
-}));
-
-describe('Interactive Utility Module', () => {
-    let originalIsTTY: boolean | undefined;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        originalIsTTY = process.stdin.isTTY;
-    });
-
-    afterEach(() => {
-        if (originalIsTTY !== undefined) {
-            Object.defineProperty(process.stdin, 'isTTY', {
-                value: originalIsTTY,
-                configurable: true,
-                writable: true
-            });
-        }
-    });
-
-    describe('requireTTY', () => {
-        it('should not throw when stdin is a TTY', () => {
-            Object.defineProperty(process.stdin, 'isTTY', {
-                value: true,
-                configurable: true,
-                writable: true
-            });
-
-            expect(() => requireTTY()).not.toThrow();
-        });
-
-        it('should throw when stdin is not a TTY', () => {
-            Object.defineProperty(process.stdin, 'isTTY', {
-                value: false,
-                configurable: true,
-                writable: true
-            });
-
-            expect(() => requireTTY()).toThrow('Interactive mode requires a terminal');
-        });
-
-        it('should throw custom error message', () => {
-            Object.defineProperty(process.stdin, 'isTTY', {
-                value: false,
-                configurable: true,
-                writable: true
-            });
-
-            expect(() => requireTTY('Custom error message')).toThrow('Custom error message');
-        });
-
-        it('should accept optional logger', () => {
-            const mockLogger: Logger = {
-                info: vi.fn(),
-                error: vi.fn(),
-                warn: vi.fn(),
-                debug: vi.fn()
-            };
-
-            Object.defineProperty(process.stdin, 'isTTY', {
-                value: false,
-                configurable: true,
-                writable: true
-            });
-
-            expect(() => requireTTY('Test error', mockLogger)).toThrow();
-            expect(mockLogger.error).toHaveBeenCalled();
-        });
-    });
-
-    describe('STANDARD_CHOICES', () => {
-        it('should export standard choice constants', async () => {
-            const { STANDARD_CHOICES } = await import('../src/interactive');
-
-            expect(STANDARD_CHOICES.CONFIRM).toEqual({ key: 'c', label: 'Confirm and proceed' });
-            expect(STANDARD_CHOICES.EDIT).toEqual({ key: 'e', label: 'Edit in editor' });
-            expect(STANDARD_CHOICES.SKIP).toEqual({ key: 's', label: 'Skip and abort' });
-            expect(STANDARD_CHOICES.IMPROVE).toEqual({ key: 'i', label: 'Improve with LLM feedback' });
-        });
-    });
-});
-