@grunnverk/kilde 0.1.0

package/src/utils/config.ts

@@ -0,0 +1,181 @@
+import fs from 'fs/promises';
+import path from 'path';
+import yaml from 'js-yaml';
+import { getLogger } from '../logging';
+import { Config } from '@grunnverk/core';
+import { KILDE_DEFAULTS } from '../constants';
+
+const CONFIG_FILES = [
+    '.kilde/config.yaml',
+    '.kilde/config.yml',
+    '.kilderc.yaml',
+    '.kilderc.yml',
+    '.kilderc.json',
+    'kilde.config.json',
+];
+
+/**
+ * Load configuration from file
+ */
+export async function loadConfig(cwd: string = process.cwd()): Promise<Config | null> {
+    const logger = getLogger();
+
+    for (const filename of CONFIG_FILES) {
+        const configPath = path.join(cwd, filename);
+
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+
+            let config: any;
+            if (filename.endsWith('.json')) {
+                config = JSON.parse(content);
+            } else if (filename.endsWith('.yaml') || filename.endsWith('.yml')) {
+                config = yaml.load(content);
+            } else {
+                // Try JSON first, then YAML
+                try {
+                    config = JSON.parse(content);
+                } catch {
+                    config = yaml.load(content);
+                }
+            }
+
+            // Return config as-is
+            logger.verbose(`Loaded configuration from ${configPath}`);
+            return config as Config;
+        } catch (error: any) {
+            if (error.code !== 'ENOENT') {
+                logger.warn(`CONFIG_LOAD_FAILED: Failed to load configuration file | Path: ${configPath} | Error: ${error.message} | Action: Using defaults`);
+            }
+        }
+    }
+
+    logger.verbose('No configuration file found, using defaults');
+    return null;
+}
+
+/**
+ * Get default configuration
+ */
+export function getDefaultConfig(): Config {
+    return KILDE_DEFAULTS;
+}
+
+/**
+ * Deep merge two objects
+ */
+function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {
+    const result = { ...target };
+
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+
+            if (sourceValue && typeof sourceValue === 'object' && !Array.isArray(sourceValue) &&
+                targetValue && typeof targetValue === 'object' && !Array.isArray(targetValue)) {
+                result[key] = deepMerge(targetValue, sourceValue) as any;
+            } else if (sourceValue !== undefined) {
+                result[key] = sourceValue as any;
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Merge loaded config with defaults
+ */
+export function mergeWithDefaults(config: Config | null): Config {
+    const defaults = getDefaultConfig();
+
+    if (!config) {
+        return defaults;
+    }
+
+    return deepMerge(defaults, config);
+}
+
+/**
+ * Get effective configuration (loaded + defaults)
+ */
+export async function getEffectiveConfig(cwd: string = process.cwd()): Promise<Config> {
+    const loaded = await loadConfig(cwd);
+    return mergeWithDefaults(loaded);
+}
+
+/**
+ * Create a sample configuration file
+ */
+export function createSampleConfig(): string {
+    const config = {
+        // Global settings
+        verbose: false,
+        debug: false,
+        model: 'gpt-4o-mini',
+        openaiReasoning: 'low',
+        outputDirectory: 'output/kilde',
+
+        // Commit configuration
+        commit: {
+            sendit: false,
+            interactive: false,
+            messageLimit: 3,
+            maxDiffBytes: 20480,
+        },
+
+        // Release configuration
+        release: {
+            interactive: false,
+            messageLimit: 3,
+            maxDiffBytes: 20480,
+        },
+    };
+
+    return yaml.dump(config, {
+        indent: 2,
+        lineWidth: 100,
+        noRefs: true,
+    });
+}
+
+/**
+ * Save sample configuration to file
+ */
+export async function saveSampleConfig(cwd: string = process.cwd()): Promise<string> {
+    const logger = getLogger();
+    const configDir = path.join(cwd, '.kilde');
+    const configPath = path.join(configDir, 'config.yaml');
+
+    try {
+        // Create directory if it doesn't exist
+        await fs.mkdir(configDir, { recursive: true });
+
+        // Write sample config
+        const sampleConfig = createSampleConfig();
+        await fs.writeFile(configPath, sampleConfig, 'utf-8');
+
+        logger.info(`Created sample configuration file at ${configPath}`);
+        return configPath;
+    } catch (error: any) {
+        logger.error(`Failed to create sample configuration: ${error.message}`);
+        throw error;
+    }
+}
+
+/**
+ * Check if configuration file exists
+ */
+export async function configFileExists(cwd: string = process.cwd()): Promise<boolean> {
+    for (const filename of CONFIG_FILES) {
+        const configPath = path.join(cwd, filename);
+        try {
+            await fs.access(configPath);
+            return true;
+        } catch {
+            // File doesn't exist, continue checking
+        }
+    }
+    return false;
+}

package/tests/application.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getVersionInfo, configureEarlyLogging } from '../src/application';
+import { getLogger, setLogLevel } from '../src/logging';
+import { VERSION, BUILD_HOSTNAME, BUILD_TIMESTAMP } from '../src/constants';
+
+describe('application', () => {
+    let originalArgv: string[];
+
+    beforeEach(() => {
+        originalArgv = [...process.argv];
+    });
+
+    afterEach(() => {
+        process.argv = originalArgv;
+        setLogLevel('info');
+    });
+
+    describe('getVersionInfo', () => {
+        it('should return version information', () => {
+            const info = getVersionInfo();
+
+            expect(info.version).toBe(VERSION);
+            expect(info.buildHostname).toBe(BUILD_HOSTNAME);
+            expect(info.buildTimestamp).toBe(BUILD_TIMESTAMP);
+            expect(info.formatted).toContain(VERSION);
+        });
+
+        it('should include build metadata in formatted string', () => {
+            const info = getVersionInfo();
+
+            expect(info.formatted).toContain('Built on:');
+            expect(info.formatted).toContain('Build time:');
+            expect(info.formatted).toContain(BUILD_HOSTNAME);
+            expect(info.formatted).toContain(BUILD_TIMESTAMP);
+        });
+
+        it('should have all required fields', () => {
+            const info = getVersionInfo();
+
+            expect(info).toHaveProperty('version');
+            expect(info).toHaveProperty('buildHostname');
+            expect(info).toHaveProperty('buildTimestamp');
+            expect(info).toHaveProperty('formatted');
+        });
+
+        it('should return string types for all fields', () => {
+            const info = getVersionInfo();
+
+            expect(typeof info.version).toBe('string');
+            expect(typeof info.buildHostname).toBe('string');
+            expect(typeof info.buildTimestamp).toBe('string');
+            expect(typeof info.formatted).toBe('string');
+        });
+    });
+
+    describe('configureEarlyLogging', () => {
+        it('should set debug log level when --debug flag is present', () => {
+            process.argv = ['node', 'kilde', '--debug'];
+            configureEarlyLogging();
+
+            const logger = getLogger() as any;
+            expect(logger.level).toBe('debug');
+        });
+
+        it('should set debug log level when -d flag is present', () => {
+            process.argv = ['node', 'kilde', '-d'];
+            configureEarlyLogging();
+
+            const logger = getLogger() as any;
+            expect(logger.level).toBe('debug');
+        });
+
+        it('should set verbose log level when --verbose flag is present', () => {
+            process.argv = ['node', 'kilde', '--verbose'];
+            configureEarlyLogging();
+
+            const logger = getLogger() as any;
+            expect(logger.level).toBe('verbose');
+        });
+
+        it('should set verbose log level when -v flag is present', () => {
+            process.argv = ['node', 'kilde', '-v'];
+            configureEarlyLogging();
+
+            const logger = getLogger() as any;
+            expect(logger.level).toBe('verbose');
+        });
+
+        it('should prioritize debug over verbose when both are present', () => {
+            process.argv = ['node', 'kilde', '--verbose', '--debug'];
+            configureEarlyLogging();
+
+            const logger = getLogger() as any;
+            expect(logger.level).toBe('debug');
+        });
+
+        it('should not change log level when no flags are present', () => {
+            setLogLevel('info');
+            process.argv = ['node', 'kilde'];
+            configureEarlyLogging();
+
+            const logger = getLogger() as any;
+            expect(logger.level).toBe('info');
+        });
+
+        it('should handle flags in any position', () => {
+            process.argv = ['node', 'kilde', 'commit', '--debug', '--sendit'];
+            configureEarlyLogging();
+
+            const logger = getLogger() as any;
+            expect(logger.level).toBe('debug');
+        });
+    });
+});

package/tests/commands/commit.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as CommandsGit from '@grunnverk/commands-git';
+import { Config } from '@grunnverk/core';
+
+// Mock the commands-git module
+vi.mock('@grunnverk/commands-git', () => ({
+    commit: vi.fn(),
+}));
+
+describe('commit command integration', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('basic commit functionality', () => {
+        it('should call commands-git commit with proper config', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                verbose: false,
+                debug: false,
+                dryRun: false,
+                commit: {
+                    add: true,
+                    sendit: true,
+                    cached: false,
+                    interactive: false,
+                    amend: false,
+                },
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockResolvedValue('Commit created successfully');
+
+            const result = await CommandsGit.commit(mockConfig);
+
+            expect(CommandsGit.commit).toHaveBeenCalledWith(mockConfig);
+            expect(result).toBe('Commit created successfully');
+        });
+
+        it('should handle commit with add flag', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                commit: {
+                    add: true,
+                },
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockResolvedValue('Changes staged and committed');
+
+            const result = await CommandsGit.commit(mockConfig);
+
+            expect(result).toBe('Changes staged and committed');
+            expect(CommandsGit.commit).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    commit: expect.objectContaining({
+                        add: true,
+                    }),
+                })
+            );
+        });
+
+        it('should handle commit with sendit flag', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                commit: {
+                    sendit: true,
+                },
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockResolvedValue('Commit created: abc1234');
+
+            const result = await CommandsGit.commit(mockConfig);
+
+            expect(result).toContain('Commit created');
+        });
+    });
+
+    describe('commit with context', () => {
+        it('should handle commit with context string', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                commit: {
+                    context: 'Fix authentication bug',
+                },
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockResolvedValue('Commit with context created');
+
+            await CommandsGit.commit(mockConfig);
+
+            expect(CommandsGit.commit).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    commit: expect.objectContaining({
+                        context: 'Fix authentication bug',
+                    }),
+                })
+            );
+        });
+
+        it('should handle commit with context files', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                commit: {
+                    contextFiles: ['CHANGELOG.md', 'README.md'],
+                },
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockResolvedValue('Commit with context files created');
+
+            await CommandsGit.commit(mockConfig);
+
+            expect(CommandsGit.commit).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    commit: expect.objectContaining({
+                        contextFiles: ['CHANGELOG.md', 'README.md'],
+                    }),
+                })
+            );
+        });
+    });
+
+    describe('commit modes', () => {
+        it('should handle interactive mode', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                commit: {
+                    interactive: true,
+                },
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockResolvedValue('Interactive commit completed');
+
+            await CommandsGit.commit(mockConfig);
+
+            expect(CommandsGit.commit).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    commit: expect.objectContaining({
+                        interactive: true,
+                    }),
+                })
+            );
+        });
+
+        it('should handle amend mode', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                commit: {
+                    amend: true,
+                },
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockResolvedValue('Commit amended');
+
+            await CommandsGit.commit(mockConfig);
+
+            expect(CommandsGit.commit).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    commit: expect.objectContaining({
+                        amend: true,
+                    }),
+                })
+            );
+        });
+
+        it('should handle cached mode', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                commit: {
+                    cached: true,
+                },
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockResolvedValue('Cached changes committed');
+
+            await CommandsGit.commit(mockConfig);
+
+            expect(CommandsGit.commit).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    commit: expect.objectContaining({
+                        cached: true,
+                    }),
+                })
+            );
+        });
+    });
+
+    describe('dry-run mode', () => {
+        it('should handle dry-run mode', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+                dryRun: true,
+                commit: {
+                    add: true,
+                },
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockResolvedValue('[DRY-RUN] Would create commit');
+
+            const result = await CommandsGit.commit(mockConfig);
+
+            expect(result).toContain('DRY-RUN');
+        });
+    });
+
+    describe('error handling', () => {
+        it('should propagate errors from commit command', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+            } as Config;
+
+            const error = new Error('Git command failed');
+            vi.mocked(CommandsGit.commit).mockRejectedValue(error);
+
+            await expect(CommandsGit.commit(mockConfig)).rejects.toThrow('Git command failed');
+        });
+
+        it('should handle missing git repository error', async () => {
+            const mockConfig: Config = {
+                configDirectory: '/test/.kilde',
+                discoveredConfigDirs: [],
+                resolvedConfigDirs: [],
+            } as Config;
+
+            vi.mocked(CommandsGit.commit).mockRejectedValue(new Error('Not a git repository'));
+
+            await expect(CommandsGit.commit(mockConfig)).rejects.toThrow('Not a git repository');
+        });
+    });
+});