antigravity-flow 1.0.0

package/dist/src/commands/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./init"), exports);
+__exportStar(require("./guide"), exports);
+__exportStar(require("./templates"), exports);

package/dist/src/commands/init.js

@@ -0,0 +1,581 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitCommand = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const path = __importStar(require("path"));
+const types_1 = require("../core/types");
+class InitCommand {
+    workflowGenerator;
+    logger;
+    localizationService;
+    pipelineGenerator;
+    configService;
+    stackDetector;
+    gitignoreGenerator;
+    dockerfileGenerator;
+    fileSystem;
+    constructor(workflowGenerator, logger, localizationService, pipelineGenerator, configService, stackDetector, gitignoreGenerator, dockerfileGenerator, fileSystem) {
+        this.workflowGenerator = workflowGenerator;
+        this.logger = logger;
+        this.localizationService = localizationService;
+        this.pipelineGenerator = pipelineGenerator;
+        this.configService = configService;
+        this.stackDetector = stackDetector;
+        this.gitignoreGenerator = gitignoreGenerator;
+        this.dockerfileGenerator = dockerfileGenerator;
+        this.fileSystem = fileSystem;
+    }
+    async execute(options = {}) {
+        try {
+            if (options.config) {
+                await this.executeWithConfig(options.config);
+                return;
+            }
+            const language = await this.promptLanguage();
+            this.localizationService.setLanguage(language);
+            this.showWelcome();
+            const projectRoot = process.cwd();
+            const detectedStack = await this.detectStack(projectRoot);
+            const coreAnswers = await this.promptCoreQuestions(detectedStack);
+            const vcsAnswers = await this.promptVersionControlQuestions();
+            const toolingAnswers = await this.promptToolingQuestions(coreAnswers.rigor);
+            const monorerepoAnswers = await this.promptMonorepoQuestions();
+            const deploymentAnswers = await this.promptDeploymentQuestions();
+            const commandAnswers = await this.promptCommandQuestions(toolingAnswers.packageManager);
+            const strictModeAnswers = await this.promptStrictModeQuestions(coreAnswers.rigor);
+            const hexagonalAnswers = await this.promptHexagonalQuestions(coreAnswers.architecture);
+            const finalAnswers = await this.promptFinalQuestions();
+            if (!finalAnswers.confirm) {
+                this.logger.warn(this.localizationService.translate('prompts.cancelled'));
+                return;
+            }
+            const projectDetails = this.buildProjectDetails(projectRoot, language, detectedStack, coreAnswers, vcsAnswers, toolingAnswers, monorerepoAnswers, deploymentAnswers, commandAnswers, strictModeAnswers, hexagonalAnswers, finalAnswers.ideIntegration, finalAnswers.roles);
+            await this.generateFiles(projectDetails, finalAnswers.roles);
+            await this.integrateWithIde(projectDetails, finalAnswers.ideIntegration, finalAnswers.roles);
+            this.logger.success(this.localizationService.translate('prompts.success'));
+        }
+        catch (error) {
+            this.logger.error(this.localizationService.translate('prompts.failed'));
+        }
+    }
+    async promptLanguage() {
+        const answer = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'language',
+                message: 'Select language / Choisissez votre langue',
+                choices: ['en', 'fr'],
+                default: 'en',
+            },
+        ]);
+        return answer.language;
+    }
+    showWelcome() {
+        this.logger.info(this.localizationService.translate('prompts.welcome'));
+        this.logger.info(this.localizationService.translate('prompts.intro'));
+    }
+    async detectStack(projectRoot) {
+        this.logger.info('Auto-detecting project stack...');
+        const detectedStack = await this.stackDetector.detectStack(projectRoot);
+        if (Object.keys(detectedStack).length > 0) {
+            this.logger.success(`Detected: ${JSON.stringify(detectedStack)}`);
+        }
+        else {
+            this.logger.info('No specific stack detected. Falling back to defaults.');
+        }
+        return detectedStack;
+    }
+    async promptCoreQuestions(detectedStack) {
+        return inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'projectDescription',
+                message: this.localizationService.translate('prompts.project_description'),
+                default: 'My awesome project',
+            },
+            {
+                type: 'list',
+                name: 'frontend',
+                message: this.localizationService.translate('prompts.frontend'),
+                choices: Object.values(types_1.FrontendFramework),
+                default: detectedStack.frontend || types_1.FrontendFramework.NONE,
+            },
+            {
+                type: 'list',
+                name: 'backend',
+                message: this.localizationService.translate('prompts.backend'),
+                choices: Object.values(types_1.BackendFramework),
+                default: detectedStack.backend || types_1.BackendFramework.NONE,
+            },
+            {
+                type: 'list',
+                name: 'smartContract',
+                message: this.localizationService.translate('prompts.smart_contract'),
+                choices: Object.values(types_1.SmartContractFramework),
+                default: detectedStack.smartContract || types_1.SmartContractFramework.NONE,
+            },
+            {
+                type: 'list',
+                name: 'database',
+                message: this.localizationService.translate('prompts.database'),
+                choices: Object.values(types_1.DatabaseType),
+                default: types_1.DatabaseType.NONE,
+            },
+            {
+                type: 'list',
+                name: 'orm',
+                message: this.localizationService.translate('prompts.orm'),
+                choices: Object.values(types_1.OrmType),
+                default: types_1.OrmType.NONE,
+                when: (answers) => answers.database !== types_1.DatabaseType.NONE,
+            },
+            {
+                type: 'list',
+                name: 'architecture',
+                message: this.localizationService.translate('prompts.architecture'),
+                choices: Object.values(types_1.ArchitectureType),
+                default: types_1.ArchitectureType.HEXAGONAL,
+            },
+            {
+                type: 'list',
+                name: 'rigor',
+                message: this.localizationService.translate('prompts.rigor'),
+                choices: Object.values(types_1.RigorMode),
+                default: types_1.RigorMode.STRICT,
+            },
+        ]);
+    }
+    async promptVersionControlQuestions() {
+        return inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'versionControl',
+                message: this.localizationService.translate('prompts.version_control'),
+                choices: Object.values(types_1.VersionControlPlatform),
+                default: types_1.VersionControlPlatform.GITHUB,
+            },
+            {
+                type: 'list',
+                name: 'branchingStrategy',
+                message: this.localizationService.translate('prompts.branching_strategy'),
+                choices: Object.values(types_1.BranchingStrategy),
+                default: types_1.BranchingStrategy.GITHUB_FLOW,
+                when: (answers) => answers.versionControl !== types_1.VersionControlPlatform.NONE,
+            },
+            {
+                type: 'list',
+                name: 'commitConvention',
+                message: this.localizationService.translate('prompts.commit_convention'),
+                choices: Object.values(types_1.CommitConvention),
+                default: types_1.CommitConvention.CONVENTIONAL,
+                when: (answers) => answers.versionControl !== types_1.VersionControlPlatform.NONE,
+            },
+        ]);
+    }
+    async promptToolingQuestions(rigor) {
+        return inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'packageManager',
+                message: this.localizationService.translate('prompts.package_manager'),
+                choices: Object.values(types_1.PackageManager),
+                default: types_1.PackageManager.NPM,
+            },
+            {
+                type: 'list',
+                name: 'testingFramework',
+                message: this.localizationService.translate('prompts.testing_framework'),
+                choices: Object.values(types_1.TestingFramework),
+                default: types_1.TestingFramework.JEST,
+            },
+            {
+                type: 'list',
+                name: 'coverageTarget',
+                message: this.localizationService.translate('prompts.coverage_target'),
+                choices: Object.values(types_1.CoverageTarget),
+                default: rigor === types_1.RigorMode.STRICT ? types_1.CoverageTarget.FULL : types_1.CoverageTarget.HIGH,
+            },
+        ]);
+    }
+    async promptMonorepoQuestions() {
+        return inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'isMonorepo',
+                message: this.localizationService.translate('prompts.is_monorepo'),
+                default: false,
+            },
+            {
+                type: 'list',
+                name: 'monorepoTool',
+                message: this.localizationService.translate('prompts.monorepo_tool'),
+                choices: Object.values(types_1.MonorepoTool),
+                default: types_1.MonorepoTool.TURBOREPO,
+                when: (answers) => answers.isMonorepo,
+            },
+            {
+                type: 'input',
+                name: 'apps',
+                message: this.localizationService.translate('prompts.monorepo_apps'),
+                when: (answers) => answers.isMonorepo,
+                filter: (input) => input
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter((s) => s.length > 0),
+            },
+        ]);
+    }
+    async promptDeploymentQuestions() {
+        return inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'deploymentPlatform',
+                message: this.localizationService.translate('prompts.deployment_platform'),
+                choices: Object.values(types_1.DeploymentPlatform),
+                default: types_1.DeploymentPlatform.NONE,
+            },
+            {
+                type: 'list',
+                name: 'containerization',
+                message: this.localizationService.translate('prompts.containerization'),
+                choices: Object.values(types_1.Containerization),
+                default: types_1.Containerization.DOCKER,
+                when: (answers) => answers.deploymentPlatform !== types_1.DeploymentPlatform.VERCEL &&
+                    answers.deploymentPlatform !== types_1.DeploymentPlatform.NETLIFY &&
+                    answers.deploymentPlatform !== types_1.DeploymentPlatform.NONE,
+            },
+            {
+                type: 'checkbox',
+                name: 'securityScanning',
+                message: this.localizationService.translate('prompts.security_scanning'),
+                choices: Object.values(types_1.SecurityScanningTool).filter((s) => s !== types_1.SecurityScanningTool.NONE),
+                default: [types_1.SecurityScanningTool.DEPENDABOT],
+            },
+        ]);
+    }
+    async promptCommandQuestions(packageManager) {
+        return inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'buildCommand',
+                message: this.localizationService.translate('prompts.build_command'),
+                default: this.getDefaultBuildCommand(packageManager),
+            },
+            {
+                type: 'input',
+                name: 'testCommand',
+                message: this.localizationService.translate('prompts.test_command'),
+                default: this.getDefaultTestCommand(packageManager),
+            },
+        ]);
+    }
+    async promptStrictModeQuestions(rigor) {
+        if (rigor !== types_1.RigorMode.STRICT)
+            return {};
+        return inquirer_1.default.prompt([
+            {
+                type: 'number',
+                name: 'prApprovalsRequired',
+                message: this.localizationService.translate('prompts.pr_approvals'),
+                default: 2,
+            },
+            {
+                type: 'confirm',
+                name: 'preCommitHooks',
+                message: this.localizationService.translate('prompts.pre_commit_hooks'),
+                default: true,
+            },
+            {
+                type: 'confirm',
+                name: 'blockMergeOnFailingChecks',
+                message: this.localizationService.translate('prompts.block_merge_failing'),
+                default: true,
+            },
+        ]);
+    }
+    async promptHexagonalQuestions(architecture) {
+        if (architecture !== types_1.ArchitectureType.HEXAGONAL && architecture !== types_1.ArchitectureType.CLEAN)
+            return {};
+        return inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'interfacePrefix',
+                message: this.localizationService.translate('prompts.interface_prefix'),
+                default: 'I',
+            },
+            {
+                type: 'list',
+                name: 'repositoryPattern',
+                message: this.localizationService.translate('prompts.repository_pattern'),
+                choices: ['repository', 'dao', 'active-record'],
+                default: 'repository',
+            },
+        ]);
+    }
+    async promptFinalQuestions() {
+        return inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'roles',
+                message: this.localizationService.translate('prompts.workflows_selection'),
+                choices: Object.values(types_1.WorkflowRole).map((role) => ({
+                    name: this.localizationService.translate(`roles.${role}`),
+                    value: role,
+                })),
+                default: [types_1.WorkflowRole.DEVELOPER, types_1.WorkflowRole.QA, types_1.WorkflowRole.LEAD_DEV],
+            },
+            {
+                type: 'checkbox',
+                name: 'ideIntegration',
+                message: this.localizationService.translate('prompts.ide_integration'),
+                choices: [
+                    { name: 'Cursor (.cursor/rules)', value: types_1.IdeIntegration.CURSOR },
+                    { name: 'Windsurf (.windsurfrules)', value: types_1.IdeIntegration.WINDSURF },
+                    { name: 'Gemini Code Assist (.gemini)', value: types_1.IdeIntegration.GEMINI },
+                    { name: 'GitHub Copilot', value: types_1.IdeIntegration.COPILOT },
+                ],
+                default: [],
+            },
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: this.localizationService.translate('prompts.confirm'),
+                default: true,
+            },
+        ]);
+    }
+    buildProjectDetails(projectRoot, language, detectedStack, coreAnswers, vcsAnswers, toolingAnswers, monorepoAnswers, deploymentAnswers, commandAnswers, strictModeAnswers, hexagonalAnswers, ideIntegrations, roles) {
+        return {
+            rootPath: projectRoot,
+            workflowDirectory: '.agent/workflows',
+            rulesDirectory: '.agent/rules',
+            buildCommand: commandAnswers.buildCommand,
+            testCommand: commandAnswers.testCommand,
+            techStack: {
+                frontend: coreAnswers.frontend,
+                backend: coreAnswers.backend,
+                smartContract: coreAnswers.smartContract,
+                database: coreAnswers.database,
+                orm: coreAnswers.orm,
+                testingFramework: toolingAnswers.testingFramework,
+                packageManager: toolingAnswers.packageManager,
+            },
+            architecture: coreAnswers.architecture,
+            rigor: coreAnswers.rigor,
+            projectDescription: coreAnswers.projectDescription,
+            isMonorepo: monorepoAnswers.isMonorepo,
+            apps: monorepoAnswers.apps,
+            monorepoTool: monorepoAnswers.monorepoTool,
+            language: language,
+            versionControl: vcsAnswers.versionControl,
+            branchingStrategy: vcsAnswers.branchingStrategy,
+            commitConvention: vcsAnswers.commitConvention,
+            packageManager: toolingAnswers.packageManager,
+            coverageTarget: toolingAnswers.coverageTarget,
+            deploymentPlatform: deploymentAnswers.deploymentPlatform,
+            containerization: deploymentAnswers.containerization,
+            securityScanning: deploymentAnswers.securityScanning,
+            ideIntegrations: ideIntegrations,
+            roles: roles,
+            ...strictModeAnswers,
+            ...hexagonalAnswers,
+        };
+    }
+    async generateFiles(projectDetails, roles) {
+        await this.workflowGenerator.generateWorkflows(projectDetails, roles);
+        await this.workflowGenerator.generateProjectContext(projectDetails);
+        await this.pipelineGenerator.generatePipeline(projectDetails);
+        await this.gitignoreGenerator.generate(projectDetails.rootPath, projectDetails.techStack);
+        await this.dockerfileGenerator.generate(projectDetails.rootPath, projectDetails.techStack);
+        await this.configService.saveConfig(projectDetails);
+    }
+    async integrateWithIde(projectDetails, ideIntegrations, roles) {
+        const rulesPath = path.join(projectDetails.rootPath, '.agent/rules/coding-standards.md');
+        const rulesContent = await this.fileSystem.readFile(rulesPath);
+        if (ideIntegrations.includes(types_1.IdeIntegration.CURSOR)) {
+            await this.integrateCursor(projectDetails, rulesContent, roles);
+        }
+        if (ideIntegrations.includes(types_1.IdeIntegration.WINDSURF)) {
+            await this.integrateWindsurf(projectDetails, rulesContent, roles);
+        }
+        if (ideIntegrations.includes(types_1.IdeIntegration.GEMINI)) {
+            await this.integrateGemini(projectDetails, rulesContent);
+        }
+        // Future: Copilot, Cody integrations
+    }
+    async integrateCursor(projectDetails, rulesContent, roles) {
+        // 1. Base Rules
+        const cursorPath = path.join(projectDetails.rootPath, '.cursor/rules/antigravity.mdc');
+        await this.fileSystem.createDirectory(path.dirname(cursorPath));
+        await this.fileSystem.writeFile(cursorPath, rulesContent);
+        this.logger.success('Integrated with Cursor (.cursor/rules/antigravity.mdc)');
+        // 2. Roles
+        for (const role of roles) {
+            const roleFileName = `${role.toLowerCase()}.md`;
+            const sourcePath = path.join(projectDetails.rootPath, projectDetails.workflowDirectory, roleFileName);
+            if (await this.fileSystem.exists(sourcePath)) {
+                const ruleContent = await this.fileSystem.readFile(sourcePath);
+                const mdcContent = `---
+description: Act as a ${role}
+globs: **/*
+---
+${ruleContent}`;
+                const rolePath = path.join(projectDetails.rootPath, '.cursor/rules', `${role.toLowerCase()}.mdc`);
+                await this.fileSystem.writeFile(rolePath, mdcContent);
+            }
+        }
+        this.logger.success('Integrated Roles with Cursor (.cursor/rules/*.mdc)');
+    }
+    async integrateWindsurf(projectDetails, rulesContent, roles) {
+        // 1. Base Rules (.windsurfrules)
+        const windsurfPath = path.join(projectDetails.rootPath, '.windsurfrules');
+        let currentContent = '';
+        if (await this.fileSystem.exists(windsurfPath)) {
+            currentContent = await this.fileSystem.readFile(windsurfPath);
+        }
+        const separator = '\n\n# Antigravity Rules\n\n';
+        if (!currentContent.includes('# Antigravity Rules')) {
+            await this.fileSystem.writeFile(windsurfPath, currentContent + separator + rulesContent);
+            this.logger.success('Integrated with Windsurf (.windsurfrules)');
+        }
+        else {
+            this.logger.info('Windsurf already configured, skipping append.');
+        }
+        // 2. Roles (.windsurf/rules/)
+        for (const role of roles) {
+            const roleFileName = `${role.toLowerCase()}.md`;
+            const sourcePath = path.join(projectDetails.rootPath, projectDetails.workflowDirectory, roleFileName);
+            if (await this.fileSystem.exists(sourcePath)) {
+                const ruleContent = await this.fileSystem.readFile(sourcePath);
+                const rolePath = path.join(projectDetails.rootPath, '.windsurf/rules', roleFileName);
+                await this.fileSystem.createDirectory(path.dirname(rolePath));
+                await this.fileSystem.writeFile(rolePath, ruleContent);
+            }
+        }
+        this.logger.success('Integrated Roles with Windsurf (.windsurf/rules/*.md)');
+    }
+    async integrateGemini(projectDetails, rulesContent) {
+        const geminiPath = path.join(projectDetails.rootPath, '.gemini/settings.json');
+        await this.fileSystem.createDirectory(path.dirname(geminiPath));
+        const geminiConfig = {
+            codeAssist: {
+                customInstructions: rulesContent.substring(0, 2000),
+            },
+        };
+        await this.fileSystem.writeFile(geminiPath, JSON.stringify(geminiConfig, null, 2));
+        this.logger.success('Integrated with Gemini Code Assist (.gemini/settings.json)');
+    }
+    getDefaultBuildCommand(packageManager) {
+        switch (packageManager) {
+            case types_1.PackageManager.YARN:
+                return 'yarn build';
+            case types_1.PackageManager.PNPM:
+                return 'pnpm build';
+            case types_1.PackageManager.BUN:
+                return 'bun run build';
+            case types_1.PackageManager.CARGO:
+                return 'cargo build';
+            case types_1.PackageManager.POETRY:
+                return 'poetry build';
+            case types_1.PackageManager.GO_MODULES:
+                return 'go build';
+            case types_1.PackageManager.MAVEN:
+                return 'mvn package';
+            case types_1.PackageManager.GRADLE:
+                return 'gradle build';
+            case types_1.PackageManager.NUGET:
+                return 'dotnet build';
+            default:
+                return 'npm run build';
+        }
+    }
+    getDefaultTestCommand(packageManager) {
+        switch (packageManager) {
+            case types_1.PackageManager.YARN:
+                return 'yarn test';
+            case types_1.PackageManager.PNPM:
+                return 'pnpm test';
+            case types_1.PackageManager.BUN:
+                return 'bun test';
+            case types_1.PackageManager.CARGO:
+                return 'cargo test';
+            case types_1.PackageManager.POETRY:
+                return 'poetry run pytest';
+            case types_1.PackageManager.GO_MODULES:
+                return 'go test ./...';
+            case types_1.PackageManager.MAVEN:
+                return 'mvn test';
+            case types_1.PackageManager.GRADLE:
+                return 'gradle test';
+            case types_1.PackageManager.NUGET:
+                return 'dotnet test';
+            default:
+                return 'npm run test';
+        }
+    }
+    async executeWithConfig(configPath) {
+        const projectRoot = process.cwd();
+        const fullConfigPath = path.isAbsolute(configPath) ? configPath : path.join(projectRoot, configPath);
+        if (!await this.fileSystem.exists(fullConfigPath)) {
+            this.logger.error(`Configuration file not found: ${fullConfigPath}`);
+            return;
+        }
+        this.logger.info(`Loading configuration from ${fullConfigPath}...`);
+        const content = await this.fileSystem.readFile(fullConfigPath);
+        try {
+            const projectDetails = JSON.parse(content);
+            // Override paths to current context
+            projectDetails.rootPath = projectRoot;
+            if (projectDetails.language) {
+                this.localizationService.setLanguage(projectDetails.language);
+            }
+            this.logger.info('Using configuration to skip prompts.');
+            const roles = projectDetails.roles || [types_1.WorkflowRole.DEVELOPER]; // Default if missing
+            await this.generateFiles(projectDetails, roles);
+            if (projectDetails.ideIntegrations) {
+                await this.integrateWithIde(projectDetails, projectDetails.ideIntegrations, roles);
+            }
+            this.logger.success('Project initialized from configuration successfully.');
+        }
+        catch (e) {
+            this.logger.error(`Failed to parse configuration: ${e.message}`);
+        }
+    }
+}
+exports.InitCommand = InitCommand;