@grunnverk/kilde 0.1.0

package/tests/commands/release.test.ts

@@ -0,0 +1,325 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { execute } from '../../src/commands/release';
+import { Config, Log, Diff } from '@grunnverk/core';
+import * as GitTools from '@grunnverk/git-tools';
+
+// Mock dependencies
+vi.mock('@grunnverk/git-tools', () => ({
+    getDefaultFromRef: vi.fn(),
+    getCurrentBranch: vi.fn(),
+}));
+
+vi.mock('@grunnverk/core', async () => {
+    const actual = await vi.importActual('@grunnverk/core');
+    return {
+        ...actual,
+        Log: {
+            create: vi.fn(),
+        },
+        Diff: {
+            create: vi.fn(),
+        },
+    };
+});
+
+vi.mock('@grunnverk/ai-service', () => ({
+    runAgenticRelease: vi.fn(),
+    getDryRunLogger: vi.fn((isDryRun) => ({
+        info: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+        warn: vi.fn(),
+    })),
+}));
+
+vi.mock('@grunnverk/shared', () => ({
+    createStorage: vi.fn(() => ({
+        writeFile: vi.fn(),
+        readFile: vi.fn(),
+        exists: vi.fn(),
+    })),
+}));
+
+describe('release command integration', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('basic release functionality', () => {
+        it('should generate release notes with default config', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                release: {},
+            } as Config;
+
+            vi.mocked(GitTools.getCurrentBranch).mockResolvedValue('main');
+            vi.mocked(GitTools.getDefaultFromRef).mockResolvedValue('v1.0.0');
+
+            vi.mocked(Log.create).mockResolvedValue({
+                toString: () => 'commit log content',
+                commits: [],
+            } as any);
+
+            vi.mocked(Diff.create).mockResolvedValue({
+                toString: () => 'diff content',
+                files: [],
+            } as any);
+
+            const { runAgenticRelease } = await import('@grunnverk/ai-service');
+            vi.mocked(runAgenticRelease).mockResolvedValue({
+                title: 'Release v2.0.0',
+                body: 'Release notes content',
+            } as any);
+
+            const result = await execute(mockConfig);
+
+            expect(result).toEqual({
+                title: 'Release v2.0.0',
+                body: 'Release notes content',
+            });
+        });
+
+        it('should use specified tag range', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                release: {
+                    from: 'v1.0.0',
+                    to: 'v2.0.0',
+                },
+            } as Config;
+
+            vi.mocked(GitTools.getCurrentBranch).mockResolvedValue('main');
+
+            vi.mocked(Log.create).mockResolvedValue({
+                toString: () => 'log between tags',
+                commits: [],
+            } as any);
+
+            vi.mocked(Diff.create).mockResolvedValue({
+                toString: () => 'diff between tags',
+                files: [],
+            } as any);
+
+            const { runAgenticRelease } = await import('@grunnverk/ai-service');
+            vi.mocked(runAgenticRelease).mockResolvedValue({
+                title: 'Release v2.0.0',
+                body: 'Changes from v1.0.0 to v2.0.0',
+            } as any);
+
+            const result = await execute(mockConfig);
+
+            expect(Log.create).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    from: 'v1.0.0',
+                    to: 'v2.0.0',
+                })
+            );
+        });
+    });
+
+    describe('release with version', () => {
+        it('should include version in release notes', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                release: {
+                    from: 'v1.0.0',
+                } as any,
+            } as Config;
+
+            (mockConfig.release as any).version = 'v2.0.0';
+
+            vi.mocked(GitTools.getCurrentBranch).mockResolvedValue('main');
+            vi.mocked(GitTools.getDefaultFromRef).mockResolvedValue('v1.0.0');
+
+            vi.mocked(Log.create).mockResolvedValue({
+                toString: () => 'commit log',
+                commits: [],
+            } as any);
+
+            vi.mocked(Diff.create).mockResolvedValue({
+                toString: () => 'diff content',
+                files: [],
+            } as any);
+
+            const { runAgenticRelease } = await import('@grunnverk/ai-service');
+            vi.mocked(runAgenticRelease).mockResolvedValue({
+                title: 'Release v2.0.0',
+                body: 'Version 2.0.0 release notes',
+            } as any);
+
+            await execute(mockConfig);
+
+            expect(runAgenticRelease).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    targetVersion: 'v2.0.0',
+                })
+            );
+        });
+    });
+
+    describe('release with focus', () => {
+        it('should use focus parameter for targeted release notes', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                release: {
+                    focus: 'breaking changes',
+                },
+            } as Config;
+
+            vi.mocked(GitTools.getCurrentBranch).mockResolvedValue('main');
+            vi.mocked(GitTools.getDefaultFromRef).mockResolvedValue('v1.0.0');
+
+            vi.mocked(Log.create).mockResolvedValue({
+                toString: () => 'commit log',
+                commits: [],
+            } as any);
+
+            vi.mocked(Diff.create).mockResolvedValue({
+                toString: () => 'diff content',
+                files: [],
+            } as any);
+
+            const { runAgenticRelease } = await import('@grunnverk/ai-service');
+            vi.mocked(runAgenticRelease).mockResolvedValue({
+                title: 'Release Notes',
+                body: 'Breaking changes highlighted',
+            } as any);
+
+            await execute(mockConfig);
+
+            expect(runAgenticRelease).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    releaseFocus: 'breaking changes',
+                })
+            );
+        });
+    });
+
+    describe('release with context', () => {
+        it('should include user context in generation', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                release: {
+                    context: 'Major refactoring release',
+                },
+            } as Config;
+
+            vi.mocked(GitTools.getCurrentBranch).mockResolvedValue('main');
+            vi.mocked(GitTools.getDefaultFromRef).mockResolvedValue('v1.0.0');
+
+            vi.mocked(Log.create).mockResolvedValue({
+                toString: () => 'commit log',
+                commits: [],
+            } as any);
+
+            vi.mocked(Diff.create).mockResolvedValue({
+                toString: () => 'diff content',
+                files: [],
+            } as any);
+
+            const { runAgenticRelease } = await import('@grunnverk/ai-service');
+            vi.mocked(runAgenticRelease).mockResolvedValue({
+                title: 'Release Notes',
+                body: 'Notes with context',
+            } as any);
+
+            await execute(mockConfig);
+
+            expect(runAgenticRelease).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    userContext: 'Major refactoring release',
+                })
+            );
+        });
+    });
+
+    describe('dry-run mode', () => {
+        it('should preview release notes without saving', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                dryRun: true,
+                release: {},
+            } as Config;
+
+            vi.mocked(GitTools.getCurrentBranch).mockResolvedValue('main');
+            vi.mocked(GitTools.getDefaultFromRef).mockResolvedValue('v1.0.0');
+
+            vi.mocked(Log.create).mockResolvedValue({
+                toString: () => 'commit log',
+                commits: [],
+            } as any);
+
+            vi.mocked(Diff.create).mockResolvedValue({
+                toString: () => 'diff content',
+                files: [],
+            } as any);
+
+            const { runAgenticRelease } = await import('@grunnverk/ai-service');
+            vi.mocked(runAgenticRelease).mockResolvedValue({
+                title: 'Preview Release',
+                body: 'Preview content',
+            } as any);
+
+            const result = await execute(mockConfig);
+
+            expect(result.title).toBe('Preview Release');
+            // In dry-run, files should not be written
+        });
+    });
+
+    describe('error handling', () => {
+        it('should handle git log errors', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                release: {},
+            } as Config;
+
+            vi.mocked(GitTools.getCurrentBranch).mockResolvedValue('main');
+            vi.mocked(GitTools.getDefaultFromRef).mockResolvedValue('v1.0.0');
+            vi.mocked(Log.create).mockRejectedValue(new Error('Git log failed'));
+
+            await expect(execute(mockConfig)).rejects.toThrow();
+        });
+
+        it('should handle AI service errors', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                release: {},
+            } as Config;
+
+            vi.mocked(GitTools.getCurrentBranch).mockResolvedValue('main');
+            vi.mocked(GitTools.getDefaultFromRef).mockResolvedValue('v1.0.0');
+
+            vi.mocked(Log.create).mockResolvedValue({
+                toString: () => 'log',
+                commits: [],
+            } as any);
+
+            vi.mocked(Diff.create).mockResolvedValue({
+                toString: () => 'diff',
+                files: [],
+            } as any);
+
+            const { runAgenticRelease } = await import('@grunnverk/ai-service');
+            vi.mocked(runAgenticRelease).mockRejectedValue(new Error('AI service error'));
+
+            await expect(execute(mockConfig)).rejects.toThrow();
+        });
+    });
+});

package/tests/constants.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'vitest';
+import {
+    PROGRAM_NAME,
+    VERSION,
+    BUILD_HOSTNAME,
+    BUILD_TIMESTAMP,
+    COMMAND_COMMIT,
+    COMMAND_RELEASE,
+    DEFAULT_CONFIG_DIR,
+    DEFAULT_EXCLUDED_PATTERNS,
+    KILDE_DEFAULTS,
+} from '../src/constants';
+
+describe('constants', () => {
+    describe('program metadata', () => {
+        it('should have PROGRAM_NAME defined', () => {
+            expect(PROGRAM_NAME).toBeDefined();
+            expect(typeof PROGRAM_NAME).toBe('string');
+            expect(PROGRAM_NAME).toBe('kilde');
+        });
+
+        it('should have VERSION defined', () => {
+            expect(VERSION).toBeDefined();
+            expect(typeof VERSION).toBe('string');
+        });
+
+        it('should have BUILD_HOSTNAME defined', () => {
+            expect(BUILD_HOSTNAME).toBeDefined();
+            expect(typeof BUILD_HOSTNAME).toBe('string');
+        });
+
+        it('should have BUILD_TIMESTAMP defined', () => {
+            expect(BUILD_TIMESTAMP).toBeDefined();
+            expect(typeof BUILD_TIMESTAMP).toBe('string');
+        });
+    });
+
+    describe('commands', () => {
+        it('should have COMMAND_COMMIT defined', () => {
+            expect(COMMAND_COMMIT).toBe('commit');
+        });
+
+        it('should have COMMAND_RELEASE defined', () => {
+            expect(COMMAND_RELEASE).toBe('release');
+        });
+    });
+
+    describe('configuration', () => {
+        it('should have DEFAULT_CONFIG_DIR defined', () => {
+            expect(DEFAULT_CONFIG_DIR).toBeDefined();
+            expect(typeof DEFAULT_CONFIG_DIR).toBe('string');
+        });
+
+        it('should have DEFAULT_EXCLUDED_PATTERNS defined', () => {
+            expect(DEFAULT_EXCLUDED_PATTERNS).toBeDefined();
+            expect(Array.isArray(DEFAULT_EXCLUDED_PATTERNS)).toBe(true);
+            expect(DEFAULT_EXCLUDED_PATTERNS.length).toBeGreaterThan(0);
+        });
+
+        it('should exclude common patterns', () => {
+            expect(DEFAULT_EXCLUDED_PATTERNS).toContain('node_modules');
+            expect(DEFAULT_EXCLUDED_PATTERNS).toContain('.git');
+            expect(DEFAULT_EXCLUDED_PATTERNS).toContain('dist');
+        });
+    });
+
+    describe('KILDE_DEFAULTS', () => {
+        it('should have all required config fields', () => {
+            expect(KILDE_DEFAULTS.configDirectory).toBeDefined();
+            expect(KILDE_DEFAULTS.discoveredConfigDirs).toBeDefined();
+            expect(KILDE_DEFAULTS.resolvedConfigDirs).toBeDefined();
+            expect(KILDE_DEFAULTS.excludedPatterns).toBeDefined();
+        });
+
+        it('should have boolean flags with default values', () => {
+            expect(typeof KILDE_DEFAULTS.verbose).toBe('boolean');
+            expect(typeof KILDE_DEFAULTS.debug).toBe('boolean');
+            expect(typeof KILDE_DEFAULTS.dryRun).toBe('boolean');
+        });
+
+        it('should have model configuration', () => {
+            expect(KILDE_DEFAULTS.model).toBeDefined();
+            expect(typeof KILDE_DEFAULTS.model).toBe('string');
+        });
+
+        it('should have commit configuration', () => {
+            expect(KILDE_DEFAULTS.commit).toBeDefined();
+            expect(typeof KILDE_DEFAULTS.commit).toBe('object');
+        });
+
+        it('should have release configuration', () => {
+            expect(KILDE_DEFAULTS.release).toBeDefined();
+            expect(typeof KILDE_DEFAULTS.release).toBe('object');
+        });
+
+        it('should have sensible commit defaults', () => {
+            expect(KILDE_DEFAULTS.commit?.sendit).toBe(false);
+            expect(KILDE_DEFAULTS.commit?.interactive).toBe(false);
+            expect(KILDE_DEFAULTS.commit?.add).toBe(false);
+            expect(KILDE_DEFAULTS.commit?.cached).toBe(false);
+        });
+
+        it('should have sensible release defaults', () => {
+            expect(KILDE_DEFAULTS.release?.interactive).toBe(false);
+        });
+
+        it('should use excluded patterns from DEFAULT_EXCLUDED_PATTERNS', () => {
+            expect(KILDE_DEFAULTS.excludedPatterns).toEqual(DEFAULT_EXCLUDED_PATTERNS);
+        });
+
+        it('should have empty arrays for directory lists', () => {
+            expect(Array.isArray(KILDE_DEFAULTS.discoveredConfigDirs)).toBe(true);
+            expect(Array.isArray(KILDE_DEFAULTS.resolvedConfigDirs)).toBe(true);
+            expect(KILDE_DEFAULTS.discoveredConfigDirs.length).toBe(0);
+            expect(KILDE_DEFAULTS.resolvedConfigDirs.length).toBe(0);
+        });
+    });
+});

package/tests/logging.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import winston from 'winston';
+import { getLogger, setLogLevel, getDryRunLogger } from '../src/logging';
+
+describe('logging', () => {
+    let originalEnv: NodeJS.ProcessEnv;
+
+    beforeEach(() => {
+        originalEnv = { ...process.env };
+    });
+
+    afterEach(() => {
+        process.env = originalEnv;
+        // Reset log level
+        setLogLevel('info');
+    });
+
+    describe('getLogger', () => {
+        it('should return a winston logger instance', () => {
+            const logger = getLogger();
+            expect(logger).toBeDefined();
+            expect(typeof logger.info).toBe('function');
+            expect(typeof logger.error).toBe('function');
+            expect(typeof logger.debug).toBe('function');
+        });
+
+        it('should return the same logger instance on multiple calls', () => {
+            const logger1 = getLogger();
+            const logger2 = getLogger();
+            expect(logger1).toBe(logger2);
+        });
+
+        it('should have console transport in non-MCP mode', () => {
+            delete process.env.KILDE_MCP_SERVER;
+            const logger = getLogger() as winston.Logger;
+            const transports = (logger as any).transports || [];
+            const hasConsole = transports.some((t: any) => t instanceof winston.transports.Console);
+            expect(hasConsole).toBe(true);
+        });
+    });
+
+    describe('setLogLevel', () => {
+        it('should change logger level to verbose', () => {
+            const logger = getLogger() as winston.Logger;
+            setLogLevel('verbose');
+            expect(logger.level).toBe('verbose');
+        });
+
+        it('should change logger level to debug', () => {
+            const logger = getLogger() as winston.Logger;
+            setLogLevel('debug');
+            expect(logger.level).toBe('debug');
+        });
+
+        it('should change logger level to info', () => {
+            const logger = getLogger() as winston.Logger;
+            setLogLevel('info');
+            expect(logger.level).toBe('info');
+        });
+    });
+
+    describe('getDryRunLogger', () => {
+        it('should return a logger with dry-run prefix when isDryRun is true', () => {
+            const logger = getDryRunLogger(true);
+            expect(logger).toBeDefined();
+
+            // Test that it has the expected methods
+            expect(typeof logger.info).toBe('function');
+            expect(typeof logger.error).toBe('function');
+            expect(typeof logger.debug).toBe('function');
+        });
+
+        it('should return the original logger when isDryRun is false', () => {
+            const originalLogger = getLogger();
+            const logger = getDryRunLogger(false);
+            expect(logger).toBe(originalLogger);
+        });
+
+        it('should prefix messages with [DRY-RUN] when isDryRun is true', () => {
+            const logger = getDryRunLogger(true);
+            const mockLog = vi.fn();
+
+            // Replace the underlying logger's info method
+            const originalLogger = getLogger();
+            const originalInfo = originalLogger.info;
+            originalLogger.info = mockLog as any;
+
+            logger.info('test message');
+
+            // Verify the message was passed with dryRun metadata
+            expect(mockLog).toHaveBeenCalledWith('test message', { dryRun: true });
+
+            // Restore original
+            originalLogger.info = originalInfo;
+        });
+
+        it('should handle all log methods with dry-run metadata', () => {
+            const logger = getDryRunLogger(true);
+            const originalLogger = getLogger();
+
+            // Test warn
+            const mockWarn = vi.fn();
+            const originalWarn = originalLogger.warn;
+            originalLogger.warn = mockWarn as any;
+            logger.warn('warning');
+            expect(mockWarn).toHaveBeenCalledWith('warning', { dryRun: true });
+            originalLogger.warn = originalWarn;
+
+            // Test error
+            const mockError = vi.fn();
+            const originalError = originalLogger.error;
+            originalLogger.error = mockError as any;
+            logger.error('error');
+            expect(mockError).toHaveBeenCalledWith('error', { dryRun: true });
+            originalLogger.error = originalError;
+
+            // Test debug
+            const mockDebug = vi.fn();
+            const originalDebug = originalLogger.debug;
+            originalLogger.debug = mockDebug as any;
+            logger.debug('debug');
+            expect(mockDebug).toHaveBeenCalledWith('debug', { dryRun: true });
+            originalLogger.debug = originalDebug;
+
+            // Test verbose
+            const mockVerbose = vi.fn();
+            const originalVerbose = originalLogger.verbose;
+            originalLogger.verbose = mockVerbose as any;
+            logger.verbose('verbose');
+            expect(mockVerbose).toHaveBeenCalledWith('verbose', { dryRun: true });
+            originalLogger.verbose = originalVerbose;
+
+            // Test silly
+            const mockSilly = vi.fn();
+            const originalSilly = originalLogger.silly;
+            originalLogger.silly = mockSilly as any;
+            logger.silly('silly');
+            expect(mockSilly).toHaveBeenCalledWith('silly', { dryRun: true });
+            originalLogger.silly = originalSilly;
+        });
+    });
+});