@grunnverk/kilde 0.1.0

package/tests/mcp/prompts/index.test.ts

@@ -0,0 +1,202 @@
+import { describe, it, expect } from 'vitest';
+import { getPrompts, getPrompt } from '../../../src/mcp/prompts/index';
+
+describe('MCP prompts', () => {
+    describe('getPrompts', () => {
+        it('should return array of prompt definitions', () => {
+            const prompts = getPrompts();
+            expect(Array.isArray(prompts)).toBe(true);
+            expect(prompts.length).toBe(2);
+        });
+
+        it('should include commit-workflow prompt', () => {
+            const prompts = getPrompts();
+            const commitPrompt = prompts.find(p => p.name === 'commit-workflow');
+
+            expect(commitPrompt).toBeDefined();
+            expect(commitPrompt?.description).toContain('commit');
+            expect(commitPrompt?.arguments).toBeDefined();
+            expect(Array.isArray(commitPrompt?.arguments)).toBe(true);
+        });
+
+        it('should include release-workflow prompt', () => {
+            const prompts = getPrompts();
+            const releasePrompt = prompts.find(p => p.name === 'release-workflow');
+
+            expect(releasePrompt).toBeDefined();
+            expect(releasePrompt?.description).toContain('release');
+            expect(releasePrompt?.arguments).toBeDefined();
+            expect(Array.isArray(releasePrompt?.arguments)).toBe(true);
+        });
+
+        it('should define optional context argument for commit-workflow', () => {
+            const prompts = getPrompts();
+            const commitPrompt = prompts.find(p => p.name === 'commit-workflow');
+            const contextArg = commitPrompt?.arguments?.find(a => a.name === 'context');
+
+            expect(contextArg).toBeDefined();
+            expect(contextArg?.required).toBe(false);
+            expect(contextArg?.description).toContain('context');
+        });
+
+        it('should define optional arguments for release-workflow', () => {
+            const prompts = getPrompts();
+            const releasePrompt = prompts.find(p => p.name === 'release-workflow');
+
+            const versionArg = releasePrompt?.arguments?.find(a => a.name === 'version');
+            const fromTagArg = releasePrompt?.arguments?.find(a => a.name === 'fromTag');
+
+            expect(versionArg).toBeDefined();
+            expect(versionArg?.required).toBe(false);
+            expect(fromTagArg).toBeDefined();
+            expect(fromTagArg?.required).toBe(false);
+        });
+    });
+
+    describe('getPrompt', () => {
+        describe('commit-workflow', () => {
+            it('should return commit workflow prompt', async () => {
+                const result = await getPrompt('commit-workflow');
+
+                expect(result.description).toContain('commit');
+                expect(result.messages).toBeDefined();
+                expect(Array.isArray(result.messages)).toBe(true);
+                expect(result.messages.length).toBeGreaterThan(0);
+            });
+
+            it('should have user role message', async () => {
+                const result = await getPrompt('commit-workflow');
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage).toBeDefined();
+                expect(userMessage?.content.type).toBe('text');
+                expect(userMessage?.content.text).toContain('commit');
+            });
+
+            it('should include workflow steps', async () => {
+                const result = await getPrompt('commit-workflow');
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage?.content.text).toContain('Steps:');
+                expect(userMessage?.content.text).toContain('kilde_commit');
+                expect(userMessage?.content.text).toContain('dryRun=true');
+            });
+
+            it('should include context when provided', async () => {
+                const result = await getPrompt('commit-workflow', { context: 'Bug fix for issue #123' });
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage?.content.text).toContain('Bug fix for issue #123');
+                expect(userMessage?.content.text).toContain('Additional context:');
+            });
+
+            it('should not include context section when not provided', async () => {
+                const result = await getPrompt('commit-workflow');
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage?.content.text).not.toContain('Additional context:');
+            });
+        });
+
+        describe('release-workflow', () => {
+            it('should return release workflow prompt', async () => {
+                const result = await getPrompt('release-workflow');
+
+                expect(result.description).toContain('release');
+                expect(result.messages).toBeDefined();
+                expect(Array.isArray(result.messages)).toBe(true);
+                expect(result.messages.length).toBeGreaterThan(0);
+            });
+
+            it('should have user role message', async () => {
+                const result = await getPrompt('release-workflow');
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage).toBeDefined();
+                expect(userMessage?.content.type).toBe('text');
+                expect(userMessage?.content.text).toContain('release');
+            });
+
+            it('should include workflow steps', async () => {
+                const result = await getPrompt('release-workflow');
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage?.content.text).toContain('Steps:');
+                expect(userMessage?.content.text).toContain('kilde_release');
+                expect(userMessage?.content.text).toContain('dryRun=true');
+            });
+
+            it('should include version when provided', async () => {
+                const result = await getPrompt('release-workflow', { version: 'v2.0.0' });
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage?.content.text).toContain('v2.0.0');
+                expect(userMessage?.content.text).toContain('version:');
+            });
+
+            it('should include fromTag when provided', async () => {
+                const result = await getPrompt('release-workflow', { fromTag: 'v1.0.0' });
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage?.content.text).toContain('v1.0.0');
+                expect(userMessage?.content.text).toContain('fromTag:');
+            });
+
+            it('should include both version and fromTag when provided', async () => {
+                const result = await getPrompt('release-workflow', {
+                    version: 'v2.0.0',
+                    fromTag: 'v1.0.0'
+                });
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage?.content.text).toContain('v2.0.0');
+                expect(userMessage?.content.text).toContain('v1.0.0');
+            });
+
+            it('should not include version section when not provided', async () => {
+                const result = await getPrompt('release-workflow');
+                const userMessage = result.messages.find(m => m.role === 'user');
+
+                expect(userMessage?.content.text).not.toContain('version:');
+            });
+        });
+
+        describe('unknown prompt', () => {
+            it('should throw error for unknown prompt name', async () => {
+                await expect(getPrompt('unknown-prompt')).rejects.toThrow('Unknown prompt: unknown-prompt');
+            });
+
+            it('should throw error for empty prompt name', async () => {
+                await expect(getPrompt('')).rejects.toThrow('Unknown prompt:');
+            });
+        });
+
+        describe('type safety', () => {
+            it('should return messages with correct type structure', async () => {
+                const result = await getPrompt('commit-workflow');
+
+                for (const message of result.messages) {
+                    expect(['user', 'assistant']).toContain(message.role);
+                    expect(message.content.type).toBe('text');
+                    expect(typeof message.content.text).toBe('string');
+                }
+            });
+
+            it('should use literal types for role', async () => {
+                const result = await getPrompt('commit-workflow');
+                const message = result.messages[0];
+
+                // TypeScript should enforce this at compile time
+                // This test verifies runtime behavior matches
+                expect(message.role === 'user' || message.role === 'assistant').toBe(true);
+            });
+
+            it('should use literal type for content type', async () => {
+                const result = await getPrompt('commit-workflow');
+                const message = result.messages[0];
+
+                expect(message.content.type).toBe('text');
+            });
+        });
+    });
+});

package/tests/mcp/resources.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getResources, readResource } from '../../src/mcp/resources';
+import { execSync } from 'child_process';
+
+// Mock dependencies
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
+}));
+
+vi.mock('@grunnverk/shared', () => ({
+    createStorage: vi.fn(() => ({
+        exists: vi.fn(),
+        readFile: vi.fn(),
+        writeFile: vi.fn(),
+    })),
+}));
+
+vi.mock('../../src/utils/config', () => ({
+    getEffectiveConfig: vi.fn(() => Promise.resolve({
+        verbose: false,
+        debug: false,
+        model: 'gpt-4o-mini',
+    })),
+}));
+
+describe('MCP resources', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('getResources', () => {
+        it('should return array of resource definitions', () => {
+            const resources = getResources();
+            expect(Array.isArray(resources)).toBe(true);
+            expect(resources.length).toBe(3);
+        });
+
+        it('should include config resource', () => {
+            const resources = getResources();
+            const configResource = resources.find(r => r.uri === 'kilde://config');
+
+            expect(configResource).toBeDefined();
+            expect(configResource?.name).toContain('configuration');
+            expect(configResource?.mimeType).toBe('application/json');
+        });
+
+        it('should include status resource', () => {
+            const resources = getResources();
+            const statusResource = resources.find(r => r.uri === 'kilde://status');
+
+            expect(statusResource).toBeDefined();
+            expect(statusResource?.name).toContain('status');
+            expect(statusResource?.mimeType).toBe('text/plain');
+        });
+
+        it('should include workspace resource', () => {
+            const resources = getResources();
+            const workspaceResource = resources.find(r => r.uri === 'kilde://workspace');
+
+            expect(workspaceResource).toBeDefined();
+            expect(workspaceResource?.name).toContain('Workspace');
+            expect(workspaceResource?.mimeType).toBe('application/json');
+        });
+    });
+
+    describe('readResource', () => {
+        describe('kilde://config', () => {
+            it('should return current configuration as JSON', async () => {
+                const result = await readResource('kilde://config');
+
+                expect(result.contents).toHaveLength(1);
+                expect(result.contents[0].uri).toBe('kilde://config');
+                expect(result.contents[0].mimeType).toBe('application/json');
+
+                const config = JSON.parse(result.contents[0].text);
+                expect(config.verbose).toBeDefined();
+                expect(config.debug).toBeDefined();
+                expect(config.model).toBeDefined();
+            });
+
+            it('should return valid JSON format', async () => {
+                const result = await readResource('kilde://config');
+                expect(() => JSON.parse(result.contents[0].text)).not.toThrow();
+            });
+        });
+
+        describe('kilde://status', () => {
+            it('should return git status information', async () => {
+                vi.mocked(execSync)
+                    .mockReturnValueOnce('On branch main\nnothing to commit' as any)
+                    .mockReturnValueOnce('main' as any)
+                    .mockReturnValueOnce('abc1234 Latest commit' as any);
+
+                const result = await readResource('kilde://status');
+
+                expect(result.contents).toHaveLength(1);
+                expect(result.contents[0].uri).toBe('kilde://status');
+                expect(result.contents[0].mimeType).toBe('text/plain');
+                expect(result.contents[0].text).toContain('Current Branch: main');
+                expect(result.contents[0].text).toContain('Last Commit: abc1234 Latest commit');
+            });
+
+            it('should handle git command errors gracefully', async () => {
+                vi.mocked(execSync).mockImplementation(() => {
+                    throw new Error('Not a git repository');
+                });
+
+                const result = await readResource('kilde://status');
+
+                expect(result.contents).toHaveLength(1);
+                expect(result.contents[0].text).toContain('Error reading git status');
+                expect(result.contents[0].text).toContain('Not a git repository');
+            });
+        });
+
+        describe('kilde://workspace', () => {
+            it('should return workspace information', async () => {
+                vi.mocked(execSync)
+                    .mockReturnValueOnce('true' as any)
+                    .mockReturnValueOnce('/path/to/repo' as any);
+
+                const result = await readResource('kilde://workspace');
+
+                expect(result.contents).toHaveLength(1);
+                expect(result.contents[0].uri).toBe('kilde://workspace');
+                expect(result.contents[0].mimeType).toBe('application/json');
+
+                const workspace = JSON.parse(result.contents[0].text);
+                expect(workspace.workingDirectory).toBeDefined();
+                expect(workspace.isGitRepository).toBe(true);
+                expect(workspace.gitRoot).toBe('/path/to/repo');
+            });
+
+            it('should handle non-git directory', async () => {
+                vi.mocked(execSync).mockImplementation(() => {
+                    throw new Error('Not a git repository');
+                });
+
+                const result = await readResource('kilde://workspace');
+
+                expect(result.contents).toHaveLength(1);
+                const workspace = JSON.parse(result.contents[0].text);
+                expect(workspace.error).toContain('Not a git repository');
+            });
+
+            it('should return valid JSON format', async () => {
+                vi.mocked(execSync)
+                    .mockReturnValueOnce('true' as any)
+                    .mockReturnValueOnce('/path/to/repo' as any);
+
+                const result = await readResource('kilde://workspace');
+                expect(() => JSON.parse(result.contents[0].text)).not.toThrow();
+            });
+        });
+
+        describe('unknown URI', () => {
+            it('should throw error for unknown resource URI', async () => {
+                await expect(readResource('kilde://unknown')).rejects.toThrow('Unknown resource URI');
+            });
+
+            it('should throw error for invalid URI format', async () => {
+                await expect(readResource('invalid-uri')).rejects.toThrow('Unknown resource URI');
+            });
+        });
+    });
+});

package/tests/mcp/tools.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { executeTool, getTools } from '../../src/mcp/tools';
+import * as CommandsGit from '@grunnverk/commands-git';
+import * as ReleaseCommand from '../../src/commands/release';
+
+// Mock the dependencies
+vi.mock('@grunnverk/commands-git', () => ({
+    commit: vi.fn(),
+}));
+
+vi.mock('../../src/commands/release', () => ({
+    execute: vi.fn(),
+}));
+
+vi.mock('@grunnverk/shared', () => ({
+    createStorage: vi.fn(() => ({
+        writeFile: vi.fn(),
+        readFile: vi.fn(),
+    })),
+}));
+
+describe('MCP tools', () => {
+    const mockLogger = {
+        info: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+        warn: vi.fn(),
+        verbose: vi.fn(),
+    };
+
+    const mockContext = {
+        workingDirectory: '/test/dir',
+        config: undefined,
+        logger: mockLogger,
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('executeTool', () => {
+        describe('kilde_commit', () => {
+            it('should execute commit command with default args', async () => {
+                const mockSummary = 'Commit created successfully';
+                vi.mocked(CommandsGit.commit).mockResolvedValue(mockSummary);
+
+                const result = await executeTool('kilde_commit', {}, mockContext);
+
+                expect(CommandsGit.commit).toHaveBeenCalled();
+                expect(result.content).toHaveLength(1);
+                expect(result.content[0].type).toBe('text');
+                expect(result.content[0].text).toBe(mockSummary);
+            });
+
+            it('should pass commit options to config', async () => {
+                vi.mocked(CommandsGit.commit).mockResolvedValue('Success');
+
+                await executeTool('kilde_commit', {
+                    add: true,
+                    cached: true,
+                    sendit: true,
+                    interactive: false,
+                    amend: true,
+                    context: 'Test context',
+                    contextFiles: ['file1.ts', 'file2.ts'],
+                    dryRun: true,
+                    verbose: true,
+                    debug: false,
+                }, mockContext);
+
+                const callArgs = vi.mocked(CommandsGit.commit).mock.calls[0][0];
+                expect(callArgs.commit?.add).toBe(true);
+                expect(callArgs.commit?.cached).toBe(true);
+                expect(callArgs.commit?.sendit).toBe(true);
+                expect(callArgs.commit?.interactive).toBe(false);
+                expect(callArgs.commit?.amend).toBe(true);
+                expect(callArgs.commit?.context).toBe('Test context');
+                expect(callArgs.commit?.contextFiles).toEqual(['file1.ts', 'file2.ts']);
+                expect(callArgs.dryRun).toBe(true);
+                expect(callArgs.verbose).toBe(true);
+                expect(callArgs.debug).toBe(false);
+            });
+
+            it('should handle errors gracefully', async () => {
+                const error = new Error('Commit failed');
+                vi.mocked(CommandsGit.commit).mockRejectedValue(error);
+
+                await expect(executeTool('kilde_commit', {}, mockContext)).rejects.toThrow('Commit failed');
+                expect(mockLogger.error).toHaveBeenCalled();
+            });
+        });
+
+        describe('kilde_release', () => {
+            it('should execute release command with default args', async () => {
+                const mockRelease = {
+                    title: 'Release v1.0.0',
+                    body: 'Release notes body',
+                };
+                vi.mocked(ReleaseCommand.execute).mockResolvedValue(mockRelease);
+
+                const result = await executeTool('kilde_release', {}, mockContext);
+
+                expect(ReleaseCommand.execute).toHaveBeenCalled();
+                expect(result.content).toHaveLength(1);
+                expect(result.content[0].type).toBe('text');
+                expect(result.content[0].text).toContain('Release v1.0.0');
+                expect(result.content[0].text).toContain('Release notes body');
+            });
+
+            it('should pass release options to config', async () => {
+                vi.mocked(ReleaseCommand.execute).mockResolvedValue({
+                    title: 'Release',
+                    body: 'Notes',
+                });
+
+                await executeTool('kilde_release', {
+                    fromTag: 'v1.0.0',
+                    toTag: 'v2.0.0',
+                    version: 'v2.0.0',
+                    output: 'RELEASE.md',
+                    interactive: true,
+                    focus: 'breaking changes',
+                    context: 'Migration guide',
+                    contextFiles: ['CHANGELOG.md'],
+                    dryRun: false,
+                    verbose: true,
+                    debug: true,
+                }, mockContext);
+
+                const callArgs = vi.mocked(ReleaseCommand.execute).mock.calls[0][0];
+                expect(callArgs.release?.from).toBe('v1.0.0');
+                expect(callArgs.release?.to).toBe('v2.0.0');
+                expect(callArgs.release?.interactive).toBe(true);
+                expect(callArgs.release?.focus).toBe('breaking changes');
+                expect(callArgs.release?.context).toBe('Migration guide');
+                expect(callArgs.release?.contextFiles).toEqual(['CHANGELOG.md']);
+                expect((callArgs.release as any)?.version).toBe('v2.0.0');
+                expect((callArgs.release as any)?.output).toBe('RELEASE.md');
+                expect(callArgs.dryRun).toBe(false);
+                expect(callArgs.verbose).toBe(true);
+                expect(callArgs.debug).toBe(true);
+            });
+
+            it('should handle errors gracefully', async () => {
+                const error = new Error('Release failed');
+                vi.mocked(ReleaseCommand.execute).mockRejectedValue(error);
+
+                await expect(executeTool('kilde_release', {}, mockContext)).rejects.toThrow('Release failed');
+                expect(mockLogger.error).toHaveBeenCalled();
+            });
+
+            it('should use HEAD as default toTag', async () => {
+                vi.mocked(ReleaseCommand.execute).mockResolvedValue({
+                    title: 'Release',
+                    body: 'Notes',
+                });
+
+                await executeTool('kilde_release', { fromTag: 'v1.0.0' }, mockContext);
+
+                const callArgs = vi.mocked(ReleaseCommand.execute).mock.calls[0][0];
+                expect(callArgs.release?.to).toBe('HEAD');
+            });
+        });
+
+        describe('unknown tool', () => {
+            it('should throw error for unknown tool name', async () => {
+                await expect(executeTool('unknown_tool', {}, mockContext)).rejects.toThrow('Unknown tool: unknown_tool');
+            });
+        });
+    });
+
+    describe('getTools', () => {
+        it('should return array of tool definitions', () => {
+            const tools = getTools();
+            expect(Array.isArray(tools)).toBe(true);
+            expect(tools.length).toBe(2);
+        });
+
+        it('should include kilde_commit tool', () => {
+            const tools = getTools();
+            const commitTool = tools.find(t => t.name === 'kilde_commit');
+
+            expect(commitTool).toBeDefined();
+            expect(commitTool?.description).toContain('commit');
+            expect(commitTool?.inputSchema.properties.add).toBeDefined();
+            expect(commitTool?.inputSchema.properties.sendit).toBeDefined();
+            expect(commitTool?.inputSchema.properties.cached).toBeDefined();
+        });
+
+        it('should include kilde_release tool', () => {
+            const tools = getTools();
+            const releaseTool = tools.find(t => t.name === 'kilde_release');
+
+            expect(releaseTool).toBeDefined();
+            expect(releaseTool?.description).toContain('release');
+            expect(releaseTool?.inputSchema.properties.fromTag).toBeDefined();
+            expect(releaseTool?.inputSchema.properties.toTag).toBeDefined();
+            expect(releaseTool?.inputSchema.properties.version).toBeDefined();
+        });
+
+        it('should have correct input schema types', () => {
+            const tools = getTools();
+            const commitTool = tools.find(t => t.name === 'kilde_commit');
+
+            expect(commitTool?.inputSchema.type).toBe('object');
+            expect(commitTool?.inputSchema.properties?.add?.type).toBe('boolean');
+            expect(commitTool?.inputSchema.properties?.context?.type).toBe('string');
+            expect(commitTool?.inputSchema.properties?.contextFiles?.type).toBe('array');
+        });
+    });
+});