@vibescope/mcp-server 0.0.1

package/dist/validators.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validators.test.js

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest';
+import { ValidationError, validateRequired, validateUUID, validateTaskStatus, validateProjectStatus, validatePriority, validateProgressPercentage, validateEstimatedMinutes, validateEnvironment, VALID_TASK_STATUSES, VALID_PROJECT_STATUSES, VALID_ENVIRONMENTS, } from './validators.js';
+describe('ValidationError', () => {
+    it('should create error with message', () => {
+        const error = new ValidationError('Test error');
+        expect(error.message).toBe('Test error');
+        expect(error.name).toBe('ValidationError');
+    });
+    it('should include optional fields', () => {
+        const error = new ValidationError('Test error', {
+            field: 'test_field',
+            hint: 'Test hint',
+            validValues: ['a', 'b'],
+        });
+        expect(error.field).toBe('test_field');
+        expect(error.hint).toBe('Test hint');
+        expect(error.validValues).toEqual(['a', 'b']);
+    });
+    it('should serialize to JSON correctly', () => {
+        const error = new ValidationError('Test error', {
+            field: 'test_field',
+            hint: 'Test hint',
+            validValues: ['a', 'b'],
+        });
+        const json = error.toJSON();
+        expect(json.error).toBe('validation_error');
+        expect(json.message).toBe('Test error');
+        expect(json.field).toBe('test_field');
+        expect(json.hint).toBe('Test hint');
+        expect(json.valid_values).toEqual(['a', 'b']);
+    });
+});
+describe('validateRequired', () => {
+    it('should pass for valid values', () => {
+        expect(() => validateRequired('value', 'field')).not.toThrow();
+        expect(() => validateRequired(0, 'field')).not.toThrow();
+        expect(() => validateRequired(false, 'field')).not.toThrow();
+        expect(() => validateRequired({}, 'field')).not.toThrow();
+    });
+    it('should throw for undefined', () => {
+        expect(() => validateRequired(undefined, 'test_field')).toThrow(ValidationError);
+        expect(() => validateRequired(undefined, 'test_field')).toThrow('Missing required field: test_field');
+    });
+    it('should throw for null', () => {
+        expect(() => validateRequired(null, 'test_field')).toThrow(ValidationError);
+    });
+    it('should throw for empty string', () => {
+        expect(() => validateRequired('', 'test_field')).toThrow(ValidationError);
+    });
+});
+describe('validateUUID', () => {
+    it('should pass for valid UUIDs', () => {
+        expect(() => validateUUID('123e4567-e89b-12d3-a456-426614174000', 'id')).not.toThrow();
+        expect(() => validateUUID('00000000-0000-0000-0000-000000000000', 'id')).not.toThrow();
+        expect(() => validateUUID('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF', 'id')).not.toThrow();
+    });
+    it('should pass for undefined (optional)', () => {
+        expect(() => validateUUID(undefined, 'id')).not.toThrow();
+    });
+    it('should pass for empty string (treated as optional)', () => {
+        expect(() => validateUUID('', 'id')).not.toThrow();
+    });
+    it('should throw for invalid UUIDs', () => {
+        expect(() => validateUUID('not-a-uuid', 'id')).toThrow(ValidationError);
+        expect(() => validateUUID('123', 'id')).toThrow(ValidationError);
+        expect(() => validateUUID('123e4567-e89b-12d3-a456', 'id')).toThrow(ValidationError);
+        expect(() => validateUUID('123e4567-e89b-12d3-a456-426614174000-extra', 'id')).toThrow(ValidationError);
+    });
+});
+describe('validateTaskStatus', () => {
+    it('should pass for valid task statuses', () => {
+        for (const status of VALID_TASK_STATUSES) {
+            expect(() => validateTaskStatus(status)).not.toThrow();
+        }
+    });
+    it('should pass for undefined (optional)', () => {
+        expect(() => validateTaskStatus(undefined)).not.toThrow();
+    });
+    it('should throw for invalid status', () => {
+        expect(() => validateTaskStatus('invalid')).toThrow(ValidationError);
+        expect(() => validateTaskStatus('PENDING')).toThrow(ValidationError);
+        expect(() => validateTaskStatus('done')).toThrow(ValidationError);
+    });
+});
+describe('validateProjectStatus', () => {
+    it('should pass for valid project statuses', () => {
+        for (const status of VALID_PROJECT_STATUSES) {
+            expect(() => validateProjectStatus(status)).not.toThrow();
+        }
+    });
+    it('should pass for undefined (optional)', () => {
+        expect(() => validateProjectStatus(undefined)).not.toThrow();
+    });
+    it('should throw for invalid status', () => {
+        expect(() => validateProjectStatus('invalid')).toThrow(ValidationError);
+        expect(() => validateProjectStatus('ACTIVE')).toThrow(ValidationError);
+    });
+});
+describe('validatePriority', () => {
+    it('should pass for valid priorities 1-5', () => {
+        for (let i = 1; i <= 5; i++) {
+            expect(() => validatePriority(i)).not.toThrow();
+        }
+    });
+    it('should pass for undefined (optional)', () => {
+        expect(() => validatePriority(undefined)).not.toThrow();
+    });
+    it('should throw for out of range values', () => {
+        expect(() => validatePriority(0)).toThrow(ValidationError);
+        expect(() => validatePriority(6)).toThrow(ValidationError);
+        expect(() => validatePriority(-1)).toThrow(ValidationError);
+    });
+    it('should throw for non-integers', () => {
+        expect(() => validatePriority(1.5)).toThrow(ValidationError);
+        expect(() => validatePriority(2.7)).toThrow(ValidationError);
+    });
+});
+describe('validateProgressPercentage', () => {
+    it('should pass for valid percentages 0-100', () => {
+        expect(() => validateProgressPercentage(0)).not.toThrow();
+        expect(() => validateProgressPercentage(50)).not.toThrow();
+        expect(() => validateProgressPercentage(100)).not.toThrow();
+        expect(() => validateProgressPercentage(33.33)).not.toThrow();
+    });
+    it('should pass for undefined (optional)', () => {
+        expect(() => validateProgressPercentage(undefined)).not.toThrow();
+    });
+    it('should throw for out of range values', () => {
+        expect(() => validateProgressPercentage(-1)).toThrow(ValidationError);
+        expect(() => validateProgressPercentage(101)).toThrow(ValidationError);
+        expect(() => validateProgressPercentage(150)).toThrow(ValidationError);
+    });
+    it('should throw for non-finite values', () => {
+        expect(() => validateProgressPercentage(Infinity)).toThrow(ValidationError);
+        expect(() => validateProgressPercentage(NaN)).toThrow(ValidationError);
+    });
+});
+describe('validateEstimatedMinutes', () => {
+    it('should pass for valid positive integers', () => {
+        expect(() => validateEstimatedMinutes(1)).not.toThrow();
+        expect(() => validateEstimatedMinutes(30)).not.toThrow();
+        expect(() => validateEstimatedMinutes(120)).not.toThrow();
+    });
+    it('should pass for undefined (optional)', () => {
+        expect(() => validateEstimatedMinutes(undefined)).not.toThrow();
+    });
+    it('should throw for zero', () => {
+        expect(() => validateEstimatedMinutes(0)).toThrow(ValidationError);
+    });
+    it('should throw for negative values', () => {
+        expect(() => validateEstimatedMinutes(-1)).toThrow(ValidationError);
+        expect(() => validateEstimatedMinutes(-30)).toThrow(ValidationError);
+    });
+    it('should throw for non-integers', () => {
+        expect(() => validateEstimatedMinutes(1.5)).toThrow(ValidationError);
+        expect(() => validateEstimatedMinutes(30.5)).toThrow(ValidationError);
+    });
+});
+describe('validateEnvironment', () => {
+    it('should pass for valid environments', () => {
+        for (const env of VALID_ENVIRONMENTS) {
+            expect(() => validateEnvironment(env)).not.toThrow();
+        }
+    });
+    it('should pass for undefined (optional)', () => {
+        expect(() => validateEnvironment(undefined)).not.toThrow();
+    });
+    it('should pass for empty string (treated as optional)', () => {
+        expect(() => validateEnvironment('')).not.toThrow();
+    });
+    it('should throw for invalid environment', () => {
+        expect(() => validateEnvironment('invalid')).toThrow(ValidationError);
+        expect(() => validateEnvironment('PRODUCTION')).toThrow(ValidationError);
+        expect(() => validateEnvironment('prod')).toThrow(ValidationError);
+    });
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@vibescope/mcp-server",
+  "version": "0.0.1",
+  "description": "MCP server for Vibescope - AI project tracking tools",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "vibescope-mcp": "dist/index.js",
+    "vibescope-cli": "dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Nonatomic/Vibescope.git",
+    "directory": "packages/mcp-server"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "vibescope",
+    "ai",
+    "project-management"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.17"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.2",
+    "@supabase/supabase-js": "^2.90.1"
+  }
+}

package/src/cli.test.ts

@@ -0,0 +1,442 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createHash } from 'crypto';
+
+// Mock child_process before importing cli module
+vi.mock('child_process', () => ({
+	execSync: vi.fn(),
+}));
+
+// Mock @supabase/supabase-js
+vi.mock('@supabase/supabase-js', () => ({
+	createClient: vi.fn(),
+}));
+
+import { execSync } from 'child_process';
+import { createClient } from '@supabase/supabase-js';
+import {
+	hashApiKey,
+	detectGitUrl,
+	validateApiKey,
+	type AuthContext,
+	type VerificationResult,
+} from './cli.js';
+
+describe('CLI verification logic', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	describe('hashApiKey', () => {
+		it('should return SHA256 hash of the key', () => {
+			const key = 'test-api-key';
+			const expected = createHash('sha256').update(key).digest('hex');
+			expect(hashApiKey(key)).toBe(expected);
+		});
+
+		it('should return different hashes for different keys', () => {
+			const hash1 = hashApiKey('key1');
+			const hash2 = hashApiKey('key2');
+			expect(hash1).not.toBe(hash2);
+		});
+
+		it('should return same hash for same key', () => {
+			const hash1 = hashApiKey('same-key');
+			const hash2 = hashApiKey('same-key');
+			expect(hash1).toBe(hash2);
+		});
+
+		it('should return 64-character hex string', () => {
+			const hash = hashApiKey('any-key');
+			expect(hash).toMatch(/^[a-f0-9]{64}$/);
+		});
+	});
+
+	describe('detectGitUrl', () => {
+		it('should return normalized git URL when git command succeeds', () => {
+			vi.mocked(execSync).mockReturnValue('git@github.com:user/repo.git\n');
+			const result = detectGitUrl();
+			expect(result).toBe('https://github.com/user/repo');
+		});
+
+		it('should return null when git command fails', () => {
+			vi.mocked(execSync).mockImplementation(() => {
+				throw new Error('Not a git repository');
+			});
+			const result = detectGitUrl();
+			expect(result).toBeNull();
+		});
+
+		it('should handle HTTPS URLs', () => {
+			vi.mocked(execSync).mockReturnValue('https://github.com/user/repo.git\n');
+			const result = detectGitUrl();
+			expect(result).toBe('https://github.com/user/repo');
+		});
+
+		it('should call execSync with correct options', () => {
+			vi.mocked(execSync).mockReturnValue('https://github.com/user/repo.git');
+			detectGitUrl();
+			expect(execSync).toHaveBeenCalledWith('git config --get remote.origin.url', {
+				encoding: 'utf8',
+				timeout: 5000,
+				stdio: ['pipe', 'pipe', 'pipe'],
+			});
+		});
+	});
+
+	describe('validateApiKey', () => {
+		it('should return auth context for valid API key', async () => {
+			const mockSupabase = {
+				from: vi.fn().mockReturnThis(),
+				select: vi.fn().mockReturnThis(),
+				eq: vi.fn().mockReturnThis(),
+				single: vi.fn().mockResolvedValue({
+					data: { id: 'key-id-123', user_id: 'user-id-456' },
+					error: null,
+				}),
+			};
+
+			const result = await validateApiKey(mockSupabase, 'test-api-key');
+
+			expect(result).toEqual({
+				userId: 'user-id-456',
+				apiKeyId: 'key-id-123',
+			});
+		});
+
+		it('should return null for invalid API key', async () => {
+			const mockSupabase = {
+				from: vi.fn().mockReturnThis(),
+				select: vi.fn().mockReturnThis(),
+				eq: vi.fn().mockReturnThis(),
+				single: vi.fn().mockResolvedValue({
+					data: null,
+					error: { message: 'Not found' },
+				}),
+			};
+
+			const result = await validateApiKey(mockSupabase, 'invalid-key');
+			expect(result).toBeNull();
+		});
+
+		it('should query api_keys table with hashed key', async () => {
+			const mockFrom = vi.fn().mockReturnThis();
+			const mockSelect = vi.fn().mockReturnThis();
+			const mockEq = vi.fn().mockReturnThis();
+			const mockSingle = vi.fn().mockResolvedValue({ data: null, error: { message: 'Not found' } });
+
+			const mockSupabase = {
+				from: mockFrom,
+				select: mockSelect,
+				eq: mockEq,
+				single: mockSingle,
+			};
+
+			await validateApiKey(mockSupabase, 'test-key');
+
+			expect(mockFrom).toHaveBeenCalledWith('api_keys');
+			expect(mockSelect).toHaveBeenCalledWith('id, user_id');
+			expect(mockEq).toHaveBeenCalledWith('key_hash', hashApiKey('test-key'));
+		});
+
+		it('should return null when data is missing', async () => {
+			const mockSupabase = {
+				from: vi.fn().mockReturnThis(),
+				select: vi.fn().mockReturnThis(),
+				eq: vi.fn().mockReturnThis(),
+				single: vi.fn().mockResolvedValue({
+					data: undefined,
+					error: null,
+				}),
+			};
+
+			const result = await validateApiKey(mockSupabase, 'test-key');
+			expect(result).toBeNull();
+		});
+	});
+});
+
+describe('verify function integration', () => {
+	const originalEnv = process.env;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		// Reset process.env for each test
+		process.env = { ...originalEnv };
+	});
+
+	afterEach(() => {
+		process.env = originalEnv;
+	});
+
+	// Note: The verify function reads environment variables at module load time,
+	// so we need to test through dynamic imports or by mocking at a higher level.
+	// For now, we test the exported functions individually.
+
+	describe('environment variable validation', () => {
+		it('hashApiKey should work without env vars', () => {
+			// hashApiKey is a pure function that doesn't depend on env vars
+			expect(hashApiKey('test')).toBeTruthy();
+		});
+
+		it('detectGitUrl should work without env vars', () => {
+			vi.mocked(execSync).mockReturnValue('https://github.com/user/repo.git');
+			expect(detectGitUrl()).toBe('https://github.com/user/repo');
+		});
+	});
+
+	describe('validateApiKey error handling', () => {
+		it('should handle database errors gracefully', async () => {
+			const mockSupabase = {
+				from: vi.fn().mockReturnThis(),
+				select: vi.fn().mockReturnThis(),
+				eq: vi.fn().mockReturnThis(),
+				single: vi.fn().mockRejectedValue(new Error('Database connection failed')),
+			};
+
+			await expect(validateApiKey(mockSupabase, 'test-key')).rejects.toThrow('Database connection failed');
+		});
+
+		it('should handle empty string API key', async () => {
+			const mockSupabase = {
+				from: vi.fn().mockReturnThis(),
+				select: vi.fn().mockReturnThis(),
+				eq: vi.fn().mockReturnThis(),
+				single: vi.fn().mockResolvedValue({ data: null, error: null }),
+			};
+
+			const result = await validateApiKey(mockSupabase, '');
+			expect(result).toBeNull();
+		});
+	});
+});
+
+describe('VerificationResult types', () => {
+	it('should have correct status types', () => {
+		const compliant: VerificationResult = {
+			status: 'compliant',
+			reason: 'All good',
+		};
+		expect(compliant.status).toBe('compliant');
+
+		const nonCompliant: VerificationResult = {
+			status: 'non_compliant',
+			reason: 'Tasks in progress',
+			continuation_prompt: 'Complete your tasks',
+		};
+		expect(nonCompliant.status).toBe('non_compliant');
+
+		const error: VerificationResult = {
+			status: 'error',
+			reason: 'Missing env vars',
+		};
+		expect(error.status).toBe('error');
+
+		const noSession: VerificationResult = {
+			status: 'no_session',
+			reason: 'No git URL detected',
+		};
+		expect(noSession.status).toBe('no_session');
+	});
+
+	it('should support optional details', () => {
+		const result: VerificationResult = {
+			status: 'compliant',
+			reason: 'All good',
+			details: {
+				session_started: true,
+				project_id: 'proj-123',
+				project_name: 'Test Project',
+				git_url: 'https://github.com/user/repo',
+				in_progress_tasks: 0,
+				tasks_completed_this_session: 5,
+				progress_logs_this_session: 3,
+				blockers_logged_this_session: 1,
+				session_duration_minutes: 45,
+			},
+		};
+
+		expect(result.details?.session_started).toBe(true);
+		expect(result.details?.tasks_completed_this_session).toBe(5);
+	});
+});
+
+describe('AuthContext type', () => {
+	it('should have required fields', () => {
+		const auth: AuthContext = {
+			userId: 'user-123',
+			apiKeyId: 'key-456',
+		};
+		expect(auth.userId).toBe('user-123');
+		expect(auth.apiKeyId).toBe('key-456');
+	});
+});
+
+describe('verify function scenarios', () => {
+	const originalEnv = { ...process.env };
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		// Set up required env vars
+		process.env.SUPABASE_URL = 'https://test.supabase.co';
+		process.env.SUPABASE_SERVICE_KEY = 'test-service-key';
+		process.env.VIBESCOPE_API_KEY = 'test-api-key';
+	});
+
+	afterEach(() => {
+		process.env = { ...originalEnv };
+	});
+
+	// Helper to create a mock Supabase client with chainable methods
+	function createMockSupabase(overrides: {
+		apiKeyResult?: { data: unknown; error: unknown };
+		projectResult?: { data: unknown; error: unknown };
+		sessionResult?: { data: unknown; error: unknown };
+		tasksResult?: { data: unknown[] | null; error: unknown };
+		completedResult?: { count: number | null; error: unknown };
+		progressResult?: { count: number | null; error: unknown };
+		blockerResult?: { count: number | null; error: unknown };
+	} = {}) {
+		const defaultApiKey = { data: { id: 'key-id', user_id: 'user-id' }, error: null };
+		const defaultProject = {
+			data: { id: 'proj-id', name: 'Test Project', git_url: 'https://github.com/test/repo' },
+			error: null,
+		};
+		const defaultSession = {
+			data: {
+				id: 'session-id',
+				created_at: new Date(Date.now() - 10 * 60 * 1000).toISOString(), // 10 mins ago
+				last_synced_at: new Date().toISOString(),
+			},
+			error: null,
+		};
+		const defaultTasks = { data: [], error: null };
+		const defaultCompleted = { count: 1, error: null };
+		const defaultProgress = { count: 0, error: null };
+		const defaultBlocker = { count: 0, error: null };
+
+		let currentTable = '';
+		let selectCount = false;
+
+		const mock = {
+			from: vi.fn((table: string) => {
+				currentTable = table;
+				return mock;
+			}),
+			select: vi.fn((cols: string, opts?: { count: string }) => {
+				selectCount = !!opts?.count;
+				return mock;
+			}),
+			eq: vi.fn().mockReturnThis(),
+			gte: vi.fn().mockReturnThis(),
+			single: vi.fn(() => {
+				if (currentTable === 'api_keys') {
+					return Promise.resolve(overrides.apiKeyResult ?? defaultApiKey);
+				}
+				if (currentTable === 'projects') {
+					return Promise.resolve(overrides.projectResult ?? defaultProject);
+				}
+				if (currentTable === 'agent_sessions') {
+					return Promise.resolve(overrides.sessionResult ?? defaultSession);
+				}
+				return Promise.resolve({ data: null, error: null });
+			}),
+			then: vi.fn((resolve: (value: unknown) => void) => {
+				if (currentTable === 'tasks') {
+					if (selectCount) {
+						return Promise.resolve(overrides.completedResult ?? defaultCompleted).then(resolve);
+					}
+					return Promise.resolve(overrides.tasksResult ?? defaultTasks).then(resolve);
+				}
+				if (currentTable === 'progress_logs') {
+					return Promise.resolve(overrides.progressResult ?? defaultProgress).then(resolve);
+				}
+				if (currentTable === 'blockers') {
+					return Promise.resolve(overrides.blockerResult ?? defaultBlocker).then(resolve);
+				}
+				return Promise.resolve({ data: null, count: 0 }).then(resolve);
+			}),
+		};
+
+		return mock;
+	}
+
+	it('should validate API key and return auth context', async () => {
+		const mockSupabase = createMockSupabase();
+		const result = await validateApiKey(mockSupabase, 'test-key');
+
+		expect(result).toEqual({
+			userId: 'user-id',
+			apiKeyId: 'key-id',
+		});
+	});
+
+	it('should return null for invalid API key', async () => {
+		const mockSupabase = createMockSupabase({
+			apiKeyResult: { data: null, error: { message: 'Not found' } },
+		});
+		const result = await validateApiKey(mockSupabase, 'invalid-key');
+
+		expect(result).toBeNull();
+	});
+
+	it('should handle database query errors', async () => {
+		const mockSupabase = {
+			from: vi.fn().mockReturnThis(),
+			select: vi.fn().mockReturnThis(),
+			eq: vi.fn().mockReturnThis(),
+			single: vi.fn().mockRejectedValue(new Error('Connection timeout')),
+		};
+
+		await expect(validateApiKey(mockSupabase, 'key')).rejects.toThrow('Connection timeout');
+	});
+});
+
+describe('detectGitUrl edge cases', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should trim whitespace from git URL', () => {
+		vi.mocked(execSync).mockReturnValue('  https://github.com/user/repo.git  \n');
+		const result = detectGitUrl();
+		expect(result).toBe('https://github.com/user/repo');
+	});
+
+	it('should handle GitLab SSH URLs', () => {
+		vi.mocked(execSync).mockReturnValue('git@gitlab.com:user/repo.git');
+		const result = detectGitUrl();
+		expect(result).toBe('https://gitlab.com/user/repo');
+	});
+
+	it('should handle Azure DevOps SSH URLs (not normalized)', () => {
+		// Azure DevOps URLs are not normalized by the current implementation
+		// The URL is trimmed but SSH format is preserved
+		vi.mocked(execSync).mockReturnValue('git@ssh.dev.azure.com:v3/org/project/repo');
+		const result = detectGitUrl();
+		expect(result).toBe('git@ssh.dev.azure.com:v3/org/project/repo');
+	});
+
+	it('should handle Bitbucket SSH URLs', () => {
+		vi.mocked(execSync).mockReturnValue('git@bitbucket.org:user/repo.git');
+		const result = detectGitUrl();
+		expect(result).toBe('https://bitbucket.org/user/repo');
+	});
+
+	it('should return null on timeout', () => {
+		vi.mocked(execSync).mockImplementation(() => {
+			const error = new Error('Command timed out');
+			(error as NodeJS.ErrnoException).code = 'ETIMEDOUT';
+			throw error;
+		});
+		const result = detectGitUrl();
+		expect(result).toBeNull();
+	});
+
+	it('should return null when not in a git repo', () => {
+		vi.mocked(execSync).mockImplementation(() => {
+			throw new Error('fatal: not a git repository');
+		});
+		const result = detectGitUrl();
+		expect(result).toBeNull();
+	});
+});