antigravity-flow 1.0.0

package/dist/tests/commands/InitCommand.spec.js

@@ -0,0 +1,529 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const init_1 = require("../../src/commands/init");
+const inquirer_1 = __importDefault(require("inquirer"));
+const types_1 = require("../../src/core/types");
+jest.mock('inquirer');
+describe('InitCommand', () => {
+    let initCommand;
+    let mockWorkflowGenerator;
+    let mockLogger;
+    let mockLocalizationService;
+    let mockPipelineGenerator;
+    let mockConfigService;
+    let mockStackDetector;
+    let mockGitignoreGenerator;
+    let mockDockerfileGenerator;
+    let mockFileSystem;
+    // Helper to create mock answers for all prompt sections
+    const createMockAnswers = (overrides = {}) => {
+        const defaults = {
+            // Language
+            language: 'en',
+            // Core
+            projectDescription: 'Test project',
+            frontend: types_1.FrontendFramework.REACT,
+            backend: types_1.BackendFramework.NESTJS,
+            smartContract: types_1.SmartContractFramework.NONE,
+            database: types_1.DatabaseType.POSTGRESQL,
+            orm: types_1.OrmType.PRISMA,
+            architecture: types_1.ArchitectureType.HEXAGONAL,
+            rigor: types_1.RigorMode.STRICT,
+            // VCS
+            versionControl: types_1.VersionControlPlatform.GITHUB,
+            branchingStrategy: types_1.BranchingStrategy.GITHUB_FLOW,
+            commitConvention: types_1.CommitConvention.CONVENTIONAL,
+            // Tooling
+            packageManager: types_1.PackageManager.NPM,
+            testingFramework: types_1.TestingFramework.JEST,
+            coverageTarget: types_1.CoverageTarget.FULL,
+            // Monorepo
+            isMonorepo: false,
+            monorepoTool: types_1.MonorepoTool.NONE,
+            apps: [],
+            // Deployment
+            deploymentPlatform: types_1.DeploymentPlatform.VERCEL,
+            containerization: types_1.Containerization.NONE,
+            securityScanning: [types_1.SecurityScanningTool.DEPENDABOT],
+            // Commands
+            buildCommand: 'npm run build',
+            testCommand: 'npm test',
+            // Strict mode conditionals
+            prApprovalsRequired: 2,
+            preCommitHooks: true,
+            blockMergeOnFailingChecks: true,
+            // Hexagonal conditionals
+            interfacePrefix: 'I',
+            repositoryPattern: 'repository',
+            // Final
+            roles: [types_1.WorkflowRole.DEVELOPER, types_1.WorkflowRole.QA],
+            ideIntegration: [],
+            confirm: true,
+        };
+        return { ...defaults, ...overrides };
+    };
+    beforeEach(() => {
+        mockWorkflowGenerator = {
+            generateWorkflows: jest.fn(),
+            generateProjectContext: jest.fn(),
+        };
+        mockLogger = {
+            info: jest.fn(),
+            success: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+        };
+        mockLocalizationService = {
+            setLanguage: jest.fn(),
+            getLanguage: jest.fn(),
+            translate: jest.fn((key) => key),
+        };
+        mockPipelineGenerator = {
+            generatePipeline: jest.fn(),
+        };
+        mockConfigService = {
+            saveConfig: jest.fn(),
+            loadConfig: jest.fn(),
+        };
+        mockStackDetector = {
+            detectStack: jest.fn().mockResolvedValue({}),
+        };
+        mockGitignoreGenerator = {
+            generate: jest.fn().mockResolvedValue(undefined),
+        };
+        mockDockerfileGenerator = {
+            generate: jest.fn().mockResolvedValue(undefined),
+        };
+        mockFileSystem = {
+            exists: jest.fn().mockResolvedValue(false),
+            readFile: jest.fn().mockResolvedValue('Rule content'),
+            writeFile: jest.fn(),
+            createDirectory: jest.fn(),
+        };
+        initCommand = new init_1.InitCommand(mockWorkflowGenerator, mockLogger, mockLocalizationService, mockPipelineGenerator, mockConfigService, mockStackDetector, mockGitignoreGenerator, mockDockerfileGenerator, mockFileSystem);
+    });
+    describe('Basic Execution', () => {
+        it('should execute successfully with default configuration', async () => {
+            const answers = createMockAnswers();
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockLocalizationService.setLanguage).toHaveBeenCalledWith('en');
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalled();
+            expect(mockWorkflowGenerator.generateProjectContext).toHaveBeenCalled();
+            expect(mockPipelineGenerator.generatePipeline).toHaveBeenCalled();
+            expect(mockConfigService.saveConfig).toHaveBeenCalled();
+            expect(mockLogger.success).toHaveBeenCalledWith(expect.stringContaining('prompts.success'));
+        });
+        it('should cancel when user does not confirm', async () => {
+            const answers = createMockAnswers({ confirm: false });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockLogger.warn).toHaveBeenCalledWith('prompts.cancelled');
+            expect(mockWorkflowGenerator.generateWorkflows).not.toHaveBeenCalled();
+        });
+        it('should log error on failure', async () => {
+            inquirer_1.default.prompt.mockRejectedValue(new Error('Test Error'));
+            await initCommand.execute();
+            expect(mockLogger.error).toHaveBeenCalledWith('prompts.failed');
+        });
+    });
+    describe('New Roles', () => {
+        it('should support DevOps role', async () => {
+            const answers = createMockAnswers({ roles: [types_1.WorkflowRole.DEVOPS] });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining([types_1.WorkflowRole.DEVOPS]));
+        });
+        it('should support Security Engineer role', async () => {
+            const answers = createMockAnswers({ roles: [types_1.WorkflowRole.SECURITY] });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining([types_1.WorkflowRole.SECURITY]));
+        });
+        it('should support Tech Writer role', async () => {
+            const answers = createMockAnswers({ roles: [types_1.WorkflowRole.TECH_WRITER] });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining([types_1.WorkflowRole.TECH_WRITER]));
+        });
+        it('should support Data Engineer role', async () => {
+            const answers = createMockAnswers({ roles: [types_1.WorkflowRole.DATA_ENGINEER] });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining([types_1.WorkflowRole.DATA_ENGINEER]));
+        });
+        it('should support multiple new roles together', async () => {
+            const allNewRoles = [
+                types_1.WorkflowRole.DEVOPS,
+                types_1.WorkflowRole.SECURITY,
+                types_1.WorkflowRole.TECH_WRITER,
+                types_1.WorkflowRole.DATA_ENGINEER,
+            ];
+            const answers = createMockAnswers({ roles: allNewRoles });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining(allNewRoles));
+        });
+    });
+    describe('Database Configuration', () => {
+        it('should support PostgreSQL database', async () => {
+            const answers = createMockAnswers({
+                database: types_1.DatabaseType.POSTGRESQL,
+                orm: types_1.OrmType.PRISMA,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                techStack: expect.objectContaining({
+                    database: types_1.DatabaseType.POSTGRESQL,
+                    orm: types_1.OrmType.PRISMA,
+                }),
+            }), expect.anything());
+        });
+        it('should support SQL Server database', async () => {
+            const answers = createMockAnswers({
+                database: types_1.DatabaseType.SQLSERVER,
+                orm: types_1.OrmType.ENTITY_FRAMEWORK,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                techStack: expect.objectContaining({
+                    database: types_1.DatabaseType.SQLSERVER,
+                }),
+            }), expect.anything());
+        });
+        it('should support Oracle database', async () => {
+            const answers = createMockAnswers({
+                database: types_1.DatabaseType.ORACLE,
+                orm: types_1.OrmType.TYPEORM,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                techStack: expect.objectContaining({
+                    database: types_1.DatabaseType.ORACLE,
+                }),
+            }), expect.anything());
+        });
+        it('should support MongoDB with Mongoose', async () => {
+            const answers = createMockAnswers({
+                database: types_1.DatabaseType.MONGODB,
+                orm: types_1.OrmType.MONGOOSE,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                techStack: expect.objectContaining({
+                    database: types_1.DatabaseType.MONGODB,
+                    orm: types_1.OrmType.MONGOOSE,
+                }),
+            }), expect.anything());
+        });
+    });
+    describe('Framework Configuration', () => {
+        it('should support Next.js frontend', async () => {
+            const answers = createMockAnswers({ frontend: types_1.FrontendFramework.NEXTJS });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                techStack: expect.objectContaining({
+                    frontend: types_1.FrontendFramework.NEXTJS,
+                }),
+            }), expect.anything());
+        });
+        it('should support FastAPI backend', async () => {
+            const answers = createMockAnswers({
+                backend: types_1.BackendFramework.FASTAPI,
+                packageManager: types_1.PackageManager.POETRY,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                techStack: expect.objectContaining({
+                    backend: types_1.BackendFramework.FASTAPI,
+                }),
+            }), expect.anything());
+        });
+        it('should support Spring Boot backend', async () => {
+            const answers = createMockAnswers({
+                backend: types_1.BackendFramework.SPRING_BOOT,
+                packageManager: types_1.PackageManager.MAVEN,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                techStack: expect.objectContaining({
+                    backend: types_1.BackendFramework.SPRING_BOOT,
+                }),
+            }), expect.anything());
+        });
+        it('should support Solidity smart contracts', async () => {
+            const answers = createMockAnswers({
+                smartContract: types_1.SmartContractFramework.SOLIDITY,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                techStack: expect.objectContaining({
+                    smartContract: types_1.SmartContractFramework.SOLIDITY,
+                }),
+            }), expect.anything());
+        });
+    });
+    describe('Version Control Configuration', () => {
+        it('should configure GitHub with GitHub Flow', async () => {
+            const answers = createMockAnswers({
+                versionControl: types_1.VersionControlPlatform.GITHUB,
+                branchingStrategy: types_1.BranchingStrategy.GITHUB_FLOW,
+                commitConvention: types_1.CommitConvention.CONVENTIONAL,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                versionControl: types_1.VersionControlPlatform.GITHUB,
+                branchingStrategy: types_1.BranchingStrategy.GITHUB_FLOW,
+                commitConvention: types_1.CommitConvention.CONVENTIONAL,
+            }));
+        });
+        it('should configure GitLab with GitFlow', async () => {
+            const answers = createMockAnswers({
+                versionControl: types_1.VersionControlPlatform.GITLAB,
+                branchingStrategy: types_1.BranchingStrategy.GITFLOW,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                versionControl: types_1.VersionControlPlatform.GITLAB,
+                branchingStrategy: types_1.BranchingStrategy.GITFLOW,
+            }));
+        });
+        it('should support Azure DevOps', async () => {
+            const answers = createMockAnswers({
+                versionControl: types_1.VersionControlPlatform.AZURE_DEVOPS,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                versionControl: types_1.VersionControlPlatform.AZURE_DEVOPS,
+            }));
+        });
+    });
+    describe('Deployment Configuration', () => {
+        it('should configure Vercel deployment', async () => {
+            const answers = createMockAnswers({
+                deploymentPlatform: types_1.DeploymentPlatform.VERCEL,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                deploymentPlatform: types_1.DeploymentPlatform.VERCEL,
+            }));
+        });
+        it('should configure Docker with Kubernetes', async () => {
+            const answers = createMockAnswers({
+                deploymentPlatform: types_1.DeploymentPlatform.AWS,
+                containerization: types_1.Containerization.KUBERNETES,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                deploymentPlatform: types_1.DeploymentPlatform.AWS,
+                containerization: types_1.Containerization.KUBERNETES,
+            }));
+        });
+        it('should configure security scanning tools', async () => {
+            const answers = createMockAnswers({
+                securityScanning: [types_1.SecurityScanningTool.SNYK, types_1.SecurityScanningTool.SONARQUBE],
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                securityScanning: expect.arrayContaining([
+                    types_1.SecurityScanningTool.SNYK,
+                    types_1.SecurityScanningTool.SONARQUBE,
+                ]),
+            }));
+        });
+    });
+    describe('Monorepo Configuration', () => {
+        it('should configure Turborepo for monorepo', async () => {
+            const answers = createMockAnswers({
+                isMonorepo: true,
+                monorepoTool: types_1.MonorepoTool.TURBOREPO,
+                apps: ['api', 'web', 'mobile'],
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                isMonorepo: true,
+                monorepoTool: types_1.MonorepoTool.TURBOREPO,
+                apps: ['api', 'web', 'mobile'],
+            }), expect.anything());
+        });
+        it('should configure Nx for monorepo', async () => {
+            const answers = createMockAnswers({
+                isMonorepo: true,
+                monorepoTool: types_1.MonorepoTool.NX,
+                apps: ['backend', 'frontend'],
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                monorepoTool: types_1.MonorepoTool.NX,
+            }), expect.anything());
+        });
+    });
+    describe('IDE Integration', () => {
+        it('should configure Cursor integration', async () => {
+            const answers = createMockAnswers({
+                roles: [types_1.WorkflowRole.DEVELOPER],
+                ideIntegration: [types_1.IdeIntegration.CURSOR],
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            mockFileSystem.exists.mockResolvedValue(true);
+            await initCommand.execute();
+            expect(mockLogger.success).toHaveBeenCalledWith(expect.stringContaining('Cursor'));
+            expect(mockFileSystem.writeFile).toHaveBeenCalled();
+        });
+        it('should configure Gemini Code Assist integration', async () => {
+            const answers = createMockAnswers({
+                ideIntegration: [types_1.IdeIntegration.GEMINI],
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockLogger.success).toHaveBeenCalledWith(expect.stringContaining('Gemini Code Assist'));
+            expect(mockFileSystem.writeFile).toHaveBeenCalled();
+        });
+        it('should configure multiple IDE integrations', async () => {
+            const answers = createMockAnswers({
+                roles: [types_1.WorkflowRole.DEVELOPER],
+                ideIntegration: [types_1.IdeIntegration.CURSOR, types_1.IdeIntegration.WINDSURF, types_1.IdeIntegration.GEMINI],
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            mockFileSystem.exists.mockResolvedValue(true);
+            await initCommand.execute();
+            expect(mockLogger.success).toHaveBeenCalledWith(expect.stringContaining('Cursor'));
+            expect(mockLogger.success).toHaveBeenCalledWith(expect.stringContaining('Windsurf'));
+            expect(mockLogger.success).toHaveBeenCalledWith(expect.stringContaining('Gemini'));
+        });
+    });
+    describe('Rigor Modes', () => {
+        it('should configure strict mode with all options', async () => {
+            const answers = createMockAnswers({
+                rigor: types_1.RigorMode.STRICT,
+                prApprovalsRequired: 2,
+                preCommitHooks: true,
+                blockMergeOnFailingChecks: true,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                rigor: types_1.RigorMode.STRICT,
+                prApprovalsRequired: 2,
+                preCommitHooks: true,
+                blockMergeOnFailingChecks: true,
+            }));
+        });
+        it('should support standard rigor mode', async () => {
+            const answers = createMockAnswers({
+                rigor: types_1.RigorMode.STANDARD,
+                coverageTarget: types_1.CoverageTarget.HIGH,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                rigor: types_1.RigorMode.STANDARD,
+            }), expect.anything());
+        });
+        it('should support prototype rigor mode', async () => {
+            const answers = createMockAnswers({
+                rigor: types_1.RigorMode.PROTOTYPE,
+                coverageTarget: types_1.CoverageTarget.MINIMAL,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                rigor: types_1.RigorMode.PROTOTYPE,
+            }), expect.anything());
+        });
+        it('should support legacy rigor mode', async () => {
+            const answers = createMockAnswers({ rigor: types_1.RigorMode.LEGACY });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                rigor: types_1.RigorMode.LEGACY,
+            }), expect.anything());
+        });
+    });
+    describe('Architecture Configuration', () => {
+        it('should configure hexagonal architecture with interface prefix', async () => {
+            const answers = createMockAnswers({
+                architecture: types_1.ArchitectureType.HEXAGONAL,
+                interfacePrefix: 'I',
+                repositoryPattern: 'repository',
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                architecture: types_1.ArchitectureType.HEXAGONAL,
+                interfacePrefix: 'I',
+                repositoryPattern: 'repository',
+            }));
+        });
+        it('should configure clean architecture', async () => {
+            const answers = createMockAnswers({
+                architecture: types_1.ArchitectureType.CLEAN,
+                interfacePrefix: '',
+                repositoryPattern: 'dao',
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                architecture: types_1.ArchitectureType.CLEAN,
+            }), expect.anything());
+        });
+        it('should configure microservices architecture', async () => {
+            const answers = createMockAnswers({
+                architecture: types_1.ArchitectureType.MICROSERVICES,
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+                architecture: types_1.ArchitectureType.MICROSERVICES,
+            }), expect.anything());
+        });
+    });
+    describe('Package Manager Support', () => {
+        it('should use correct defaults for pnpm', async () => {
+            const answers = createMockAnswers({
+                packageManager: types_1.PackageManager.PNPM,
+                buildCommand: 'pnpm build',
+                testCommand: 'pnpm test',
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                packageManager: types_1.PackageManager.PNPM,
+                buildCommand: 'pnpm build',
+                testCommand: 'pnpm test',
+            }));
+        });
+        it('should use correct defaults for cargo (Rust)', async () => {
+            const answers = createMockAnswers({
+                backend: types_1.BackendFramework.RUST,
+                packageManager: types_1.PackageManager.CARGO,
+                buildCommand: 'cargo build',
+                testCommand: 'cargo test',
+            });
+            inquirer_1.default.prompt.mockResolvedValue(answers);
+            await initCommand.execute();
+            expect(mockConfigService.saveConfig).toHaveBeenCalledWith(expect.objectContaining({
+                packageManager: types_1.PackageManager.CARGO,
+            }));
+        });
+    });
+});

package/dist/tests/commands/InitConfig.spec.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const init_1 = require("../../src/commands/init");
+const inquirer_1 = __importDefault(require("inquirer"));
+const types_1 = require("../../src/core/types");
+jest.mock('inquirer');
+describe('InitCommand - Config Mode', () => {
+    let initCommand;
+    let mockWorkflowGenerator;
+    let mockLogger;
+    let mockLocalizationService;
+    let mockPipelineGenerator;
+    let mockConfigService;
+    let mockStackDetector;
+    let mockGitignoreGenerator;
+    let mockDockerfileGenerator;
+    let mockFileSystem;
+    beforeEach(() => {
+        mockWorkflowGenerator = {
+            generateWorkflows: jest.fn(),
+            generateProjectContext: jest.fn(),
+        };
+        mockLogger = {
+            info: jest.fn(),
+            success: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+        };
+        mockLocalizationService = {
+            setLanguage: jest.fn(),
+            getLanguage: jest.fn(),
+            translate: jest.fn((key) => key),
+        };
+        mockPipelineGenerator = {
+            generatePipeline: jest.fn(),
+        };
+        mockConfigService = {
+            saveConfig: jest.fn(),
+            loadConfig: jest.fn(),
+        };
+        mockStackDetector = {
+            detectStack: jest.fn().mockResolvedValue({}),
+        };
+        mockGitignoreGenerator = {
+            generate: jest.fn().mockResolvedValue(undefined),
+        };
+        mockDockerfileGenerator = {
+            generate: jest.fn().mockResolvedValue(undefined),
+        };
+        mockFileSystem = {
+            exists: jest.fn().mockResolvedValue(false),
+            readFile: jest.fn().mockResolvedValue(''),
+            writeFile: jest.fn(),
+            createDirectory: jest.fn(),
+        };
+        initCommand = new init_1.InitCommand(mockWorkflowGenerator, mockLogger, mockLocalizationService, mockPipelineGenerator, mockConfigService, mockStackDetector, mockGitignoreGenerator, mockDockerfileGenerator, mockFileSystem);
+    });
+    it('should load configuration from file and skip prompts', async () => {
+        const configPath = 'my-config.json';
+        const mockConfig = {
+            language: 'fr',
+            rootPath: '/test/path',
+            workflowDirectory: '.agent/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: {
+                frontend: types_1.FrontendFramework.VUE,
+                backend: types_1.BackendFramework.EXPRESS,
+                database: types_1.DatabaseType.MYSQL,
+                orm: types_1.OrmType.SEQUELIZE,
+                testingFramework: types_1.TestingFramework.JEST,
+                packageManager: types_1.PackageManager.YARN,
+            },
+            architecture: types_1.ArchitectureType.MVC,
+            rigor: types_1.RigorMode.STANDARD,
+            projectDescription: 'Configured Project',
+            isMonorepo: false,
+            apps: [],
+            versionControl: types_1.VersionControlPlatform.GITLAB,
+            deploymentPlatform: types_1.DeploymentPlatform.HEROKU,
+            roles: [types_1.WorkflowRole.PRODUCT_OWNER, types_1.WorkflowRole.ARCHITECT],
+            ideIntegrations: [types_1.IdeIntegration.WINDSURF],
+        };
+        mockFileSystem.exists.mockResolvedValue(true);
+        mockFileSystem.readFile.mockResolvedValue(JSON.stringify(mockConfig));
+        await initCommand.execute({ config: configPath });
+        // Should not prompt
+        expect(inquirer_1.default.prompt).not.toHaveBeenCalled();
+        // Should set language
+        expect(mockLocalizationService.setLanguage).toHaveBeenCalledWith('fr');
+        // Should generate files with config details
+        expect(mockWorkflowGenerator.generateWorkflows).toHaveBeenCalledWith(expect.objectContaining({
+            projectDescription: 'Configured Project',
+            architecture: types_1.ArchitectureType.MVC,
+        }), expect.arrayContaining([types_1.WorkflowRole.PRODUCT_OWNER, types_1.WorkflowRole.ARCHITECT]));
+        // Should integrate IDE
+        expect(mockFileSystem.writeFile).toHaveBeenCalledWith(expect.stringContaining('.windsurfrules'), expect.anything());
+    });
+    it('should handle missing config file gracefully', async () => {
+        mockFileSystem.exists.mockResolvedValue(false);
+        await initCommand.execute({ config: 'missing.json' });
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining('not found'));
+        expect(inquirer_1.default.prompt).not.toHaveBeenCalled();
+        expect(mockWorkflowGenerator.generateWorkflows).not.toHaveBeenCalled();
+    });
+});