@gitgov/core 1.0.0

package/dist/src/adapters/project_adapter/project_adapter.test.js

@@ -0,0 +1,627 @@
+import { ProjectAdapter } from './index';
+import { RecordStore } from '../../store';
+import { ConfigManager } from '../../config_manager';
+import { DetailedValidationError } from '../../validation/common';
+import { promises as fs, existsSync } from 'fs';
+import { createTaskRecord } from '../../factories/task_factory';
+import { createCycleRecord } from '../../factories/cycle_factory';
+// Mock the factories before importing
+jest.mock('../../factories/task_factory', () => ({
+    createTaskRecord: jest.fn()
+}));
+jest.mock('../../factories/cycle_factory', () => ({
+    createCycleRecord: jest.fn()
+}));
+jest.mock('../../factories/actor_factory', () => ({
+    createActorRecord: jest.fn()
+}));
+// Mock dependencies
+jest.mock('../../store');
+jest.mock('../../config_manager');
+jest.mock('fs', () => ({
+    promises: {
+        access: jest.fn(),
+        writeFile: jest.fn(),
+        readFile: jest.fn(),
+        unlink: jest.fn(),
+        mkdir: jest.fn(),
+        rm: jest.fn(),
+        appendFile: jest.fn(),
+    },
+    existsSync: jest.fn(),
+}));
+// Helper function to create mock actor record
+function createMockActorRecord(overrides = {}) {
+    return {
+        id: 'human:test-user',
+        type: 'human',
+        displayName: 'Test User',
+        publicKey: 'test-public-key',
+        roles: ['admin', 'author'],
+        status: 'active',
+        ...overrides,
+    };
+}
+// Helper function to create mock cycle record
+function createMockCycleRecord(overrides = {}) {
+    return {
+        id: `${Date.now()}-cycle-test-cycle`,
+        title: 'Test Cycle',
+        status: 'planning',
+        taskIds: [],
+        childCycleIds: [],
+        tags: [],
+        notes: '',
+        ...overrides,
+    };
+}
+// Helper function to create mock task record
+function createMockTaskRecord(overrides = {}) {
+    return {
+        id: `${Date.now()}-task-test-task`,
+        title: 'Test Task',
+        status: 'draft',
+        priority: 'medium',
+        description: 'Test task description',
+        tags: [],
+        cycleIds: [],
+        ...overrides,
+    };
+}
+describe('ProjectAdapter', () => {
+    let projectAdapter;
+    let mockIdentityAdapter;
+    let mockBacklogAdapter;
+    let mockWorkflowMethodologyAdapter;
+    let mockConfigManager;
+    let mockTaskStore;
+    let mockCycleStore;
+    let mockFs;
+    let mockCreateTaskRecord;
+    let mockCreateCycleRecord;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock all adapters
+        mockIdentityAdapter = {
+            createActor: jest.fn(),
+            getActor: jest.fn(),
+            listActors: jest.fn(),
+            revokeActor: jest.fn(),
+            createAgentRecord: jest.fn(),
+            getAgentRecord: jest.fn(),
+            listAgentRecords: jest.fn(),
+            getCurrentActor: jest.fn(),
+            getEffectiveActorForAgent: jest.fn(),
+        };
+        mockBacklogAdapter = {
+            createTask: jest.fn(),
+            createCycle: jest.fn(),
+            getTask: jest.fn(),
+            getCycle: jest.fn(),
+            getAllTasks: jest.fn(),
+            getAllCycles: jest.fn(),
+        };
+        mockWorkflowMethodologyAdapter = {
+            getTransitionRule: jest.fn(),
+            validateSignature: jest.fn(),
+            validateCustomRules: jest.fn(),
+        };
+        mockConfigManager = {
+            loadConfig: jest.fn(),
+            loadSession: jest.fn(),
+            getRootCycle: jest.fn(),
+            getProjectInfo: jest.fn(),
+            getActorState: jest.fn(),
+            updateActorState: jest.fn(),
+            getCloudSessionToken: jest.fn(),
+            constructor: { name: 'ConfigManager' },
+        };
+        // Mock stores
+        mockTaskStore = {
+            write: jest.fn().mockResolvedValue(undefined),
+            read: jest.fn().mockResolvedValue(null),
+            list: jest.fn().mockResolvedValue([]),
+            delete: jest.fn().mockResolvedValue(undefined),
+            exists: jest.fn().mockResolvedValue(false),
+        };
+        mockCycleStore = {
+            write: jest.fn().mockResolvedValue(undefined),
+            read: jest.fn().mockResolvedValue(null),
+            list: jest.fn().mockResolvedValue([]),
+            delete: jest.fn().mockResolvedValue(undefined),
+            exists: jest.fn().mockResolvedValue(false),
+        };
+        mockFs = fs;
+        mockFs.existsSync = existsSync;
+        // Configure default mock behavior
+        mockFs.existsSync.mockReturnValue(true); // Default: .git exists
+        // Mock factories
+        mockCreateTaskRecord = createTaskRecord;
+        mockCreateCycleRecord = createCycleRecord;
+        // Setup factory mocks
+        mockCreateTaskRecord.mockImplementation(async (payload) => ({
+            id: `${Date.now()}-task-${payload.title?.toLowerCase().replace(/\s+/g, '-') || 'test'}`,
+            title: payload.title || 'Test Task',
+            status: payload.status || 'draft',
+            priority: payload.priority || 'medium',
+            description: payload.description || '',
+            tags: payload.tags || [],
+            cycleIds: payload.cycleIds || [],
+        }));
+        mockCreateCycleRecord.mockImplementation(async (payload) => ({
+            id: `${Date.now()}-cycle-${payload.title?.toLowerCase().replace(/\s+/g, '-') || 'test'}`,
+            title: payload.title || 'Test Cycle',
+            status: payload.status || 'planning',
+            taskIds: payload.taskIds || [],
+            childCycleIds: payload.childCycleIds || [],
+            tags: payload.tags || [],
+            notes: payload.notes || '',
+        }));
+        // Create adapter with all dependencies
+        projectAdapter = new ProjectAdapter({
+            identityAdapter: mockIdentityAdapter,
+            backlogAdapter: mockBacklogAdapter,
+            workflowMethodologyAdapter: mockWorkflowMethodologyAdapter,
+            configManager: mockConfigManager,
+            taskStore: mockTaskStore,
+            cycleStore: mockCycleStore,
+        });
+    });
+    describe('Environment Validation (EARS 2, 7, 8)', () => {
+        it('[EARS-21] should validate current directory, not search upward for init', async () => {
+            // This test prevents the critical bug where init modifies parent repositories
+            // Simulate being in /packages/cli/ but wanting to init there, not in parent /solo-hub/
+            // Mock: no .git in current directory (should fail validation)
+            mockFs.existsSync.mockImplementation((path) => {
+                if (typeof path === 'string' && path.includes('/packages/cli/.git')) {
+                    return false; // No .git in subdirectory
+                }
+                if (typeof path === 'string' && path.includes('/solo-hub/.git')) {
+                    return true; // .git exists in parent (should NOT be found)
+                }
+                return false;
+            });
+            // Mock: no write permissions in current directory
+            mockFs.writeFile.mockRejectedValueOnce(new Error('Permission denied'));
+            mockFs.access.mockRejectedValue(new Error('Directory does not exist')); // .gitgov doesn't exist
+            const result = await projectAdapter.validateEnvironment('/test/project/packages/cli');
+            // Should validate the EXACT directory passed, not search upward
+            expect(result.isValid).toBe(false);
+            expect(result.isGitRepo).toBe(false); // Should be false for /packages/cli/
+            expect(result.warnings).toContain('Not a Git repository in directory: /test/project/packages/cli');
+        });
+        it('[EARS-22] should use GITGOV_ORIGINAL_DIR when provided (pnpm --filter case)', async () => {
+            // This test ensures pnpm --filter cli dev init validates the correct directory
+            // Mock environment variables as they would be set by our wrapper
+            const originalEnv = process.env['GITGOV_ORIGINAL_DIR'];
+            process.env['GITGOV_ORIGINAL_DIR'] = '/test/project'; // User executed from root
+            try {
+                // Mock: .git exists in original directory
+                mockFs.existsSync.mockImplementation((path) => {
+                    if (typeof path === 'string' && path.includes('/test/project/.git')) {
+                        return true; // .git exists in original directory
+                    }
+                    return false;
+                });
+                // Mock: .gitgov already exists in original directory
+                mockFs.writeFile.mockResolvedValueOnce(undefined);
+                mockFs.unlink.mockResolvedValueOnce(undefined);
+                mockFs.access.mockResolvedValueOnce(undefined); // .gitgov exists
+                const result = await projectAdapter.validateEnvironment(); // No path = use env var
+                expect(result.isValid).toBe(false);
+                expect(result.isGitRepo).toBe(true);
+                expect(result.isAlreadyInitialized).toBe(true);
+                expect(result.warnings).toContain('GitGovernance already initialized in directory: /test/project');
+            }
+            finally {
+                // Restore original environment
+                if (originalEnv) {
+                    process.env['GITGOV_ORIGINAL_DIR'] = originalEnv;
+                }
+                else {
+                    delete process.env['GITGOV_ORIGINAL_DIR'];
+                }
+            }
+        });
+        it('[EARS-23] should create .gitgov in correct directory during init', async () => {
+            // This test ensures init creates .gitgov in the target directory, not in parent repos
+            const targetDirectory = '/tmp/new-project';
+            const originalEnv = process.env['GITGOV_ORIGINAL_DIR'];
+            process.env['GITGOV_ORIGINAL_DIR'] = targetDirectory;
+            try {
+                // Mock: .git exists in target directory
+                mockFs.existsSync.mockImplementation((path) => {
+                    if (typeof path === 'string' && path.includes(`${targetDirectory}/.git`)) {
+                        return true;
+                    }
+                    return false;
+                });
+                // Mock successful initialization
+                mockFs.writeFile.mockResolvedValue(undefined);
+                mockFs.unlink.mockResolvedValue(undefined);
+                mockFs.access.mockRejectedValue(new Error('Directory does not exist')); // .gitgov doesn't exist
+                mockFs.mkdir.mockResolvedValue(undefined);
+                mockFs.appendFile.mockResolvedValue(undefined);
+                const mockActor = createMockActorRecord();
+                const mockCycle = createMockCycleRecord();
+                mockIdentityAdapter.createActor.mockResolvedValueOnce(mockActor);
+                mockBacklogAdapter.createCycle.mockResolvedValueOnce(mockCycle);
+                const result = await projectAdapter.initializeProject({
+                    name: 'New Project',
+                    actorName: 'New User',
+                });
+                expect(result.success).toBe(true);
+                // Verify .gitgov directory creation was attempted in correct location
+                expect(mockFs.mkdir).toHaveBeenCalledWith(expect.stringContaining(targetDirectory), { recursive: true });
+                // Verify config.json was written to correct location
+                const configWriteCalls = mockFs.writeFile.mock.calls.filter(call => call[0].toString().includes('config.json'));
+                expect(configWriteCalls.length).toBeGreaterThan(0);
+                expect(configWriteCalls[0]?.[0]).toContain(targetDirectory);
+            }
+            finally {
+                // Restore original environment
+                if (originalEnv) {
+                    process.env['GITGOV_ORIGINAL_DIR'] = originalEnv;
+                }
+                else {
+                    delete process.env['GITGOV_ORIGINAL_DIR'];
+                }
+            }
+        });
+        it('[EARS-2] should verify git repo permissions and previous state', async () => {
+            // Mock successful validation using static method
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue('/test/project');
+            mockFs.writeFile.mockResolvedValueOnce(undefined);
+            mockFs.unlink.mockResolvedValueOnce(undefined);
+            mockFs.access.mockRejectedValueOnce(new Error('Directory does not exist'));
+            const result = await projectAdapter.validateEnvironment('/test/project');
+            expect(result.isValid).toBe(true);
+            expect(result.isGitRepo).toBe(true);
+            expect(result.hasWritePermissions).toBe(true);
+            expect(result.isAlreadyInitialized).toBe(false);
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('[EARS-7] should return EnvironmentValidation with specific warnings', async () => {
+            // Mock ConfigManager static method for this test
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue(null);
+            // Mock failed validation - no write permissions and no .git
+            mockFs.writeFile.mockRejectedValueOnce(new Error('Permission denied'));
+            mockFs.access.mockRejectedValue(new Error('Directory does not exist')); // .gitgov doesn't exist
+            mockFs.existsSync.mockReturnValue(false); // No .git directory
+            const result = await projectAdapter.validateEnvironment('/invalid/path');
+            expect(result.isValid).toBe(false);
+            expect(result.isGitRepo).toBe(false); // Should be false since findProjectRoot returns null
+            expect(result.hasWritePermissions).toBe(false);
+            expect(result.warnings).toContain('Not a Git repository in directory: /invalid/path');
+            expect(result.warnings).toContain('No write permissions in target directory');
+            expect(result.suggestions).toContain("Run 'git init' to initialize a Git repository first");
+        });
+        it('[EARS-8] should detect already initialized GitGovernance project', async () => {
+            // Mock already initialized project
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue('/test/project');
+            mockFs.writeFile.mockResolvedValueOnce(undefined);
+            mockFs.unlink.mockResolvedValueOnce(undefined);
+            mockFs.access.mockResolvedValueOnce(undefined); // .gitgov exists
+            const result = await projectAdapter.validateEnvironment('/test/project');
+            expect(result.isValid).toBe(false);
+            expect(result.isAlreadyInitialized).toBe(true);
+            expect(result.warnings).toContain('GitGovernance already initialized in directory: /test/project');
+            expect(result.suggestions).toContain("Use 'gitgov status' to check current state or choose a different directory");
+        });
+    });
+    describe('Project Initialization (EARS 1, 5)', () => {
+        beforeEach(() => {
+            // Setup successful mocks
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue('/test/project');
+            mockFs.writeFile.mockResolvedValue(undefined);
+            mockFs.unlink.mockResolvedValue(undefined);
+            mockFs.access.mockRejectedValue(new Error('Directory does not exist')); // .gitgov doesn't exist
+            mockFs.mkdir.mockResolvedValue(undefined);
+            mockFs.appendFile.mockResolvedValue(undefined);
+        });
+        it('[EARS-1] should create complete project with 3-adapter orchestration', async () => {
+            const mockActor = createMockActorRecord();
+            const mockCycle = createMockCycleRecord();
+            mockIdentityAdapter.createActor.mockResolvedValueOnce(mockActor);
+            mockBacklogAdapter.createCycle.mockResolvedValueOnce(mockCycle);
+            const result = await projectAdapter.initializeProject({
+                name: 'Test Project',
+                actorName: 'Test User',
+            });
+            expect(result.success).toBe(true);
+            expect(result.projectName).toBe('Test Project');
+            expect(result.rootCycle).toBe(mockCycle.id);
+            expect(result.actor.id).toBe(mockActor.id);
+            expect(result.actor.displayName).toBe(mockActor.displayName);
+            expect(mockIdentityAdapter.createActor).toHaveBeenCalledWith({
+                type: 'human',
+                displayName: 'Test User',
+                roles: ['admin', 'author'],
+            }, 'bootstrap');
+            expect(mockBacklogAdapter.createCycle).toHaveBeenCalledWith(expect.objectContaining({
+                title: 'root',
+                status: 'planning',
+            }), mockActor.id);
+        });
+        it('[EARS-5] should return ProjectInitResult with complete metadata', async () => {
+            const mockActor = createMockActorRecord();
+            const mockCycle = createMockCycleRecord();
+            mockIdentityAdapter.createActor.mockResolvedValueOnce(mockActor);
+            mockBacklogAdapter.createCycle.mockResolvedValueOnce(mockCycle);
+            const result = await projectAdapter.initializeProject({
+                name: 'Test Project',
+                actorName: 'Test User',
+                methodology: 'scrum',
+            });
+            expect(result).toEqual({
+                success: true,
+                projectId: 'test-project',
+                projectName: 'Test Project',
+                rootCycle: mockCycle.id,
+                actor: {
+                    id: mockActor.id,
+                    displayName: mockActor.displayName,
+                    publicKeyPath: expect.stringContaining(`${mockActor.id}.json`),
+                },
+                template: undefined,
+                initializationTime: expect.any(Number),
+                nextSteps: expect.arrayContaining([
+                    "Run 'gitgov status' to see your project overview",
+                    "Use 'gitgov task create' to add your first task"
+                ]),
+            });
+        });
+    });
+    describe('Template Processing (EARS 3, 6)', () => {
+        beforeEach(() => {
+            const mockTemplate = {
+                cycles: [
+                    {
+                        title: 'Sprint 1',
+                        status: 'active',
+                        tasks: [
+                            { title: 'Task 1', priority: 'high', description: 'Test task 1' },
+                            { title: 'Task 2', priority: 'medium', description: 'Test task 2' },
+                        ],
+                    },
+                ],
+            };
+            mockFs.readFile.mockResolvedValue(JSON.stringify(mockTemplate));
+        });
+        it('[EARS-3] should create cycles and tasks using factories with validation', async () => {
+            const mockCycle = createMockCycleRecord();
+            const mockTask1 = createMockTaskRecord({ title: 'Task 1' });
+            const mockTask2 = createMockTaskRecord({ title: 'Task 2' });
+            mockBacklogAdapter.createCycle.mockResolvedValueOnce(mockCycle);
+            mockBacklogAdapter.createTask
+                .mockResolvedValueOnce(mockTask1)
+                .mockResolvedValueOnce(mockTask2);
+            const projectContext = {
+                projectId: 'test-project',
+                projectName: 'Test Project',
+                actorId: 'human:test-user',
+                rootCycle: 'cycle-123',
+            };
+            const result = await projectAdapter.processBlueprintTemplate('./template.json', projectContext);
+            expect(result.success).toBe(true);
+            expect(result.cyclesCreated).toBe(1);
+            expect(result.tasksCreated).toBe(2);
+            expect(result.createdIds.cycles).toContain(mockCycle.id);
+            expect(result.createdIds.tasks).toContain(mockTask1.id);
+            expect(result.createdIds.tasks).toContain(mockTask2.id);
+            expect(mockBacklogAdapter.createCycle).toHaveBeenCalledWith(expect.objectContaining({
+                title: 'Sprint 1',
+                status: 'active',
+            }), projectContext.actorId);
+        });
+        it('[EARS-6] should throw DetailedValidationError for invalid template', async () => {
+            mockFs.readFile.mockResolvedValue(JSON.stringify({ invalid: 'template' }));
+            const projectContext = {
+                projectId: 'test-project',
+                projectName: 'Test Project',
+                actorId: 'human:test-user',
+                rootCycle: 'cycle-123',
+            };
+            await expect(projectAdapter.processBlueprintTemplate('./invalid-template.json', projectContext)).rejects.toThrow(DetailedValidationError);
+            await expect(projectAdapter.processBlueprintTemplate('./invalid-template.json', projectContext)).rejects.toThrow('Invalid template format');
+        });
+    });
+    describe('Error Handling & Rollback (EARS 4, 13, 15, 16, 17)', () => {
+        it('[EARS-4] should invoke rollback automatically when initialization fails', async () => {
+            // Mock ConfigManager static method for this test
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue('/test/project');
+            // Setup environment validation to pass
+            mockFs.writeFile.mockResolvedValue(undefined);
+            mockFs.unlink.mockResolvedValue(undefined);
+            mockFs.access.mockRejectedValueOnce(new Error('Directory does not exist')); // .gitgov doesn't exist (validation)
+            mockFs.mkdir.mockResolvedValue(undefined);
+            // Setup identity creation to fail
+            mockIdentityAdapter.createActor.mockRejectedValueOnce(new Error('Identity creation failed'));
+            // Setup rollback mocks
+            mockFs.access.mockResolvedValueOnce(undefined); // .gitgov exists for rollback
+            mockFs.rm.mockResolvedValue(undefined);
+            await expect(projectAdapter.initializeProject({
+                name: 'Test Project',
+                actorName: 'Test User',
+            })).rejects.toThrow('Identity creation failed');
+            // Verify rollback was called
+            expect(mockFs.rm).toHaveBeenCalledWith(expect.stringContaining('.gitgov'), { recursive: true, force: true });
+        });
+        it('[EARS-13] should capture adapter errors with specific context', async () => {
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue('/test/project');
+            mockFs.writeFile.mockResolvedValue(undefined);
+            mockFs.unlink.mockResolvedValue(undefined);
+            mockFs.access.mockRejectedValue(new Error('Directory does not exist'));
+            mockFs.mkdir.mockResolvedValue(undefined);
+            const specificError = new Error('BacklogAdapter connection failed');
+            mockIdentityAdapter.createActor.mockResolvedValueOnce(createMockActorRecord());
+            mockBacklogAdapter.createCycle.mockRejectedValueOnce(specificError);
+            await expect(projectAdapter.initializeProject({
+                name: 'Test Project',
+                actorName: 'Test User',
+            })).rejects.toThrow('BacklogAdapter connection failed');
+        });
+        it('[EARS-15] should provide specific guidance for environment errors', async () => {
+            // Mock ConfigManager static method for this test
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue(null);
+            mockFs.writeFile.mockRejectedValueOnce(new Error('Permission denied'));
+            mockFs.existsSync.mockReturnValue(false); // No .git directory
+            const result = await projectAdapter.validateEnvironment('/invalid/path');
+            expect(result.isValid).toBe(false);
+            expect(result.suggestions).toContain("Run 'git init' to initialize a Git repository first");
+            expect(result.suggestions).toContain('Ensure you have write permissions in the target directory');
+        });
+        it('[EARS-16] should provide field-level errors for DetailedValidationError', async () => {
+            mockFs.readFile.mockResolvedValue('invalid json');
+            const projectContext = {
+                projectId: 'test-project',
+                projectName: 'Test Project',
+                actorId: 'human:test-user',
+                rootCycle: 'cycle-123',
+            };
+            await expect(projectAdapter.processBlueprintTemplate('./invalid.json', projectContext)).rejects.toThrow(DetailedValidationError);
+            try {
+                await projectAdapter.processBlueprintTemplate('./invalid.json', projectContext);
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DetailedValidationError);
+                if (error instanceof DetailedValidationError) {
+                    expect(error.ajvErrors).toBeDefined();
+                    expect(error.ajvErrors[0]).toEqual({
+                        field: 'template',
+                        message: expect.any(String),
+                        value: './invalid.json',
+                    });
+                }
+            }
+        });
+        it('[EARS-17] should handle file system errors gracefully', async () => {
+            // Mock ConfigManager static method for this test
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue('/test/project');
+            // Mock file system error during permission check
+            mockFs.writeFile.mockRejectedValueOnce(new Error('Disk full'));
+            mockFs.access.mockRejectedValue(new Error('Directory does not exist')); // .gitgov doesn't exist
+            mockFs.existsSync.mockReturnValue(true); // .git exists but other errors
+            const result = await projectAdapter.validateEnvironment('/test/path');
+            expect(result.isValid).toBe(false);
+            expect(result.warnings).toContain('No write permissions in target directory');
+            expect(result.suggestions).toContain('Ensure you have write permissions in the target directory');
+        });
+    });
+    describe('Graceful Degradation (EARS 14)', () => {
+        it('[EARS-14] should continue without optional dependencies with warnings', async () => {
+            // Create adapter without optional dependencies
+            const minimalAdapter = new ProjectAdapter({
+                identityAdapter: mockIdentityAdapter,
+                backlogAdapter: mockBacklogAdapter,
+                workflowMethodologyAdapter: mockWorkflowMethodologyAdapter,
+                configManager: mockConfigManager,
+                taskStore: mockTaskStore,
+                cycleStore: mockCycleStore,
+                // No eventBus, platformApi, or userManagement
+            });
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue('/test/project');
+            mockFs.writeFile.mockResolvedValue(undefined);
+            mockFs.unlink.mockResolvedValue(undefined);
+            mockFs.access.mockRejectedValue(new Error('Directory does not exist'));
+            mockFs.mkdir.mockResolvedValue(undefined);
+            mockFs.appendFile.mockResolvedValue(undefined);
+            const mockActor = createMockActorRecord();
+            const mockCycle = createMockCycleRecord();
+            mockIdentityAdapter.createActor.mockResolvedValueOnce(mockActor);
+            mockBacklogAdapter.createCycle.mockResolvedValueOnce(mockCycle);
+            const result = await minimalAdapter.initializeProject({
+                name: 'Test Project',
+                actorName: 'Test User',
+            });
+            expect(result.success).toBe(true);
+            expect(result.projectName).toBe('Test Project');
+            // Should work without optional dependencies
+        });
+    });
+    describe('Future Platform Methods (EARS 19, 20)', () => {
+        it('[EARS-19] should return project metadata from ConfigManager', async () => {
+            const mockConfig = {
+                protocolVersion: '1.0.0',
+                projectId: 'test-project',
+                projectName: 'Test Project',
+                rootCycle: 'cycle-123',
+                blueprints: { root: './blueprints' },
+                state: { branch: 'gitgov-state' },
+            };
+            mockConfigManager.loadConfig.mockResolvedValueOnce(mockConfig);
+            const result = await projectAdapter.getProjectInfo();
+            expect(result).toEqual({
+                id: 'test-project',
+                name: 'Test Project',
+                rootCycle: 'cycle-123',
+                protocolVersion: '1.0.0',
+            });
+        });
+        it('[EARS-20] should handle missing configuration gracefully', async () => {
+            mockConfigManager.loadConfig.mockResolvedValueOnce(null);
+            const result = await projectAdapter.getProjectInfo();
+            expect(result).toBeNull();
+        });
+    });
+    describe('Type Safety (EARS 18)', () => {
+        it('[EARS-18] should compile without any or unknown types unjustified', () => {
+            // This test ensures TypeScript compilation is clean
+            // The fact that this test file compiles without errors validates EARS-18
+            expect(true).toBe(true);
+        });
+    });
+    describe('Integration Tests', () => {
+        it('should work end-to-end with real-like data', async () => {
+            // Setup complete successful scenario
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue('/test/project');
+            mockFs.writeFile.mockResolvedValue(undefined);
+            mockFs.unlink.mockResolvedValue(undefined);
+            mockFs.access.mockRejectedValue(new Error('Directory does not exist'));
+            mockFs.mkdir.mockResolvedValue(undefined);
+            mockFs.appendFile.mockResolvedValue(undefined);
+            const mockActor = createMockActorRecord({
+                id: 'human:project-owner',
+                displayName: 'Project Owner',
+            });
+            const mockCycle = createMockCycleRecord({
+                id: 'cycle-root-project',
+                title: 'My Awesome Project - Root Cycle',
+            });
+            mockIdentityAdapter.createActor.mockResolvedValueOnce(mockActor);
+            mockBacklogAdapter.createCycle.mockResolvedValueOnce(mockCycle);
+            const envValidation = await projectAdapter.validateEnvironment();
+            expect(envValidation.isValid).toBe(true);
+            const initResult = await projectAdapter.initializeProject({
+                name: 'My Awesome Project',
+                actorName: 'Project Owner',
+                methodology: 'scrum',
+            });
+            expect(initResult.success).toBe(true);
+            expect(initResult.projectName).toBe('My Awesome Project');
+            expect(initResult.actor.displayName).toBe('Project Owner');
+            expect(initResult.initializationTime).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('Performance Tests', () => {
+        it('should complete initialization in reasonable time', async () => {
+            jest.spyOn(ConfigManager, 'findProjectRoot').mockReturnValue('/test/project');
+            mockFs.writeFile.mockResolvedValue(undefined);
+            mockFs.unlink.mockResolvedValue(undefined);
+            mockFs.access.mockRejectedValue(new Error('Directory does not exist'));
+            mockFs.mkdir.mockResolvedValue(undefined);
+            mockFs.appendFile.mockResolvedValue(undefined);
+            mockIdentityAdapter.createActor.mockResolvedValueOnce(createMockActorRecord());
+            mockBacklogAdapter.createCycle.mockResolvedValueOnce(createMockCycleRecord());
+            const startTime = Date.now();
+            await projectAdapter.initializeProject({
+                name: 'Performance Test Project',
+                actorName: 'Test User',
+            });
+            const endTime = Date.now();
+            // Should complete within reasonable time (mocked, so should be very fast)
+            expect(endTime - startTime).toBeLessThan(1000);
+        });
+    });
+});
+//# sourceMappingURL=project_adapter.test.js.map