@grunnverk/kilde 0.1.0

package/tests/utils/config.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { tmpdir } from 'os';
+import {
+    loadConfig,
+    getDefaultConfig,
+    mergeWithDefaults,
+    getEffectiveConfig,
+    createSampleConfig,
+    saveSampleConfig,
+    configFileExists,
+} from '../../src/utils/config';
+import { KILDE_DEFAULTS } from '../../src/constants';
+
+describe('config utilities', () => {
+    let testDir: string;
+
+    beforeEach(async () => {
+        testDir = await fs.mkdtemp(path.join(tmpdir(), 'kilde-test-'));
+    });
+
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+
+    describe('loadConfig', () => {
+        it('should return null when no config file exists', async () => {
+            const config = await loadConfig(testDir);
+            expect(config).toBeNull();
+        });
+
+        it('should load YAML config from .kilde/config.yaml', async () => {
+            const configDir = path.join(testDir, '.kilde');
+            await fs.mkdir(configDir, { recursive: true });
+            const configPath = path.join(configDir, 'config.yaml');
+            await fs.writeFile(configPath, 'verbose: true\nmodel: gpt-4o', 'utf-8');
+
+            const config = await loadConfig(testDir);
+            expect(config).not.toBeNull();
+            expect(config?.verbose).toBe(true);
+            expect(config?.model).toBe('gpt-4o');
+        });
+
+        it('should load JSON config from .kilderc.json', async () => {
+            const configPath = path.join(testDir, '.kilderc.json');
+            await fs.writeFile(configPath, JSON.stringify({ verbose: true, debug: true }), 'utf-8');
+
+            const config = await loadConfig(testDir);
+            expect(config).not.toBeNull();
+            expect(config?.verbose).toBe(true);
+            expect(config?.debug).toBe(true);
+        });
+
+        it('should prioritize .kilde/config.yaml over other files', async () => {
+            // Create multiple config files
+            const configDir = path.join(testDir, '.kilde');
+            await fs.mkdir(configDir, { recursive: true });
+            await fs.writeFile(path.join(configDir, 'config.yaml'), 'verbose: true\nmodel: gpt-4o', 'utf-8');
+            await fs.writeFile(path.join(testDir, '.kilderc.json'), JSON.stringify({ verbose: false }), 'utf-8');
+
+            const config = await loadConfig(testDir);
+            expect(config?.verbose).toBe(true);
+            expect(config?.model).toBe('gpt-4o');
+        });
+
+        it('should handle malformed config gracefully', async () => {
+            const configPath = path.join(testDir, '.kilderc.json');
+            await fs.writeFile(configPath, 'not valid json', 'utf-8');
+
+            const config = await loadConfig(testDir);
+            expect(config).toBeNull();
+        });
+    });
+
+    describe('getDefaultConfig', () => {
+        it('should return KILDE_DEFAULTS', () => {
+            const config = getDefaultConfig();
+            expect(config).toEqual(KILDE_DEFAULTS);
+        });
+
+        it('should include required fields', () => {
+            const config = getDefaultConfig();
+            expect(config.configDirectory).toBeDefined();
+            expect(config.discoveredConfigDirs).toBeDefined();
+            expect(config.resolvedConfigDirs).toBeDefined();
+            expect(config.verbose).toBeDefined();
+            expect(config.debug).toBeDefined();
+            expect(config.dryRun).toBeDefined();
+        });
+    });
+
+    describe('mergeWithDefaults', () => {
+        it('should return defaults when config is null', () => {
+            const merged = mergeWithDefaults(null);
+            expect(merged).toEqual(KILDE_DEFAULTS);
+        });
+
+        it('should merge config with defaults', () => {
+            const config = { verbose: true, model: 'gpt-4o' } as any;
+            const merged = mergeWithDefaults(config);
+
+            expect(merged.verbose).toBe(true);
+            expect(merged.model).toBe('gpt-4o');
+            expect(merged.debug).toBe(KILDE_DEFAULTS.debug);
+            expect(merged.configDirectory).toBe(KILDE_DEFAULTS.configDirectory);
+        });
+
+        it('should deep merge nested objects', () => {
+            const config = {
+                commit: {
+                    sendit: true,
+                    add: false,
+                }
+            } as any;
+            const merged = mergeWithDefaults(config);
+
+            expect(merged.commit?.sendit).toBe(true);
+            expect(merged.commit?.add).toBe(false);
+            expect(merged.commit?.cached).toBe(KILDE_DEFAULTS.commit?.cached);
+        });
+
+        it('should not merge arrays', () => {
+            const config = {
+                discoveredConfigDirs: ['custom-dir']
+            } as any;
+            const merged = mergeWithDefaults(config);
+
+            expect(merged.discoveredConfigDirs).toEqual(['custom-dir']);
+        });
+    });
+
+    describe('getEffectiveConfig', () => {
+        it('should return defaults when no config file exists', async () => {
+            const config = await getEffectiveConfig(testDir);
+            expect(config).toEqual(KILDE_DEFAULTS);
+        });
+
+        it('should merge loaded config with defaults', async () => {
+            const configPath = path.join(testDir, '.kilderc.json');
+            await fs.writeFile(configPath, JSON.stringify({ verbose: true }), 'utf-8');
+
+            const config = await getEffectiveConfig(testDir);
+            expect(config.verbose).toBe(true);
+            expect(config.debug).toBe(KILDE_DEFAULTS.debug);
+        });
+    });
+
+    describe('createSampleConfig', () => {
+        it('should return valid YAML config string', () => {
+            const yaml = createSampleConfig();
+            expect(yaml).toContain('verbose:');
+            expect(yaml).toContain('debug:');
+            expect(yaml).toContain('model:');
+            expect(yaml).toContain('commit:');
+            expect(yaml).toContain('release:');
+        });
+
+        it('should have correct default values', () => {
+            const yaml = createSampleConfig();
+            expect(yaml).toContain('verbose: false');
+            expect(yaml).toContain('debug: false');
+            expect(yaml).toContain('model: gpt-4o-mini');
+        });
+    });
+
+    describe('saveSampleConfig', () => {
+        it('should create .kilde directory', async () => {
+            await saveSampleConfig(testDir);
+            const configDir = path.join(testDir, '.kilde');
+            const stats = await fs.stat(configDir);
+            expect(stats.isDirectory()).toBe(true);
+        });
+
+        it('should create config.yaml file', async () => {
+            const configPath = await saveSampleConfig(testDir);
+            expect(configPath).toBe(path.join(testDir, '.kilde', 'config.yaml'));
+
+            const content = await fs.readFile(configPath, 'utf-8');
+            expect(content).toContain('verbose:');
+            expect(content).toContain('model:');
+        });
+
+        it('should return the config path', async () => {
+            const configPath = await saveSampleConfig(testDir);
+            expect(configPath).toMatch(/\.kilde\/config\.yaml$/);
+        });
+    });
+
+    describe('configFileExists', () => {
+        it('should return false when no config file exists', async () => {
+            const exists = await configFileExists(testDir);
+            expect(exists).toBe(false);
+        });
+
+        it('should return true when .kilde/config.yaml exists', async () => {
+            const configDir = path.join(testDir, '.kilde');
+            await fs.mkdir(configDir, { recursive: true });
+            await fs.writeFile(path.join(configDir, 'config.yaml'), 'verbose: true', 'utf-8');
+
+            const exists = await configFileExists(testDir);
+            expect(exists).toBe(true);
+        });
+
+        it('should return true when .kilderc.json exists', async () => {
+            await fs.writeFile(path.join(testDir, '.kilderc.json'), '{}', 'utf-8');
+
+            const exists = await configFileExists(testDir);
+            expect(exists).toBe(true);
+        });
+    });
+});

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "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,
+    "baseUrl": ".",
+    "paths": {
+      "*": [
+        "src/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*",
+    "tests/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/vite.config.ts

@@ -0,0 +1,107 @@
+import { defineConfig } from 'vite';
+import { VitePluginNode } from 'vite-plugin-node';
+import replace from '@rollup/plugin-replace';
+import { execSync } from 'child_process';
+import shebang from 'rollup-plugin-preserve-shebang';
+import os from 'os';
+
+let gitInfo = {
+    branch: '',
+    commit: '',
+    tags: '',
+    commitDate: '',
+};
+
+try {
+    gitInfo = {
+        branch: execSync('git rev-parse --abbrev-ref HEAD').toString().trim(),
+        commit: execSync('git rev-parse --short HEAD').toString().trim(),
+        tags: '',
+        commitDate: execSync('git log -1 --format=%cd --date=iso').toString().trim(),
+    };
+
+    try {
+        gitInfo.tags = execSync('git tag --points-at HEAD | paste -sd "," -').toString().trim();
+    } catch {
+        gitInfo.tags = '';
+    }
+} catch {
+    // eslint-disable-next-line no-console
+    console.log('Directory does not have a Git repository, skipping git info');
+}
+
+// Capture build metadata
+const buildInfo = {
+    hostname: os.hostname(),
+    timestamp: new Date().toISOString(),
+};
+
+
+export default defineConfig({
+    server: {
+        port: 3000
+    },
+    plugins: [
+        ...VitePluginNode({
+            adapter: 'express',
+            appPath: './src/main.ts',
+            exportName: 'viteNodeApp',
+            tsCompiler: 'swc',
+            swcOptions: {
+                sourceMaps: true,
+            },
+        }),
+        replace({
+            '__VERSION__': process.env.npm_package_version,
+            '__GIT_BRANCH__': gitInfo.branch,
+            '__GIT_COMMIT__': gitInfo.commit,
+            '__GIT_TAGS__': gitInfo.tags === '' ? '' : `T:${gitInfo.tags}`,
+            '__GIT_COMMIT_DATE__': gitInfo.commitDate,
+            '__SYSTEM_INFO__': `${process.platform} ${process.arch} ${process.version}`,
+            '__BUILD_HOSTNAME__': buildInfo.hostname,
+            '__BUILD_TIMESTAMP__': buildInfo.timestamp,
+            preventAssignment: true,
+        }),
+    ],
+    build: {
+        target: 'esnext',
+        outDir: 'dist',
+        lib: {
+            entry: './src/main.ts',
+            formats: ['es'],
+            fileName: 'main',
+        },
+        rollupOptions: {
+            external: [
+                // Command packages
+                '@grunnverk/core',
+                '@grunnverk/commands-git',
+                // Foundation packages
+                '@grunnverk/ai-service',
+                '@grunnverk/git-tools',
+                '@grunnverk/shared',
+                // MCP dependencies
+                '@modelcontextprotocol/sdk',
+            ],
+            input: 'src/main.ts',
+            output: {
+                dir: 'dist',
+                format: 'es',
+                entryFileNames: '[name].js',
+                chunkFileNames: '[name].js',
+                preserveModules: true,
+                preserveModulesRoot: 'src',
+                exports: 'named',
+            },
+            plugins: [
+                shebang({
+                    shebang: '#!/usr/bin/env node',
+                }),
+            ],
+        },
+        // Make sure Vite generates ESM-compatible code
+        modulePreload: false,
+        minify: false,
+        sourcemap: true
+    },
+});

package/vitest.config.ts

@@ -0,0 +1,40 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: false,
+        environment: 'node',
+        include: ['tests/**/*.test.ts'],
+        exclude: ['tests/commands/**/*.test.ts'], // Exclude command integration tests - require real git repo
+        env: {
+            TZ: 'America/New_York'
+        },
+        // Add pool configuration to prevent memory issues (moved from poolOptions in Vitest 4)
+        pool: 'forks',
+        maxForks: 2,
+        minForks: 1,
+        // Add test timeout and memory limits
+        testTimeout: 30000,
+        hookTimeout: 10000,
+        teardownTimeout: 10000,
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'lcov', 'html'],
+            all: true,
+            include: ['src/**/*.ts'],
+            exclude: [
+                'src/main.ts',
+                'src/types/**/*.ts',
+                'src/application.ts', // CLI integration - requires Commander parse
+                'src/commands/release.ts', // Complex integration - requires git + AI
+                'src/mcp/server.ts', // MCP server integration - requires stdio transport
+            ],
+            thresholds: {
+                statements: 70,
+                branches: 70,
+                functions: 70,
+                lines: 70,
+            }
+        },
+    },
+});

package/website/index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="description" content="Kilde - Universal Git Automation Tool with AI-powered commit messages and release notes" />
+    <title>Kilde - Universal Git Automation</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/website/src/App.css

@@ -0,0 +1,142 @@
+.app {
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+.section {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 4rem 2rem;
+  width: 100%;
+}
+
+.section h2 {
+  font-size: 2.5rem;
+  margin-bottom: 2rem;
+  color: var(--color-text);
+}
+
+.section h3 {
+  font-size: 1.75rem;
+  margin-top: 2rem;
+  margin-bottom: 1rem;
+  color: var(--color-text);
+}
+
+.section p {
+  color: var(--color-text-secondary);
+  margin-bottom: 1rem;
+  line-height: 1.8;
+}
+
+.code-block {
+  background-color: var(--color-bg-secondary);
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  padding: 1.5rem;
+  margin: 1.5rem 0;
+  overflow-x: auto;
+}
+
+.code-block pre {
+  margin: 0;
+  color: var(--color-text);
+  font-size: 0.9rem;
+  line-height: 1.6;
+}
+
+.code-inline {
+  background-color: var(--color-bg-secondary);
+  color: var(--color-primary);
+  padding: 0.2rem 0.5rem;
+  border-radius: 4px;
+  font-family: var(--font-mono);
+  font-size: 0.9em;
+}
+
+.button {
+  display: inline-block;
+  padding: 0.75rem 1.5rem;
+  background-color: var(--color-primary);
+  color: white;
+  text-decoration: none;
+  border-radius: 8px;
+  font-weight: 600;
+  transition: background-color 0.2s;
+  border: none;
+  cursor: pointer;
+  font-size: 1rem;
+}
+
+.button:hover {
+  background-color: var(--color-primary-hover);
+}
+
+.button-secondary {
+  background-color: transparent;
+  border: 2px solid var(--color-primary);
+  color: var(--color-primary);
+}
+
+.button-secondary:hover {
+  background-color: var(--color-primary);
+  color: white;
+}
+
+.grid {
+  display: grid;
+  gap: 2rem;
+  margin: 2rem 0;
+}
+
+.grid-2 {
+  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+}
+
+.grid-3 {
+  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+}
+
+.card {
+  background-color: var(--color-bg-secondary);
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  padding: 2rem;
+  transition: transform 0.2s, border-color 0.2s;
+}
+
+.card:hover {
+  transform: translateY(-4px);
+  border-color: var(--color-primary);
+}
+
+.card h3 {
+  margin-top: 0;
+  color: var(--color-primary);
+}
+
+.feature-icon {
+  font-size: 2rem;
+  margin-bottom: 1rem;
+  color: var(--color-accent);
+}
+
+@media (max-width: 768px) {
+  .section {
+    padding: 2rem 1rem;
+  }
+
+  .section h2 {
+    font-size: 2rem;
+  }
+
+  .section h3 {
+    font-size: 1.5rem;
+  }
+
+  .grid-2,
+  .grid-3 {
+    grid-template-columns: 1fr;
+  }
+}

package/website/src/App.tsx

@@ -0,0 +1,34 @@
+import React, { useState } from 'react';
+import './App.css';
+import Hero from './components/Hero';
+import Navigation from './components/Navigation';
+import GettingStarted from './components/GettingStarted';
+import Commands from './components/Commands';
+import Configuration from './components/Configuration';
+import Examples from './components/Examples';
+import Footer from './components/Footer';
+
+function App() {
+    const [activeSection, setActiveSection] = useState('home');
+
+    return (
+        <div className="app">
+            <Navigation activeSection={activeSection} onNavigate={setActiveSection} />
+
+            {activeSection === 'home' && (
+                <>
+                    <Hero />
+                    <GettingStarted />
+                </>
+            )}
+
+            {activeSection === 'commands' && <Commands />}
+            {activeSection === 'configuration' && <Configuration />}
+            {activeSection === 'examples' && <Examples />}
+
+            <Footer />
+        </div>
+    );
+}
+
+export default App;