antigravity-flow 1.0.0

package/dist/src/commands/templates.js

@@ -0,0 +1,143 @@
+"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.TemplatesCommand = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+class TemplatesCommand {
+    logger;
+    localizationService;
+    templatesDir;
+    customTemplatesDir;
+    constructor(logger, localizationService, templatesDir, customTemplatesDir // .agent/templates
+    ) {
+        this.logger = logger;
+        this.localizationService = localizationService;
+        this.templatesDir = templatesDir;
+        this.customTemplatesDir = customTemplatesDir;
+    }
+    async execute(action, templateName) {
+        if (action === 'list') {
+            await this.listTemplates();
+        }
+        else if (action === 'update') {
+            if (!templateName) {
+                // Interactive selection if no name provided
+                const files = await this.getAllTemplateFiles();
+                const answer = await inquirer_1.default.prompt([
+                    {
+                        type: 'list', // or autocomplete if list is huge? list is safer for now.
+                        name: 'template',
+                        message: 'Select a template to update:',
+                        choices: files
+                    }
+                ]);
+                templateName = answer.template;
+            }
+            if (templateName) {
+                await this.updateTemplate(templateName);
+            }
+        }
+        else {
+            this.logger.error(`Unknown action: ${action}. Use 'list' or 'update'.`);
+        }
+    }
+    async listTemplates() {
+        this.logger.info('Available Templates:');
+        const files = await this.getAllTemplateFiles();
+        files.forEach(f => {
+            // Check if customized
+            const isCustom = fs.existsSync(path.join(this.customTemplatesDir, f));
+            const status = isCustom ? '[Customized]' : '[Default]   ';
+            console.log(`  ${status} ${f}`);
+        });
+    }
+    async updateTemplate(templateName) {
+        const defaultPath = path.join(this.templatesDir, templateName);
+        const customPath = path.join(this.customTemplatesDir, templateName);
+        // 1. Load content (Custom > Default)
+        let content = '';
+        if (await fs.pathExists(customPath)) {
+            content = await fs.readFile(customPath, 'utf8');
+        }
+        else if (await fs.pathExists(defaultPath)) {
+            content = await fs.readFile(defaultPath, 'utf8');
+        }
+        else {
+            this.logger.error(`Template not found: ${templateName}`);
+            return;
+        }
+        // 2. Open Editor
+        const answer = await inquirer_1.default.prompt([
+            {
+                type: 'editor',
+                name: 'content',
+                message: `Editing template: ${templateName}`,
+                default: content,
+            },
+        ]);
+        const newContent = answer.content;
+        // 3. Save to custom location
+        if (newContent && newContent.trim() !== '') {
+            await fs.ensureDir(path.dirname(customPath));
+            await fs.writeFile(customPath, newContent);
+            this.logger.success(`Template saved to: ${customPath}`);
+        }
+        else {
+            this.logger.warn('Empty content. Update cancelled.');
+        }
+    }
+    async getAllTemplateFiles(dir = this.templatesDir, baseDir = this.templatesDir) {
+        let results = [];
+        const list = await fs.readdir(dir);
+        for (const file of list) {
+            const filePath = path.join(dir, file);
+            const stat = await fs.stat(filePath);
+            if (stat && stat.isDirectory()) {
+                results = results.concat(await this.getAllTemplateFiles(filePath, baseDir));
+            }
+            else {
+                // relative path from templates dir
+                results.push(path.relative(baseDir, filePath).replace(/\\/g, '/'));
+            }
+        }
+        return results;
+    }
+}
+exports.TemplatesCommand = TemplatesCommand;

package/dist/src/core/ConfigService.js

@@ -0,0 +1,75 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const path = __importStar(require("path"));
+class ConfigService {
+    fileSystem;
+    logger;
+    configPath = '.agent/antigravity.json';
+    constructor(fileSystem, logger) {
+        this.fileSystem = fileSystem;
+        this.logger = logger;
+    }
+    async saveConfig(projectDetails) {
+        try {
+            const fullPath = path.join(projectDetails.rootPath, this.configPath);
+            // Ensure directory exists
+            const dir = path.dirname(fullPath);
+            await this.fileSystem.createDirectory(dir);
+            const content = JSON.stringify(projectDetails, null, 2);
+            await this.fileSystem.writeFile(fullPath, content);
+            this.logger.success(`Configuration saved to ${this.configPath}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to save configuration: ${error.message}`);
+        }
+    }
+    async loadConfig(rootPath) {
+        try {
+            const fullPath = path.join(rootPath, this.configPath);
+            if (await this.fileSystem.exists(fullPath)) {
+                const content = await this.fileSystem.readFile(fullPath);
+                return JSON.parse(content);
+            }
+            return null;
+        }
+        catch (error) {
+            this.logger.warn(`Could not load configuration from ${this.configPath}`);
+            return null;
+        }
+    }
+}
+exports.ConfigService = ConfigService;

package/dist/src/core/ContextGenerator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextGenerator = void 0;
+class ContextGenerator {
+    templateProvider;
+    localizationService;
+    constructor(templateProvider, localizationService) {
+        this.templateProvider = templateProvider;
+        this.localizationService = localizationService;
+    }
+    async generateContext(project) {
+        const lang = this.localizationService.getLanguage();
+        const templatePath = `${lang}/project-context.md.ejs`;
+        const formattedStack = `Frontend: ${project.techStack.frontend}, Backend: ${project.techStack.backend}`;
+        const templateContent = await this.templateProvider.getTemplate(templatePath);
+        return this.templateProvider.render(templateContent, {
+            projectDescription: project.projectDescription || 'N/A',
+            techStack: formattedStack,
+            architecture: project.architecture,
+            buildCommand: project.buildCommand,
+            testCommand: project.testCommand,
+            isMonorepo: project.isMonorepo || false,
+            apps: project.apps || [],
+        });
+    }
+}
+exports.ContextGenerator = ContextGenerator;

package/dist/src/core/DockerfileGenerator.js

@@ -0,0 +1,151 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerfileGenerator = void 0;
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+class DockerfileGenerator {
+    fileSystem;
+    templateProvider;
+    logger;
+    constructor(fileSystem, templateProvider, logger) {
+        this.fileSystem = fileSystem;
+        this.templateProvider = templateProvider;
+        this.logger = logger;
+    }
+    async generate(projectRoot, techStack) {
+        this.logger.info('Generating Dockerfile...');
+        let templateName = '';
+        const data = {
+            port: 3000,
+            packageManager: 'npm',
+            installCommand: 'npm install',
+            buildCommand: 'npm run build',
+            startCommand: 'npm run start:prod',
+        };
+        switch (techStack.packageManager) {
+            case types_1.PackageManager.YARN:
+                data.packageManager = 'yarn';
+                data.installCommand = 'yarn install --frozen-lockfile';
+                data.buildCommand = 'yarn build';
+                data.startCommand = 'yarn start:prod';
+                break;
+            case types_1.PackageManager.PNPM:
+                data.packageManager = 'pnpm';
+                data.installCommand = 'pnpm install --frozen-lockfile';
+                data.buildCommand = 'pnpm build';
+                data.startCommand = 'pnpm start:prod';
+                break;
+            case types_1.PackageManager.BUN:
+                data.packageManager = 'bun';
+                data.installCommand = 'bun install --frozen-lockfile';
+                data.buildCommand = 'bun run build';
+                data.startCommand = 'bun run start:prod';
+                break;
+        }
+        switch (techStack.backend) {
+            case types_1.BackendFramework.NESTJS:
+                templateName = 'docker/nestjs.Dockerfile.ejs';
+                break;
+            case types_1.BackendFramework.EXPRESS:
+                templateName = 'docker/node.Dockerfile.ejs';
+                break;
+            case types_1.BackendFramework.FASTAPI:
+                templateName = 'docker/python.Dockerfile.ejs';
+                data.port = 8000;
+                data.installCommand = 'pip install -r requirements.txt';
+                data.startCommand = 'uvicorn main:app --host 0.0.0.0 --port 8000';
+                if (techStack.packageManager === types_1.PackageManager.POETRY) {
+                    data.installCommand = 'poetry install --no-dev';
+                    data.startCommand = 'poetry run uvicorn main:app --host 0.0.0.0 --port 8000';
+                }
+                break;
+            case types_1.BackendFramework.DJANGO:
+                templateName = 'docker/django.Dockerfile.ejs';
+                data.port = 8000;
+                data.startCommand = 'python manage.py runserver 0.0.0.0:8000'; // Or gunicorn
+                break;
+            case types_1.BackendFramework.SPRING_BOOT:
+                templateName = 'docker/springboot.Dockerfile.ejs';
+                data.port = 8080;
+                break;
+            case types_1.BackendFramework.GO:
+            case types_1.BackendFramework.GIN:
+            case types_1.BackendFramework.RUST: // Using Go template for Rust??? No, stick to Go. Wait, RUST has no dockerfile?
+                // Ah, Rust was not in original switch. Let's add Go first.
+                if (techStack.backend === types_1.BackendFramework.RUST) {
+                    // TODO: Rust Dockerfile template
+                    this.logger.warn('Rust Dockerfile template not yet implemented.');
+                    return;
+                }
+                templateName = 'docker/go.Dockerfile.ejs';
+                data.port = 8080;
+                break;
+            default:
+                this.logger.warn(`No Dockerfile template found for backend: ${techStack.backend}`);
+                return;
+        }
+        try {
+            const templateContent = await this.templateProvider.getTemplate(templateName);
+            const dockerfileContent = this.templateProvider.render(templateContent, data);
+            const outputPath = path.join(projectRoot, 'Dockerfile');
+            if (await this.fileSystem.exists(outputPath)) {
+                this.logger.warn('Dockerfile already exists. Skipping generation.');
+            }
+            else {
+                await this.fileSystem.writeFile(outputPath, dockerfileContent);
+                this.logger.success('Dockerfile generated successfully.');
+                // Also generate .dockerignore
+                const dockerignorePath = path.join(projectRoot, '.dockerignore');
+                if (!await this.fileSystem.exists(dockerignorePath)) {
+                    try {
+                        const ignoreTemplate = await this.templateProvider.getTemplate('docker/dockerignore.ejs');
+                        // No data needed for now, but good to have
+                        const ignoreContent = this.templateProvider.render(ignoreTemplate, {});
+                        await this.fileSystem.writeFile(dockerignorePath, ignoreContent);
+                        this.logger.success('.dockerignore generated successfully.');
+                    }
+                    catch (e) {
+                        this.logger.warn('Failed to generate .dockerignore from template.');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to generate Dockerfile.');
+        }
+    }
+}
+exports.DockerfileGenerator = DockerfileGenerator;

package/dist/src/core/GitignoreGenerator.js

@@ -0,0 +1,129 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitignoreGenerator = void 0;
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+class GitignoreGenerator {
+    fileSystem;
+    logger;
+    constructor(fileSystem, logger) {
+        this.fileSystem = fileSystem;
+        this.logger = logger;
+    }
+    async generate(projectRoot, techStack) {
+        this.logger.info('Generating .gitignore...');
+        const fragments = new Set();
+        // OS & Editors (Always include)
+        fragments.add('macos');
+        fragments.add('windows');
+        fragments.add('linux');
+        fragments.add('vscode');
+        fragments.add('jetbrains');
+        // Frontend
+        if (techStack.frontend !== types_1.FrontendFramework.NONE) {
+            fragments.add('node');
+        }
+        // Backend
+        switch (techStack.backend) {
+            case types_1.BackendFramework.NESTJS:
+            case types_1.BackendFramework.EXPRESS:
+                fragments.add('node');
+                break;
+            case types_1.BackendFramework.FASTAPI:
+            case types_1.BackendFramework.DJANGO:
+            case types_1.BackendFramework.FLASK:
+                fragments.add('python');
+                break;
+            case types_1.BackendFramework.SPRING_BOOT:
+                fragments.add('java');
+                fragments.add('maven'); // Assuming Maven for now, possibly Gradle
+                break;
+            case types_1.BackendFramework.ASPNET_CORE:
+                fragments.add('dotnet');
+                break;
+            case types_1.BackendFramework.RUST:
+                fragments.add('rust');
+                break;
+            case types_1.BackendFramework.GO:
+            case types_1.BackendFramework.GIN:
+                fragments.add('go');
+                break;
+        }
+        if (techStack.smartContract === 'solidity' || techStack.smartContract === 'scrypto') {
+            // Scrypto has no specific gitignore template yet? Rust one covers it mostly.
+            if (techStack.smartContract === 'solidity') {
+                fragments.add('solidity');
+            }
+            // If scrypto, maybe just rust is enough
+        }
+        // Database (if local files)
+        // Most DBs don't commit data types, but sqlite does have .db files
+        const content = await this.composeContent(Array.from(fragments));
+        const outputPath = path.join(projectRoot, '.gitignore');
+        if (await this.fileSystem.exists(outputPath)) {
+            this.logger.warn('.gitignore already exists. Appending specific rules if missing.');
+            const existing = await this.fileSystem.readFile(outputPath);
+            // Simple append for now
+            await this.fileSystem.writeFile(outputPath, existing + '\n\n' + content);
+        }
+        else {
+            await this.fileSystem.writeFile(outputPath, content);
+        }
+        this.logger.success('.gitignore generated successfully.');
+    }
+    async composeContent(fragments) {
+        let finalContent = '# Generated by Antigravity Flow\n';
+        const templatesDir = path.join(__dirname, '../templates/gitignore');
+        for (const fragment of fragments) {
+            const fragmentPath = path.join(templatesDir, `${fragment}.txt`);
+            try {
+                if (await this.fileSystem.exists(fragmentPath)) {
+                    const content = await this.fileSystem.readFile(fragmentPath);
+                    finalContent += `\n### ${fragment.toUpperCase()} ###\n${content}\n`;
+                }
+                else {
+                    // Silently fail or warn? specific fragments might not exist yet
+                    // this.logger.warn(`Gitignore fragment not found: ${fragment}`);
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to load gitignore fragment: ${fragment}`);
+            }
+        }
+        return finalContent;
+    }
+}
+exports.GitignoreGenerator = GitignoreGenerator;

package/dist/src/core/PipelineGenerator.js

@@ -0,0 +1,68 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineGenerator = void 0;
+const path = __importStar(require("path"));
+const PipelineStrategy_1 = require("./pipelines/PipelineStrategy");
+class PipelineGenerator {
+    fileSystem;
+    templateProvider;
+    logger;
+    strategyFactory = new PipelineStrategy_1.PipelineStrategyFactory();
+    constructor(fileSystem, templateProvider, logger) {
+        this.fileSystem = fileSystem;
+        this.templateProvider = templateProvider;
+        this.logger = logger;
+    }
+    async generatePipeline(projectDetails) {
+        const strategy = this.strategyFactory.getStrategy(projectDetails);
+        const templateName = strategy.getTemplateName();
+        const templatePath = `en/pipelines/${templateName}`; // Hardcoded to EN for config files? Or use local? Config files usually don't need translation but let's stick to structure.
+        try {
+            const templateContent = await this.templateProvider.getTemplate(templatePath);
+            const rendered = this.templateProvider.render(templateContent, {
+                project: projectDetails
+            });
+            await this.fileSystem.createDirectory(projectDetails.workflowDirectory);
+            const outputPath = path.join(projectDetails.workflowDirectory, 'ci.yml');
+            await this.fileSystem.writeFile(outputPath, rendered);
+            this.logger.success(`CI/CD Pipeline generated: ${projectDetails.workflowDirectory}/ci.yml`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to generate pipeline: ${error.message}`);
+        }
+    }
+}
+exports.PipelineGenerator = PipelineGenerator;

package/dist/src/core/RulesComposer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RulesComposer = void 0;
+class RulesComposer {
+    templateProvider;
+    localizationService;
+    constructor(templateProvider, localizationService) {
+        this.templateProvider = templateProvider;
+        this.localizationService = localizationService;
+    }
+    async composeRules(stack, rigor) {
+        const lang = this.localizationService.getLanguage();
+        const fragments = [];
+        // Base Rules
+        const baseTemplatePath = `${lang}/fragments/base-rules.md.ejs`;
+        fragments.push(await this.templateProvider.getTemplate(baseTemplatePath));
+        // Rigor Mode Rules
+        const rigorTemplatePath = `${lang}/fragments/rigor/${rigor}.md.ejs`;
+        try {
+            fragments.push(await this.templateProvider.getTemplate(rigorTemplatePath));
+        }
+        catch (e) {
+            console.warn(`Missing rigor fragment: ${rigorTemplatePath}`);
+        }
+        // Frontend Rules
+        if (stack.frontend && stack.frontend !== 'none') {
+            const feTemplatePath = `${lang}/fragments/${stack.frontend}.md.ejs`;
+            try {
+                fragments.push(await this.templateProvider.getTemplate(feTemplatePath));
+            }
+            catch (e) {
+                // Ignore missing fragments for now or log warning
+                console.warn(`Missing rule fragment: ${feTemplatePath}`);
+            }
+        }
+        // Backend Rules
+        if (stack.backend && stack.backend !== 'none') {
+            const beTemplatePath = `${lang}/fragments/${stack.backend}.md.ejs`;
+            try {
+                fragments.push(await this.templateProvider.getTemplate(beTemplatePath));
+            }
+            catch (e) {
+                console.warn(`Missing rule fragment: ${beTemplatePath}`);
+            }
+        }
+        // Smart Contract Rules
+        if (stack.smartContract && stack.smartContract !== 'none') {
+            const scTemplatePath = `${lang}/fragments/${stack.smartContract}.md.ejs`;
+            try {
+                fragments.push(await this.templateProvider.getTemplate(scTemplatePath));
+            }
+            catch (e) {
+                console.warn(`Missing rule fragment: ${scTemplatePath}`);
+            }
+        }
+        // Render all fragments
+        // Note: We might want to pass data to fragments if needed
+        const renderedFragments = fragments.map(f => this.templateProvider.render(f, {}));
+        return renderedFragments.join('\n\n');
+    }
+}
+exports.RulesComposer = RulesComposer;