@fractary/faber 2.4.40 → 2.4.42

package/dist/faber/__tests__/config-manager.test.js

@@ -0,0 +1,637 @@
+/**
+ * @fractary/faber - FaberConfigManager Tests
+ *
+ * Unit tests for FaberConfigManager with workflow resolution
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { FaberConfigManager } from '../config-manager';
+describe('FaberConfigManager', () => {
+    const testDir = path.join(__dirname, '__test-config-manager__');
+    const configDir = path.join(testDir, '.fractary', 'plugins', 'faber');
+    const configPath = path.join(configDir, 'config.json');
+    const workflowsDir = path.join(configDir, 'workflows');
+    let manager;
+    /**
+     * Create a minimal valid configuration
+     */
+    function createMinimalConfig() {
+        return {
+            schema_version: '2.0',
+            default_workflow: 'default',
+            integrations: {
+                work_plugin: 'fractary-work',
+                repo_plugin: 'fractary-repo',
+            },
+            workflows: [
+                {
+                    id: 'default',
+                    description: 'Default workflow',
+                    phases: createDefaultPhases(),
+                    autonomy: {
+                        level: 'guarded',
+                    },
+                },
+            ],
+        };
+    }
+    /**
+     * Create default phase definitions
+     */
+    function createDefaultPhases() {
+        const defaultPhase = {
+            enabled: true,
+            description: 'Default phase',
+            steps: [],
+        };
+        return {
+            frame: { ...defaultPhase, description: 'Frame phase' },
+            architect: { ...defaultPhase, description: 'Architect phase' },
+            build: { ...defaultPhase, description: 'Build phase' },
+            evaluate: { ...defaultPhase, description: 'Evaluate phase' },
+            release: { ...defaultPhase, description: 'Release phase' },
+        };
+    }
+    /**
+     * Write config file to disk
+     */
+    function writeConfig(config) {
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    /**
+     * Write workflow file to disk
+     */
+    function writeWorkflowFile(filename, workflow) {
+        fs.mkdirSync(workflowsDir, { recursive: true });
+        const filePath = path.join(workflowsDir, filename);
+        fs.writeFileSync(filePath, JSON.stringify(workflow, null, 2), 'utf-8');
+    }
+    beforeEach(() => {
+        // Clean up test directory before each test
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(testDir, { recursive: true });
+        // Mock process.cwd() to return testDir
+        jest.spyOn(process, 'cwd').mockReturnValue(testDir);
+        // Create manager with default config
+        manager = new FaberConfigManager();
+    });
+    afterEach(() => {
+        // Clean up test directory after each test
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+        // Restore mocks
+        jest.restoreAllMocks();
+    });
+    describe('Constructor', () => {
+        it('should construct with default config', () => {
+            const mgr = new FaberConfigManager();
+            expect(mgr).toBeDefined();
+        });
+        it('should construct with custom config', () => {
+            const mgr = new FaberConfigManager({
+                configDir: '.custom/faber',
+                configFile: 'faber.json',
+                workflowsDir: 'defs',
+            });
+            expect(mgr).toBeDefined();
+        });
+        it('should construct with partial config', () => {
+            const mgr = new FaberConfigManager({
+                configDir: '.custom/faber',
+            });
+            expect(mgr).toBeDefined();
+        });
+    });
+    describe('Config Loading', () => {
+        describe('configExists', () => {
+            it('should return false when config does not exist', () => {
+                expect(manager.configExists()).toBe(false);
+            });
+            it('should return true when config exists', () => {
+                writeConfig(createMinimalConfig());
+                expect(manager.configExists()).toBe(true);
+            });
+        });
+        describe('load', () => {
+            it('should throw error when config not found', async () => {
+                await expect(manager.load())
+                    .rejects.toThrow('Configuration not found');
+            });
+            it('should load valid configuration', async () => {
+                const config = createMinimalConfig();
+                writeConfig(config);
+                const loaded = await manager.load();
+                expect(loaded.schema_version).toBe('2.0');
+                expect(loaded.integrations.work_plugin).toBe('fractary-work');
+            });
+            it('should throw error on invalid JSON', async () => {
+                fs.mkdirSync(configDir, { recursive: true });
+                fs.writeFileSync(configPath, '{ invalid json }', 'utf-8');
+                await expect(manager.load())
+                    .rejects.toThrow('Failed to load configuration');
+            });
+        });
+        describe('getConfig', () => {
+            it('should load config if not already loaded', async () => {
+                writeConfig(createMinimalConfig());
+                const config = await manager.getConfig();
+                expect(config.schema_version).toBe('2.0');
+            });
+            it('should return cached config on subsequent calls', async () => {
+                writeConfig(createMinimalConfig());
+                const config1 = await manager.getConfig();
+                const config2 = await manager.getConfig();
+                expect(config1).toBe(config2); // Same reference
+            });
+        });
+        describe('reload', () => {
+            it('should clear cache and reload', async () => {
+                const config1 = createMinimalConfig();
+                writeConfig(config1);
+                await manager.load();
+                // Modify config on disk
+                const config2 = { ...config1, schema_version: '3.0' };
+                writeConfig(config2);
+                const reloaded = await manager.reload();
+                expect(reloaded.schema_version).toBe('3.0');
+            });
+        });
+    });
+    describe('Validation', () => {
+        describe('validate', () => {
+            it('should report missing schema_version', async () => {
+                const config = createMinimalConfig();
+                delete config.schema_version;
+                writeConfig(config);
+                const result = await manager.validate();
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContain('Missing required field: schema_version');
+            });
+            it('should report missing integrations', async () => {
+                const config = createMinimalConfig();
+                delete config.integrations;
+                writeConfig(config);
+                const result = await manager.validate();
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContain('Missing required field: integrations');
+            });
+            it('should report missing work_plugin', async () => {
+                const config = createMinimalConfig();
+                delete config.integrations.work_plugin;
+                writeConfig(config);
+                const result = await manager.validate();
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContain('Missing required integration: work_plugin');
+            });
+            it('should report missing repo_plugin', async () => {
+                const config = createMinimalConfig();
+                delete config.integrations.repo_plugin;
+                writeConfig(config);
+                const result = await manager.validate();
+                expect(result.valid).toBe(false);
+                expect(result.errors).toContain('Missing required integration: repo_plugin');
+            });
+            it('should report missing workflow file', async () => {
+                const config = createMinimalConfig();
+                config.workflows = [
+                    { id: 'test', file: 'workflows/nonexistent.json' },
+                ];
+                writeConfig(config);
+                const result = await manager.validate();
+                expect(result.warnings).toContain('Workflow file not found: workflows/nonexistent.json');
+            });
+            it('should pass validation for valid config', async () => {
+                writeConfig(createMinimalConfig());
+                const result = await manager.validate();
+                expect(result.valid).toBe(true);
+                expect(result.errors).toHaveLength(0);
+            });
+        });
+    });
+    describe('Workflow Operations', () => {
+        describe('resolveWorkflow', () => {
+            it('should resolve default workflow', async () => {
+                writeConfig(createMinimalConfig());
+                const workflow = await manager.resolveWorkflow();
+                expect(workflow.id).toBe('default');
+            });
+            it('should resolve workflow by ID', async () => {
+                const config = createMinimalConfig();
+                config.workflows.push({
+                    id: 'feature',
+                    description: 'Feature workflow',
+                    phases: createDefaultPhases(),
+                    autonomy: { level: 'autonomous' },
+                });
+                writeConfig(config);
+                const workflow = await manager.resolveWorkflow('feature');
+                expect(workflow.id).toBe('feature');
+                expect(workflow.autonomy.level).toBe('autonomous');
+            });
+            it('should throw error for unknown workflow', async () => {
+                writeConfig(createMinimalConfig());
+                await expect(manager.resolveWorkflow('unknown'))
+                    .rejects.toThrow('Workflow not found: unknown');
+            });
+            it('should resolve workflow from file reference', async () => {
+                const config = createMinimalConfig();
+                config.workflows = [
+                    { id: 'file-workflow', file: 'workflows/custom.json' },
+                ];
+                writeConfig(config);
+                const fileWorkflow = {
+                    id: 'file-workflow',
+                    description: 'From file',
+                    phases: createDefaultPhases(),
+                    autonomy: { level: 'assisted' },
+                };
+                writeWorkflowFile('custom.json', fileWorkflow);
+                const workflow = await manager.resolveWorkflow('file-workflow');
+                expect(workflow.description).toBe('From file');
+            });
+            it('should cache resolved workflows', async () => {
+                writeConfig(createMinimalConfig());
+                const workflow1 = await manager.resolveWorkflow('default');
+                const workflow2 = await manager.resolveWorkflow('default');
+                expect(workflow1).toBe(workflow2); // Same reference from cache
+            });
+        });
+        describe('listWorkflows', () => {
+            it('should list all workflows', async () => {
+                const config = createMinimalConfig();
+                config.workflows.push({
+                    id: 'feature',
+                    description: 'Feature workflow',
+                    phases: createDefaultPhases(),
+                    autonomy: { level: 'autonomous' },
+                });
+                writeConfig(config);
+                const workflows = await manager.listWorkflows();
+                expect(workflows).toHaveLength(2);
+                expect(workflows.map(w => w.id)).toContain('default');
+                expect(workflows.map(w => w.id)).toContain('feature');
+            });
+            it('should identify file-based workflows', async () => {
+                const config = createMinimalConfig();
+                config.workflows = [
+                    { id: 'file-workflow', file: 'workflows/custom.json' },
+                ];
+                writeConfig(config);
+                const workflows = await manager.listWorkflows();
+                expect(workflows[0].isFile).toBe(true);
+                expect(workflows[0].filePath).toBe('workflows/custom.json');
+            });
+            it('should identify inline workflows', async () => {
+                writeConfig(createMinimalConfig());
+                const workflows = await manager.listWorkflows();
+                expect(workflows[0].isFile).toBe(false);
+                expect(workflows[0].filePath).toBeUndefined();
+            });
+        });
+        describe('getWorkflowForLabels', () => {
+            it('should return null when no label mapping', async () => {
+                writeConfig(createMinimalConfig());
+                const workflowId = await manager.getWorkflowForLabels(['bug', 'urgent']);
+                expect(workflowId).toBeNull();
+            });
+            it('should return workflow ID for matching label', async () => {
+                const config = createMinimalConfig();
+                config.workflow_inference = {
+                    label_mapping: {
+                        bug: 'bugfix',
+                        feature: 'feature-workflow',
+                    },
+                };
+                writeConfig(config);
+                const workflowId = await manager.getWorkflowForLabels(['bug', 'urgent']);
+                expect(workflowId).toBe('bugfix');
+            });
+            it('should return first matching label', async () => {
+                const config = createMinimalConfig();
+                config.workflow_inference = {
+                    label_mapping: {
+                        bug: 'bugfix',
+                        feature: 'feature-workflow',
+                    },
+                };
+                writeConfig(config);
+                const workflowId = await manager.getWorkflowForLabels(['feature', 'bug']);
+                expect(workflowId).toBe('feature-workflow');
+            });
+        });
+    });
+    describe('Workflow Inheritance', () => {
+        it('should resolve workflow with extends', async () => {
+            const config = createMinimalConfig();
+            config.workflows.push({
+                id: 'child',
+                extends: 'default',
+                description: 'Child workflow',
+                phases: createDefaultPhases(),
+                autonomy: { level: 'autonomous' },
+            });
+            writeConfig(config);
+            const workflow = await manager.resolveWorkflow('child');
+            expect(workflow.id).toBe('child');
+            expect(workflow.description).toBe('Child workflow');
+            expect(workflow.autonomy.level).toBe('autonomous');
+        });
+        it('should merge phases from parent', async () => {
+            const config = createMinimalConfig();
+            const parentWorkflow = config.workflows[0];
+            parentWorkflow.phases.frame.steps = [
+                { id: 'parent-step', name: 'Parent Step' },
+            ];
+            config.workflows.push({
+                id: 'child',
+                extends: 'default',
+                phases: {
+                    ...createDefaultPhases(),
+                    frame: {
+                        enabled: true,
+                        steps: [{ id: 'child-step', name: 'Child Step' }],
+                    },
+                },
+                autonomy: { level: 'guarded' },
+            });
+            writeConfig(config);
+            const workflow = await manager.resolveWorkflow('child');
+            // Child steps should come after parent steps
+            expect(workflow.phases.frame.steps).toHaveLength(2);
+            expect(workflow.phases.frame.steps[0].id).toBe('parent-step');
+            expect(workflow.phases.frame.steps[1].id).toBe('child-step');
+        });
+        it('should merge pre_steps and post_steps correctly', async () => {
+            const config = createMinimalConfig();
+            const parentWorkflow = config.workflows[0];
+            parentWorkflow.phases.frame.pre_steps = [
+                { id: 'parent-pre', name: 'Parent Pre' },
+            ];
+            parentWorkflow.phases.frame.post_steps = [
+                { id: 'parent-post', name: 'Parent Post' },
+            ];
+            config.workflows.push({
+                id: 'child',
+                extends: 'default',
+                phases: {
+                    ...createDefaultPhases(),
+                    frame: {
+                        enabled: true,
+                        pre_steps: [{ id: 'child-pre', name: 'Child Pre' }],
+                        post_steps: [{ id: 'child-post', name: 'Child Post' }],
+                    },
+                },
+                autonomy: { level: 'guarded' },
+            });
+            writeConfig(config);
+            const workflow = await manager.resolveWorkflow('child');
+            // Pre-steps: parent first, then child
+            expect(workflow.phases.frame.pre_steps).toHaveLength(2);
+            expect(workflow.phases.frame.pre_steps[0].id).toBe('parent-pre');
+            expect(workflow.phases.frame.pre_steps[1].id).toBe('child-pre');
+            // Post-steps: child first, then parent
+            expect(workflow.phases.frame.post_steps).toHaveLength(2);
+            expect(workflow.phases.frame.post_steps[0].id).toBe('child-post');
+            expect(workflow.phases.frame.post_steps[1].id).toBe('parent-post');
+        });
+        it('should apply skip_steps filter', async () => {
+            const config = createMinimalConfig();
+            const parentWorkflow = config.workflows[0];
+            parentWorkflow.phases.frame.steps = [
+                { id: 'step1', name: 'Step 1' },
+                { id: 'step2', name: 'Step 2' },
+                { id: 'step3', name: 'Step 3' },
+            ];
+            config.workflows.push({
+                id: 'child',
+                extends: 'default',
+                skip_steps: ['step2'],
+                phases: createDefaultPhases(),
+                autonomy: { level: 'guarded' },
+            });
+            writeConfig(config);
+            const workflow = await manager.resolveWorkflow('child');
+            expect(workflow.phases.frame.steps).toHaveLength(2);
+            expect(workflow.phases.frame.steps.map(s => s.id)).not.toContain('step2');
+        });
+        it('should inherit description from parent if not specified', async () => {
+            const config = createMinimalConfig();
+            config.workflows[0].description = 'Parent description';
+            config.workflows.push({
+                id: 'child',
+                extends: 'default',
+                phases: createDefaultPhases(),
+                autonomy: { level: 'guarded' },
+                // No description
+            });
+            writeConfig(config);
+            const workflow = await manager.resolveWorkflow('child');
+            expect(workflow.description).toBe('Parent description');
+        });
+    });
+    describe('Helper Methods', () => {
+        describe('getIntegrations', () => {
+            it('should return integrations config', async () => {
+                writeConfig(createMinimalConfig());
+                const integrations = await manager.getIntegrations();
+                expect(integrations.work_plugin).toBe('fractary-work');
+                expect(integrations.repo_plugin).toBe('fractary-repo');
+            });
+        });
+        describe('getLogging', () => {
+            it('should return undefined when not configured', async () => {
+                writeConfig(createMinimalConfig());
+                const logging = await manager.getLogging();
+                expect(logging).toBeUndefined();
+            });
+            it('should return logging config when present', async () => {
+                const config = createMinimalConfig();
+                config.logging = {
+                    use_logs_plugin: true,
+                    log_level: 'debug',
+                };
+                writeConfig(config);
+                const logging = await manager.getLogging();
+                expect(logging?.use_logs_plugin).toBe(true);
+                expect(logging?.log_level).toBe('debug');
+            });
+        });
+        describe('getSafety', () => {
+            it('should return undefined when not configured', async () => {
+                writeConfig(createMinimalConfig());
+                const safety = await manager.getSafety();
+                expect(safety).toBeUndefined();
+            });
+            it('should return safety config when present', async () => {
+                const config = createMinimalConfig();
+                config.safety = {
+                    protected_paths: ['*.env', 'secrets/**'],
+                    require_confirm_for: ['delete', 'force-push'],
+                };
+                writeConfig(config);
+                const safety = await manager.getSafety();
+                expect(safety?.protected_paths).toContain('*.env');
+                expect(safety?.require_confirm_for).toContain('delete');
+            });
+        });
+        describe('getDefaultWorkflowId', () => {
+            it('should return configured default', async () => {
+                const config = createMinimalConfig();
+                config.default_workflow = 'my-default';
+                writeConfig(config);
+                const defaultId = await manager.getDefaultWorkflowId();
+                expect(defaultId).toBe('my-default');
+            });
+            it('should return "default" when not configured', async () => {
+                const config = createMinimalConfig();
+                delete config.default_workflow;
+                writeConfig(config);
+                const defaultId = await manager.getDefaultWorkflowId();
+                expect(defaultId).toBe('default');
+            });
+        });
+        describe('getSchemaVersion', () => {
+            it('should return schema version', async () => {
+                writeConfig(createMinimalConfig());
+                const version = await manager.getSchemaVersion();
+                expect(version).toBe('2.0');
+            });
+        });
+        describe('isPathProtected', () => {
+            it('should return false when no safety config', async () => {
+                writeConfig(createMinimalConfig());
+                const isProtected = await manager.isPathProtected('.env');
+                expect(isProtected).toBe(false);
+            });
+            it('should match exact paths', async () => {
+                const config = createMinimalConfig();
+                config.safety = {
+                    protected_paths: ['.env'],
+                };
+                writeConfig(config);
+                expect(await manager.isPathProtected('.env')).toBe(true);
+                expect(await manager.isPathProtected('.env.local')).toBe(false);
+            });
+            it('should match glob patterns with *', async () => {
+                const config = createMinimalConfig();
+                config.safety = {
+                    protected_paths: ['*.env'],
+                };
+                writeConfig(config);
+                expect(await manager.isPathProtected('.env')).toBe(true);
+                expect(await manager.isPathProtected('local.env')).toBe(true);
+                expect(await manager.isPathProtected('.env.local')).toBe(false);
+            });
+            it('should match glob patterns with **', async () => {
+                const config = createMinimalConfig();
+                config.safety = {
+                    protected_paths: ['secrets/**'],
+                };
+                writeConfig(config);
+                // The simple glob implementation converts ** to .* regex
+                expect(await manager.isPathProtected('secrets/api-key')).toBe(true);
+                expect(await manager.isPathProtected('other/secrets/key')).toBe(false);
+            });
+        });
+        describe('requiresConfirmation', () => {
+            it('should return false when no safety config', async () => {
+                writeConfig(createMinimalConfig());
+                const requires = await manager.requiresConfirmation('delete');
+                expect(requires).toBe(false);
+            });
+            it('should return true for configured actions', async () => {
+                const config = createMinimalConfig();
+                config.safety = {
+                    require_confirm_for: ['delete', 'force-push'],
+                };
+                writeConfig(config);
+                expect(await manager.requiresConfirmation('delete')).toBe(true);
+                expect(await manager.requiresConfirmation('force-push')).toBe(true);
+                expect(await manager.requiresConfirmation('commit')).toBe(false);
+            });
+        });
+        describe('getPhaseSteps', () => {
+            it('should return flattened steps for a phase', async () => {
+                const config = createMinimalConfig();
+                const workflow = config.workflows[0];
+                workflow.phases.frame = {
+                    enabled: true,
+                    pre_steps: [{ id: 'pre1' }],
+                    steps: [{ id: 'main1' }, { id: 'main2' }],
+                    post_steps: [{ id: 'post1' }],
+                };
+                writeConfig(config);
+                const steps = await manager.getPhaseSteps('default', 'frame');
+                expect(steps).toHaveLength(4);
+                expect(steps.map(s => s.id)).toEqual(['pre1', 'main1', 'main2', 'post1']);
+            });
+            it('should handle phases with no steps', async () => {
+                writeConfig(createMinimalConfig());
+                const steps = await manager.getPhaseSteps('default', 'frame');
+                expect(steps).toHaveLength(0);
+            });
+        });
+        describe('getStep', () => {
+            it('should find step by ID across phases', async () => {
+                const config = createMinimalConfig();
+                const workflow = config.workflows[0];
+                workflow.phases.build.steps = [
+                    { id: 'implement', name: 'Implement feature' },
+                ];
+                writeConfig(config);
+                const result = await manager.getStep('default', 'implement');
+                expect(result).not.toBeNull();
+                expect(result?.phase).toBe('build');
+                expect(result?.step.name).toBe('Implement feature');
+            });
+            it('should return null for unknown step', async () => {
+                writeConfig(createMinimalConfig());
+                const result = await manager.getStep('default', 'nonexistent');
+                expect(result).toBeNull();
+            });
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should handle empty workflows array', async () => {
+            const config = createMinimalConfig();
+            config.workflows = [];
+            writeConfig(config);
+            const workflows = await manager.listWorkflows();
+            expect(workflows).toHaveLength(0);
+        });
+        it('should handle special characters in workflow IDs', async () => {
+            const config = createMinimalConfig();
+            config.workflows = [
+                {
+                    id: 'workflow-with-special_chars.v2',
+                    description: 'Special chars',
+                    phases: createDefaultPhases(),
+                    autonomy: { level: 'guarded' },
+                },
+            ];
+            writeConfig(config);
+            const workflow = await manager.resolveWorkflow('workflow-with-special_chars.v2');
+            expect(workflow.id).toBe('workflow-with-special_chars.v2');
+        });
+        it('should handle namespaced workflow IDs', async () => {
+            const config = createMinimalConfig();
+            config.workflows = [
+                {
+                    id: 'default',
+                    description: 'Default in project namespace',
+                    phases: createDefaultPhases(),
+                    autonomy: { level: 'guarded' },
+                },
+            ];
+            writeConfig(config);
+            // When no colon, defaults to 'project' namespace
+            const workflow = await manager.resolveWorkflow('default');
+            expect(workflow.id).toBe('default');
+        });
+    });
+});
+//# sourceMappingURL=config-manager.test.js.map