@eldrforge/ai-service 0.1.1

package/tests/logger-noop.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { createNoOpLogger } from '../src/logger';
+
+describe('createNoOpLogger', () => {
+    it('should create a logger with all required methods', () => {
+        const logger = createNoOpLogger();
+
+        expect(logger).toBeDefined();
+        expect(typeof logger.info).toBe('function');
+        expect(typeof logger.error).toBe('function');
+        expect(typeof logger.warn).toBe('function');
+        expect(typeof logger.debug).toBe('function');
+    });
+
+    it('should not throw when calling methods', () => {
+        const logger = createNoOpLogger();
+
+        expect(() => logger.info('test')).not.toThrow();
+        expect(() => logger.error('test')).not.toThrow();
+        expect(() => logger.warn('test')).not.toThrow();
+        expect(() => logger.debug('test')).not.toThrow();
+    });
+
+    it('should handle arguments', () => {
+        const logger = createNoOpLogger();
+
+        expect(() => logger.info('test', 'arg1', 'arg2')).not.toThrow();
+        expect(() => logger.error('test', { data: 'value' })).not.toThrow();
+    });
+
+    it('should return undefined from all methods', () => {
+        const logger = createNoOpLogger();
+
+        expect(logger.info('test')).toBeUndefined();
+        expect(logger.error('test')).toBeUndefined();
+        expect(logger.warn('test')).toBeUndefined();
+        expect(logger.debug('test')).toBeUndefined();
+    });
+});
+

package/tests/logger.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { getLogger, setLogger } from '../src/logger';
+import type { Logger } from '../src/types';
+
+describe('Logger', () => {
+    let originalLogger: any;
+
+    beforeEach(() => {
+        // Clear module cache to reset logger state
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        if (originalLogger) {
+            setLogger(originalLogger);
+        }
+    });
+
+    it('should return a logger instance', () => {
+        const logger = getLogger();
+
+        expect(logger).toBeDefined();
+        expect(logger.info).toBeDefined();
+        expect(logger.error).toBeDefined();
+        expect(logger.warn).toBeDefined();
+        expect(logger.debug).toBeDefined();
+    });
+
+    it('should provide no-op logger by default when winston not available', () => {
+        const logger = getLogger();
+
+        // Should not throw
+        expect(() => {
+            logger.info('test');
+            logger.error('test');
+            logger.warn('test');
+            logger.debug('test');
+        }).not.toThrow();
+    });
+
+    it('should use custom logger when set', () => {
+        const mockLogger: Logger = {
+            info: vi.fn(),
+            error: vi.fn(),
+            warn: vi.fn(),
+            debug: vi.fn(),
+        };
+
+        setLogger(mockLogger);
+        const logger = getLogger();
+
+        logger.info('test message', 'extra arg');
+        logger.error('error message');
+        logger.warn('warn message');
+        logger.debug('debug message');
+
+        expect(mockLogger.info).toHaveBeenCalledWith('test message', 'extra arg');
+        expect(mockLogger.error).toHaveBeenCalledWith('error message');
+        expect(mockLogger.warn).toHaveBeenCalledWith('warn message');
+        expect(mockLogger.debug).toHaveBeenCalledWith('debug message');
+    });
+
+    it('should persist custom logger across getLogger calls', () => {
+        const mockLogger: Logger = {
+            info: vi.fn(),
+            error: vi.fn(),
+            warn: vi.fn(),
+            debug: vi.fn(),
+        };
+
+        setLogger(mockLogger);
+
+        const logger1 = getLogger();
+        const logger2 = getLogger();
+
+        logger1.info('message 1');
+        logger2.info('message 2');
+
+        expect(mockLogger.info).toHaveBeenCalledTimes(2);
+        expect(mockLogger.info).toHaveBeenNthCalledWith(1, 'message 1');
+        expect(mockLogger.info).toHaveBeenNthCalledWith(2, 'message 2');
+    });
+
+    it('should handle logger with metadata', () => {
+        const mockLogger: Logger = {
+            info: vi.fn(),
+            error: vi.fn(),
+            warn: vi.fn(),
+            debug: vi.fn(),
+        };
+
+        setLogger(mockLogger);
+        const logger = getLogger();
+
+        const metadata = { user: 'test', action: 'login' };
+        logger.info('User action', metadata);
+
+        expect(mockLogger.info).toHaveBeenCalledWith('User action', metadata);
+    });
+
+    it('should support all log levels', () => {
+        const mockLogger: Logger = {
+            info: vi.fn(),
+            error: vi.fn(),
+            warn: vi.fn(),
+            debug: vi.fn(),
+        };
+
+        setLogger(mockLogger);
+        const logger = getLogger();
+
+        logger.info('info level');
+        logger.error('error level');
+        logger.warn('warn level');
+        logger.debug('debug level');
+
+        expect(mockLogger.info).toHaveBeenCalledTimes(1);
+        expect(mockLogger.error).toHaveBeenCalledTimes(1);
+        expect(mockLogger.warn).toHaveBeenCalledTimes(1);
+        expect(mockLogger.debug).toHaveBeenCalledTimes(1);
+    });
+});

package/tests/prompts.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect } from 'vitest';
+import {
+    createCommitPrompt,
+    createReleasePrompt,
+    createReviewPrompt,
+} from '../src/prompts';
+
+describe('Prompt Builders', () => {
+    describe('createCommitPrompt', () => {
+        it('should create a prompt with diff content', async () => {
+            const prompt = await createCommitPrompt(
+                { overrides: false },
+                {
+                    diffContent: 'diff --git a/file.ts b/file.ts\n+new line',
+                }
+            );
+
+            expect(prompt).toBeDefined();
+            // RiotPrompt returns a Prompt object, not necessarily with messages property
+            expect(typeof prompt).toBe('object');
+        });
+
+        it('should include user direction in prompt', async () => {
+            const prompt = await createCommitPrompt(
+                { overrides: false },
+                {
+                    diffContent: 'diff --git a/file.ts b/file.ts\n+new line',
+                    userDirection: 'Focus on performance improvements',
+                }
+            );
+
+            const promptText = JSON.stringify(prompt);
+            expect(promptText.toLowerCase()).toContain('performance');
+        });
+
+        it('should handle file content mode', async () => {
+            const prompt = await createCommitPrompt(
+                { overrides: false },
+                {
+                    diffContent: 'function test() { return true; }',
+                    isFileContent: true,
+                }
+            );
+
+            expect(prompt).toBeDefined();
+            expect(typeof prompt).toBe('object');
+        });
+
+        it('should include optional context', async () => {
+            const prompt = await createCommitPrompt(
+                { overrides: false },
+                {
+                    diffContent: 'diff content',
+                },
+                {
+                    logContext: 'recent commits',
+                    context: 'working on auth',
+                    directories: ['src/'],
+                }
+            );
+
+            expect(prompt).toBeDefined();
+            expect(typeof prompt).toBe('object');
+        });
+    });
+
+    describe('createReleasePrompt', () => {
+        it('should create a prompt with log and diff content', async () => {
+            const result = await createReleasePrompt(
+                { overrides: false },
+                {
+                    logContent: 'commit 1\ncommit 2\ncommit 3',
+                    diffContent: 'diff content',
+                }
+            );
+
+            expect(result).toBeDefined();
+            expect(result.prompt).toBeDefined();
+            expect(typeof result.prompt).toBe('object');
+            expect(result.maxTokens).toBeDefined();
+            expect(result.isLargeRelease).toBeDefined();
+        });
+
+        it('should detect normal sized releases', async () => {
+            const result = await createReleasePrompt(
+                { overrides: false },
+                {
+                    logContent: 'commit 1\ncommit 2',
+                    diffContent: 'small diff',
+                }
+            );
+
+            expect(result.isLargeRelease).toBe(false);
+            expect(result.maxTokens).toBe(10000);
+        });
+
+        it('should detect large releases by log line count', async () => {
+            // Create log with >60 lines
+            const largeLog = Array(70).fill('commit line').join('\n');
+
+            const result = await createReleasePrompt(
+                { overrides: false },
+                {
+                    logContent: largeLog,
+                    diffContent: 'diff content',
+                }
+            );
+
+            expect(result.isLargeRelease).toBe(true);
+            expect(result.maxTokens).toBe(25000);
+        });
+
+        it('should detect large releases by diff size', async () => {
+            // Create diff with >500 lines
+            const largeDiff = Array(600).fill('diff line').join('\n');
+
+            const result = await createReleasePrompt(
+                { overrides: false },
+                {
+                    logContent: 'small log',
+                    diffContent: largeDiff,
+                }
+            );
+
+            expect(result.isLargeRelease).toBe(true);
+            expect(result.maxTokens).toBe(25000);
+        });
+
+        it('should include release focus and milestone issues', async () => {
+            const result = await createReleasePrompt(
+                { overrides: false },
+                {
+                    logContent: 'commits',
+                    diffContent: 'diff',
+                    releaseFocus: 'Bug fixes and performance',
+                    milestoneIssues: 'Issue #1\nIssue #2',
+                }
+            );
+
+            expect(result.prompt).toBeDefined();
+            expect(typeof result.prompt).toBe('object');
+        });
+    });
+
+    describe('createReviewPrompt', () => {
+        it('should create a prompt with review notes', async () => {
+            const prompt = await createReviewPrompt(
+                { overrides: false },
+                {
+                    notes: 'Review notes about the project',
+                }
+            );
+
+            expect(prompt).toBeDefined();
+            expect(typeof prompt).toBe('object');
+        });
+
+        it('should include optional context', async () => {
+            const prompt = await createReviewPrompt(
+                { overrides: false },
+                {
+                    notes: 'Review notes',
+                },
+                {
+                    logContext: 'recent commits',
+                    diffContext: 'current diff',
+                    releaseNotesContext: 'recent release',
+                    issuesContext: 'existing issues',
+                    context: 'additional context',
+                    directories: ['src/'],
+                }
+            );
+
+            expect(prompt).toBeDefined();
+            expect(typeof prompt).toBe('object');
+        });
+    });
+});
+

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "types": [
+      "node",
+      "vitest"
+    ],
+    "incremental": true,
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": [
+        "src/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*",
+    "tests/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}
+

package/vite.config.ts

@@ -0,0 +1,69 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+import dts from 'vite-plugin-dts';
+import fs from 'fs';
+import path from 'path';
+
+export default defineConfig({
+    plugins: [
+        dts({
+            include: ['src/**/*'],
+            exclude: ['src/**/*.test.ts', 'tests/**/*', 'src/**/*.md'],
+            outDir: 'dist',
+            insertTypesEntry: true,
+        }),
+        // Custom plugin to copy markdown files
+        {
+            name: 'copy-markdown',
+            writeBundle() {
+                // Copy markdown files preserving directory structure
+                const copyDir = (src: string, dest: string) => {
+                    if (!fs.existsSync(dest)) {
+                        fs.mkdirSync(dest, { recursive: true });
+                    }
+
+                    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+                    for (const entry of entries) {
+                        const srcPath = path.join(src, entry.name);
+                        const destPath = path.join(dest, entry.name);
+
+                        if (entry.isDirectory()) {
+                            copyDir(srcPath, destPath);
+                        } else if (entry.name.endsWith('.md')) {
+                            fs.copyFileSync(srcPath, destPath);
+                        }
+                    }
+                };
+
+                // Copy prompts markdown files to dist root
+                // (because bundled code in dist/index.js uses __dirname which resolves to dist/)
+                copyDir('src/prompts', 'dist');
+            }
+        }
+    ],
+    build: {
+        lib: {
+            entry: resolve(__dirname, 'src/index.ts'),
+            formats: ['es'],
+            fileName: 'index',
+        },
+        rollupOptions: {
+            external: [
+                'openai',
+                '@riotprompt/riotprompt',
+                '@eldrforge/git-tools',
+                'winston',
+                'fs',
+                'fs/promises',
+                'path',
+                'child_process',
+                'os',
+                'crypto',
+                'url',
+            ],
+        },
+        sourcemap: true,
+        minify: false,
+    },
+});

package/vitest.config.ts

@@ -0,0 +1,25 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'html', 'lcov'],
+            include: ['src/**/*.ts'],
+            exclude: [
+                'src/**/*.test.ts',
+                'tests/**/*',
+                'src/types.ts',
+                'src/**/index.ts', // Index files are just exports
+            ],
+            thresholds: {
+                lines: 90,
+                functions: 90,
+                branches: 90,
+                statements: 90,
+            },
+        },
+    },
+});