antigravity-flow 1.0.0

package/dist/src/core/StackDetector.js

@@ -0,0 +1,115 @@
+"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.StackDetector = void 0;
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+class StackDetector {
+    fileSystem;
+    logger;
+    constructor(fileSystem, logger) {
+        this.fileSystem = fileSystem;
+        this.logger = logger;
+    }
+    async detectStack(rootPath) {
+        const stack = {};
+        try {
+            // 1. Rust / Scrypto
+            const cargoPath = path.join(rootPath, 'Cargo.toml');
+            if (await this.fileSystem.exists(cargoPath)) {
+                const content = await this.fileSystem.readFile(cargoPath);
+                if (content.includes('scrypto')) {
+                    stack.smartContract = types_1.SmartContractFramework.SCRYPTO;
+                    // Scrypto usually implies backend or part of it, but technically it's smart contract.
+                    // Often no backend or a separate one.
+                }
+                else {
+                    stack.backend = types_1.BackendFramework.RUST; // Default to Rust backend if generic Cargo
+                }
+            }
+            // 2. Flutter
+            const pubspecPath = path.join(rootPath, 'pubspec.yaml');
+            if (await this.fileSystem.exists(pubspecPath)) {
+                stack.frontend = types_1.FrontendFramework.FLUTTER;
+            }
+            // 3. Python
+            const requirementsPath = path.join(rootPath, 'requirements.txt');
+            const pyprojectPath = path.join(rootPath, 'pyproject.toml');
+            if (await this.fileSystem.exists(requirementsPath) || await this.fileSystem.exists(pyprojectPath)) {
+                stack.backend = types_1.BackendFramework.PYTHON;
+            }
+            // 4. Node / JS Ecosystem
+            const packageJsonPath = path.join(rootPath, 'package.json');
+            if (await this.fileSystem.exists(packageJsonPath)) {
+                const content = await this.fileSystem.readFile(packageJsonPath);
+                const pkg = JSON.parse(content);
+                const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+                // Frontend detection
+                if (allDeps['react'] || allDeps['next']) {
+                    stack.frontend = types_1.FrontendFramework.REACT;
+                }
+                // Backend detection (if not already set by others)
+                if (!stack.backend) {
+                    if (allDeps['@nestjs/core']) {
+                        stack.backend = types_1.BackendFramework.NESTJS;
+                    }
+                    else {
+                        // Default to Node if generic package.json and no other backend specific found
+                        // But only if we suspect it's backend.
+                        // If just frontend deps, maybe it's just frontend.
+                        // We'll set NODE as a safe fallback if no explicit backend framework is found but package.json exists.
+                        stack.backend = types_1.BackendFramework.NODE;
+                    }
+                }
+            }
+            // 5. .NET
+            // We need to scan for .csproj or .sln
+            // Since IFileSystem doesn't support glob/scan easily here without specific implementation,
+            // we might skip deep scan or try a common pattern?
+            // For now, let's assume if we can't easily glob, we skip or assume user selects it.
+            // Or check specific file "Program.cs"?
+            // Let's assume user selection for .NET if not easily detectable via 'project.fsproj' etc.
+            // Actually, list_dir is not available to the class, only specific file exists checks.
+            // So let's skip .NET auto-detect for MVP unless we know a specific file. `*.sln` at root?
+            // I can't check wildcard. 
+            // I will skip .NET for now.
+        }
+        catch (error) {
+            this.logger.warn(`Failed to auto-detect stack: ${error.message}`);
+        }
+        return stack;
+    }
+}
+exports.StackDetector = StackDetector;

package/dist/src/core/WorkflowGenerator.js

@@ -0,0 +1,137 @@
+"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.WorkflowGenerator = void 0;
+const types_1 = require("./types");
+const path = __importStar(require("path"));
+class WorkflowGenerator {
+    fileSystem;
+    templateProvider;
+    logger;
+    localizationService;
+    rulesComposer;
+    contextGenerator;
+    constructor(fileSystem, templateProvider, logger, localizationService, rulesComposer, contextGenerator) {
+        this.fileSystem = fileSystem;
+        this.templateProvider = templateProvider;
+        this.logger = logger;
+        this.localizationService = localizationService;
+        this.rulesComposer = rulesComposer;
+        this.contextGenerator = contextGenerator;
+    }
+    /**
+     * Generates workflow files for the specified project.
+     */
+    async generateWorkflows(project, roles) {
+        this.logger.info(this.localizationService.translate('prompts.intro'));
+        // Ensure .agent/workflows directory exists for standard workflows
+        const workflowsDir = path.join(project.rootPath, project.workflowDirectory);
+        // Generate each selected role workflow
+        for (const role of roles) {
+            if (role === types_1.WorkflowRole.RULES) {
+                if (project.rulesDirectory) {
+                    const rulesDir = path.join(project.rootPath, project.rulesDirectory);
+                    await this.ensureDirectory(rulesDir);
+                    await this.generateWorkflowForRole(role, project, rulesDir);
+                }
+            }
+            else {
+                await this.ensureDirectory(workflowsDir);
+                await this.generateWorkflowForRole(role, project, workflowsDir);
+            }
+        }
+        this.logger.success(this.localizationService.translate('prompts.success'));
+    }
+    async ensureDirectory(dirPath) {
+        if (!(await this.fileSystem.exists(dirPath))) {
+            this.logger.info(`Creating directory: ${dirPath}`);
+            await this.fileSystem.createDirectory(dirPath);
+        }
+    }
+    async generateProjectContext(project) {
+        const contextContent = await this.contextGenerator.generateContext(project);
+        const contextPath = path.join(project.rootPath, '.agent/project-context.md');
+        // Ensure .agent exists (it should if workflows run, but safety first)
+        await this.ensureDirectory(path.dirname(contextPath));
+        await this.fileSystem.writeFile(contextPath, contextContent);
+        this.logger.success(`Created: ${contextPath}`);
+    }
+    async generateWorkflowForRole(role, project, outputDir) {
+        const fileName = types_1.WORKFLOW_FILES[role];
+        const outputPath = path.join(outputDir, fileName);
+        let content = '';
+        if (role === types_1.WorkflowRole.RULES) {
+            this.logger.info(`Generaring customized rules for stack: ${project.techStack.frontend}/${project.techStack.backend}...`);
+            const rulesContent = await this.rulesComposer.composeRules(project.techStack, project.rigor);
+            content = rulesContent; // Assign rulesContent to content
+        }
+        else {
+            const lang = this.localizationService.getLanguage();
+            const templatePath = path.join(lang, `${role}.md.ejs`);
+            this.logger.info(`Generating ${fileName} from template ${templatePath}...`);
+            try {
+                const templateContent = await this.templateProvider.getTemplate(templatePath);
+                // Load architecture fragment if needed (for architect/lead roles)
+                let folderStructure = '';
+                if (role === types_1.WorkflowRole.ARCHITECT || role === types_1.WorkflowRole.LEAD_DEV) {
+                    const archTemplatePath = `${lang}/fragments/arch/${project.architecture}.md.ejs`;
+                    try {
+                        folderStructure = await this.templateProvider.getTemplate(archTemplatePath);
+                    }
+                    catch (e) {
+                        this.logger.warn(`Missing architecture fragment: ${archTemplatePath}`);
+                    }
+                }
+                content = this.templateProvider.render(templateContent, {
+                    buildCommand: project.buildCommand,
+                    testCommand: project.testCommand,
+                    folderStructure: folderStructure,
+                });
+            }
+            catch (error) {
+                this.logger.error(`Failed to generate ${fileName}: ${error.message}`);
+                return;
+            }
+        }
+        try {
+            await this.fileSystem.writeFile(outputPath, content);
+            this.logger.success(`Created: ${outputPath}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to write ${fileName}: ${error.message}`);
+        }
+    }
+}
+exports.WorkflowGenerator = WorkflowGenerator;

package/dist/src/core/index.js

@@ -0,0 +1,26 @@
+"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("./interfaces"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./WorkflowGenerator"), exports);
+__exportStar(require("./RulesComposer"), exports);
+__exportStar(require("./ContextGenerator"), exports);
+__exportStar(require("./PipelineGenerator"), exports);
+__exportStar(require("./ConfigService"), exports);
+__exportStar(require("./StackDetector"), exports);
+__exportStar(require("./GitignoreGenerator"), exports);
+__exportStar(require("./DockerfileGenerator"), exports);

package/dist/src/core/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/pipelines/PipelineStrategy.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineStrategyFactory = exports.DefaultNodePipelineStrategy = exports.ReactPipelineStrategy = exports.FlutterPipelineStrategy = exports.NestJSPipelineStrategy = exports.DotNetPipelineStrategy = exports.PythonPipelineStrategy = exports.RustPipelineStrategy = exports.ScryptoPipelineStrategy = void 0;
+const types_1 = require("../types");
+class ScryptoPipelineStrategy {
+    canHandle(project) {
+        return project.techStack.smartContract === types_1.SmartContractFramework.SCRYPTO;
+    }
+    getTemplateName() {
+        return 'github-scrypto.yml.ejs';
+    }
+}
+exports.ScryptoPipelineStrategy = ScryptoPipelineStrategy;
+class RustPipelineStrategy {
+    canHandle(project) {
+        return project.techStack.backend === types_1.BackendFramework.RUST;
+    }
+    getTemplateName() {
+        return 'github-rust.yml.ejs';
+    }
+}
+exports.RustPipelineStrategy = RustPipelineStrategy;
+class PythonPipelineStrategy {
+    canHandle(project) {
+        return project.techStack.backend === types_1.BackendFramework.PYTHON;
+    }
+    getTemplateName() {
+        return 'github-python.yml.ejs';
+    }
+}
+exports.PythonPipelineStrategy = PythonPipelineStrategy;
+class DotNetPipelineStrategy {
+    canHandle(project) {
+        return project.techStack.backend === types_1.BackendFramework.ASPNET_CORE;
+    }
+    getTemplateName() {
+        return 'github-dotnet.yml.ejs';
+    }
+}
+exports.DotNetPipelineStrategy = DotNetPipelineStrategy;
+class NestJSPipelineStrategy {
+    canHandle(project) {
+        return project.techStack.backend === types_1.BackendFramework.NESTJS;
+    }
+    getTemplateName() {
+        return 'github-nestjs.yml.ejs';
+    }
+}
+exports.NestJSPipelineStrategy = NestJSPipelineStrategy;
+class FlutterPipelineStrategy {
+    canHandle(project) {
+        return project.techStack.frontend === types_1.FrontendFramework.FLUTTER;
+    }
+    getTemplateName() {
+        return 'github-flutter.yml.ejs';
+    }
+}
+exports.FlutterPipelineStrategy = FlutterPipelineStrategy;
+class ReactPipelineStrategy {
+    canHandle(project) {
+        return project.techStack.frontend !== types_1.FrontendFramework.NONE && project.techStack.frontend !== types_1.FrontendFramework.FLUTTER;
+    }
+    getTemplateName() {
+        return 'github-react.yml.ejs';
+    }
+}
+exports.ReactPipelineStrategy = ReactPipelineStrategy;
+class DefaultNodePipelineStrategy {
+    canHandle(project) {
+        return true; // Fallback
+    }
+    getTemplateName() {
+        return 'github-node.yml.ejs';
+    }
+}
+exports.DefaultNodePipelineStrategy = DefaultNodePipelineStrategy;
+class PipelineStrategyFactory {
+    strategies = [
+        new ScryptoPipelineStrategy(),
+        new RustPipelineStrategy(),
+        new PythonPipelineStrategy(),
+        new DotNetPipelineStrategy(),
+        new NestJSPipelineStrategy(),
+        new FlutterPipelineStrategy(),
+        new ReactPipelineStrategy(), // Checks if frontend != NONE
+        new DefaultNodePipelineStrategy()
+    ];
+    getStrategy(project) {
+        for (const strategy of this.strategies) {
+            if (strategy.canHandle(project)) {
+                return strategy;
+            }
+        }
+        return new DefaultNodePipelineStrategy();
+    }
+}
+exports.PipelineStrategyFactory = PipelineStrategyFactory;