antigravity-flow 1.0.0

package/dist/tests/core/Types.spec.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../src/core/types");
+describe('Types', () => {
+    describe('WorkflowRole', () => {
+        it('should have all original roles', () => {
+            expect(types_1.WorkflowRole.DEVELOPER).toBe('dev');
+            expect(types_1.WorkflowRole.QA).toBe('qa');
+            expect(types_1.WorkflowRole.LEAD_DEV).toBe('lead');
+            expect(types_1.WorkflowRole.ARCHITECT).toBe('architect');
+            expect(types_1.WorkflowRole.PRODUCT_OWNER).toBe('po');
+            expect(types_1.WorkflowRole.BUSINESS_ANALYST).toBe('ba');
+            expect(types_1.WorkflowRole.RULES).toBe('rules');
+        });
+        it('should have new roles', () => {
+            expect(types_1.WorkflowRole.DEVOPS).toBe('devops');
+            expect(types_1.WorkflowRole.SECURITY).toBe('security');
+            expect(types_1.WorkflowRole.TECH_WRITER).toBe('techwriter');
+            expect(types_1.WorkflowRole.DATA_ENGINEER).toBe('data');
+        });
+        it('should have 11 total roles', () => {
+            expect(Object.keys(types_1.WorkflowRole).length).toBe(11);
+        });
+    });
+    describe('WORKFLOW_FILES', () => {
+        it('should map all roles to files', () => {
+            expect(types_1.WORKFLOW_FILES[types_1.WorkflowRole.DEVELOPER]).toBe('dev.md');
+            expect(types_1.WORKFLOW_FILES[types_1.WorkflowRole.DEVOPS]).toBe('devops.md');
+            expect(types_1.WORKFLOW_FILES[types_1.WorkflowRole.SECURITY]).toBe('security.md');
+            expect(types_1.WORKFLOW_FILES[types_1.WorkflowRole.TECH_WRITER]).toBe('techwriter.md');
+            expect(types_1.WORKFLOW_FILES[types_1.WorkflowRole.DATA_ENGINEER]).toBe('data.md');
+        });
+    });
+    describe('FrontendFramework', () => {
+        it('should include new frameworks', () => {
+            expect(types_1.FrontendFramework.NEXTJS).toBe('nextjs');
+            expect(types_1.FrontendFramework.NUXTJS).toBe('nuxtjs');
+            expect(types_1.FrontendFramework.SVELTEKIT).toBe('sveltekit');
+            expect(types_1.FrontendFramework.REMIX).toBe('remix');
+            expect(types_1.FrontendFramework.ASTRO).toBe('astro');
+            expect(types_1.FrontendFramework.REACT_NATIVE).toBe('react-native');
+        });
+        it('should have correct count of frameworks', () => {
+            expect(Object.keys(types_1.FrontendFramework).length).toBe(12);
+        });
+    });
+    describe('BackendFramework', () => {
+        it('should include new frameworks', () => {
+            expect(types_1.BackendFramework.FASTAPI).toBe('fastapi');
+            expect(types_1.BackendFramework.DJANGO).toBe('django');
+            expect(types_1.BackendFramework.FLASK).toBe('flask');
+            expect(types_1.BackendFramework.SPRING_BOOT).toBe('spring-boot');
+            expect(types_1.BackendFramework.GO).toBe('go');
+            expect(types_1.BackendFramework.GIN).toBe('gin');
+            expect(types_1.BackendFramework.ELIXIR).toBe('elixir');
+            expect(types_1.BackendFramework.EXPRESS).toBe('express');
+            expect(types_1.BackendFramework.FASTIFY).toBe('fastify');
+        });
+        it('should have correct count of frameworks', () => {
+            expect(Object.keys(types_1.BackendFramework).length).toBe(15);
+        });
+    });
+    describe('SmartContractFramework', () => {
+        it('should include new frameworks', () => {
+            expect(types_1.SmartContractFramework.SOLIDITY).toBe('solidity');
+            expect(types_1.SmartContractFramework.MOVE).toBe('move');
+            expect(types_1.SmartContractFramework.ANCHOR).toBe('anchor');
+            expect(types_1.SmartContractFramework.INK).toBe('ink');
+        });
+    });
+    describe('MobileFramework', () => {
+        it('should include mobile frameworks', () => {
+            expect(types_1.MobileFramework.FLUTTER).toBe('flutter');
+            expect(types_1.MobileFramework.REACT_NATIVE).toBe('react-native');
+            expect(types_1.MobileFramework.SWIFT).toBe('swift');
+            expect(types_1.MobileFramework.KOTLIN).toBe('kotlin');
+            expect(types_1.MobileFramework.NONE).toBe('none');
+        });
+    });
+    describe('ArchitectureType', () => {
+        it('should include new architectures', () => {
+            expect(types_1.ArchitectureType.CLEAN).toBe('clean');
+            expect(types_1.ArchitectureType.VERTICAL_SLICE).toBe('vertical-slice');
+            expect(types_1.ArchitectureType.LAYERED).toBe('layered');
+            expect(types_1.ArchitectureType.MICROSERVICES).toBe('microservices');
+            expect(types_1.ArchitectureType.NONE).toBe('none');
+        });
+    });
+    describe('RigorMode', () => {
+        it('should include standard mode', () => {
+            expect(types_1.RigorMode.STANDARD).toBe('standard');
+        });
+        it('should have all 4 modes', () => {
+            expect(Object.keys(types_1.RigorMode).length).toBe(4);
+        });
+    });
+    describe('VersionControlPlatform', () => {
+        it('should include all platforms', () => {
+            expect(types_1.VersionControlPlatform.GITHUB).toBe('github');
+            expect(types_1.VersionControlPlatform.GITLAB).toBe('gitlab');
+            expect(types_1.VersionControlPlatform.AZURE_DEVOPS).toBe('azure-devops');
+            expect(types_1.VersionControlPlatform.BITBUCKET).toBe('bitbucket');
+            expect(types_1.VersionControlPlatform.NONE).toBe('none');
+        });
+    });
+    describe('BranchingStrategy', () => {
+        it('should include all strategies', () => {
+            expect(types_1.BranchingStrategy.GITFLOW).toBe('gitflow');
+            expect(types_1.BranchingStrategy.GITHUB_FLOW).toBe('github-flow');
+            expect(types_1.BranchingStrategy.TRUNK_BASED).toBe('trunk-based');
+            expect(types_1.BranchingStrategy.GITLAB_FLOW).toBe('gitlab-flow');
+            expect(types_1.BranchingStrategy.CUSTOM).toBe('custom');
+        });
+    });
+    describe('CommitConvention', () => {
+        it('should include all conventions', () => {
+            expect(types_1.CommitConvention.CONVENTIONAL).toBe('conventional');
+            expect(types_1.CommitConvention.GITMOJI).toBe('gitmoji');
+            expect(types_1.CommitConvention.ANGULAR).toBe('angular');
+            expect(types_1.CommitConvention.SEMANTIC).toBe('semantic');
+        });
+    });
+    describe('PackageManager', () => {
+        it('should include all package managers', () => {
+            expect(types_1.PackageManager.NPM).toBe('npm');
+            expect(types_1.PackageManager.YARN).toBe('yarn');
+            expect(types_1.PackageManager.PNPM).toBe('pnpm');
+            expect(types_1.PackageManager.BUN).toBe('bun');
+            expect(types_1.PackageManager.PIP).toBe('pip');
+            expect(types_1.PackageManager.POETRY).toBe('poetry');
+            expect(types_1.PackageManager.UV).toBe('uv');
+            expect(types_1.PackageManager.CARGO).toBe('cargo');
+            expect(types_1.PackageManager.NUGET).toBe('nuget');
+            expect(types_1.PackageManager.MAVEN).toBe('maven');
+            expect(types_1.PackageManager.GRADLE).toBe('gradle');
+            expect(types_1.PackageManager.GO_MODULES).toBe('go-modules');
+        });
+    });
+    describe('DatabaseType', () => {
+        it('should include SQL Server and Oracle', () => {
+            expect(types_1.DatabaseType.SQLSERVER).toBe('sqlserver');
+            expect(types_1.DatabaseType.ORACLE).toBe('oracle');
+        });
+        it('should include all database types', () => {
+            expect(types_1.DatabaseType.POSTGRESQL).toBe('postgresql');
+            expect(types_1.DatabaseType.MYSQL).toBe('mysql');
+            expect(types_1.DatabaseType.MONGODB).toBe('mongodb');
+            expect(types_1.DatabaseType.SUPABASE).toBe('supabase');
+            expect(types_1.DatabaseType.FIREBASE).toBe('firebase');
+            expect(types_1.DatabaseType.DYNAMODB).toBe('dynamodb');
+            expect(types_1.DatabaseType.REDIS).toBe('redis');
+            expect(types_1.DatabaseType.NEON).toBe('neon');
+            expect(types_1.DatabaseType.PLANETSCALE).toBe('planetscale');
+        });
+    });
+    describe('OrmType', () => {
+        it('should include all ORMs', () => {
+            expect(types_1.OrmType.PRISMA).toBe('prisma');
+            expect(types_1.OrmType.TYPEORM).toBe('typeorm');
+            expect(types_1.OrmType.MIKROORM).toBe('mikroorm');
+            expect(types_1.OrmType.DRIZZLE).toBe('drizzle');
+            expect(types_1.OrmType.MONGOOSE).toBe('mongoose');
+            expect(types_1.OrmType.SQLALCHEMY).toBe('sqlalchemy');
+            expect(types_1.OrmType.DJANGO_ORM).toBe('django-orm');
+            expect(types_1.OrmType.ENTITY_FRAMEWORK).toBe('entity-framework');
+            expect(types_1.OrmType.GORM).toBe('gorm');
+            expect(types_1.OrmType.DIESEL).toBe('diesel');
+            expect(types_1.OrmType.ECTO).toBe('ecto');
+        });
+    });
+    describe('TestingFramework', () => {
+        it('should include all testing frameworks', () => {
+            expect(types_1.TestingFramework.JEST).toBe('jest');
+            expect(types_1.TestingFramework.VITEST).toBe('vitest');
+            expect(types_1.TestingFramework.PLAYWRIGHT).toBe('playwright');
+            expect(types_1.TestingFramework.CYPRESS).toBe('cypress');
+            expect(types_1.TestingFramework.PYTEST).toBe('pytest');
+            expect(types_1.TestingFramework.JUNIT).toBe('junit');
+            expect(types_1.TestingFramework.GO_TEST).toBe('go-test');
+            expect(types_1.TestingFramework.RUST_TEST).toBe('rust-test');
+            expect(types_1.TestingFramework.EXUNIT).toBe('exunit');
+        });
+    });
+    describe('CoverageTarget', () => {
+        it('should have all coverage levels', () => {
+            expect(types_1.CoverageTarget.FULL).toBe('100');
+            expect(types_1.CoverageTarget.HIGH).toBe('80');
+            expect(types_1.CoverageTarget.STANDARD).toBe('60');
+            expect(types_1.CoverageTarget.MINIMAL).toBe('40');
+            expect(types_1.CoverageTarget.NONE).toBe('none');
+        });
+    });
+    describe('DeploymentPlatform', () => {
+        it('should include all platforms', () => {
+            expect(types_1.DeploymentPlatform.VERCEL).toBe('vercel');
+            expect(types_1.DeploymentPlatform.NETLIFY).toBe('netlify');
+            expect(types_1.DeploymentPlatform.AWS).toBe('aws');
+            expect(types_1.DeploymentPlatform.AZURE).toBe('azure');
+            expect(types_1.DeploymentPlatform.GCP).toBe('gcp');
+            expect(types_1.DeploymentPlatform.RAILWAY).toBe('railway');
+            expect(types_1.DeploymentPlatform.RENDER).toBe('render');
+            expect(types_1.DeploymentPlatform.FLY_IO).toBe('fly-io');
+            expect(types_1.DeploymentPlatform.KUBERNETES).toBe('kubernetes');
+        });
+    });
+    describe('Containerization', () => {
+        it('should include all options', () => {
+            expect(types_1.Containerization.DOCKER).toBe('docker');
+            expect(types_1.Containerization.DOCKER_COMPOSE).toBe('docker-compose');
+            expect(types_1.Containerization.KUBERNETES).toBe('kubernetes');
+            expect(types_1.Containerization.PODMAN).toBe('podman');
+        });
+    });
+    describe('SecurityScanningTool', () => {
+        it('should include all tools', () => {
+            expect(types_1.SecurityScanningTool.SNYK).toBe('snyk');
+            expect(types_1.SecurityScanningTool.DEPENDABOT).toBe('dependabot');
+            expect(types_1.SecurityScanningTool.RENOVATE).toBe('renovate');
+            expect(types_1.SecurityScanningTool.TRIVY).toBe('trivy');
+            expect(types_1.SecurityScanningTool.SONARQUBE).toBe('sonarqube');
+            expect(types_1.SecurityScanningTool.CODEQL).toBe('codeql');
+        });
+    });
+    describe('MonorepoTool', () => {
+        it('should include all tools', () => {
+            expect(types_1.MonorepoTool.TURBOREPO).toBe('turborepo');
+            expect(types_1.MonorepoTool.NX).toBe('nx');
+            expect(types_1.MonorepoTool.LERNA).toBe('lerna');
+            expect(types_1.MonorepoTool.RUSH).toBe('rush');
+            expect(types_1.MonorepoTool.PNPM_WORKSPACES).toBe('pnpm-workspaces');
+            expect(types_1.MonorepoTool.YARN_WORKSPACES).toBe('yarn-workspaces');
+        });
+    });
+    describe('IdeIntegration', () => {
+        it('should include all IDEs', () => {
+            expect(types_1.IdeIntegration.CURSOR).toBe('cursor');
+            expect(types_1.IdeIntegration.WINDSURF).toBe('windsurf');
+            expect(types_1.IdeIntegration.GEMINI).toBe('gemini');
+            expect(types_1.IdeIntegration.COPILOT).toBe('copilot');
+            expect(types_1.IdeIntegration.CODY).toBe('cody');
+        });
+    });
+});

package/dist/tests/core/WorkflowGenerator.spec.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WorkflowGenerator_1 = require("../../src/core/WorkflowGenerator");
+const types_1 = require("../../src/core/types");
+describe('WorkflowGenerator', () => {
+    let workflowGenerator;
+    let mockFileSystem;
+    let mockTemplateProvider;
+    let mockLogger;
+    let mockLocalizationService;
+    let mockRulesComposer;
+    let mockContextGenerator;
+    const mockProject = {
+        rootPath: '/test/root',
+        workflowDirectory: '.github/workflows',
+        rulesDirectory: '.agent/rules',
+        techStack: { frontend: types_1.FrontendFramework.REACT, backend: types_1.BackendFramework.NESTJS },
+        architecture: types_1.ArchitectureType.HEXAGONAL,
+        rigor: types_1.RigorMode.STRICT,
+        projectDescription: 'A test project',
+        buildCommand: 'npm run build',
+        testCommand: 'npm test'
+    };
+    beforeEach(() => {
+        mockFileSystem = {
+            exists: jest.fn(),
+            readFile: jest.fn(),
+            writeFile: jest.fn(),
+            createDirectory: jest.fn(),
+        };
+        mockTemplateProvider = {
+            getTemplate: jest.fn(),
+            render: jest.fn(),
+        };
+        mockLogger = {
+            info: jest.fn(),
+            success: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+        };
+        mockLocalizationService = {
+            setLanguage: jest.fn(),
+            getLanguage: jest.fn().mockReturnValue('en'),
+            translate: jest.fn(),
+        };
+        mockRulesComposer = {
+            composeRules: jest.fn(),
+        };
+        mockContextGenerator = {
+            generateContext: jest.fn(),
+        };
+        workflowGenerator = new WorkflowGenerator_1.WorkflowGenerator(mockFileSystem, mockTemplateProvider, mockLogger, mockLocalizationService, mockRulesComposer, mockContextGenerator);
+    });
+    it('should inject folder structure fragment for Architect role', async () => {
+        const roles = [types_1.WorkflowRole.ARCHITECT];
+        const folderStructureContent = 'Hexagonal Structure Content';
+        const templateContent = 'Architect Template Content <%- folderStructure %>';
+        const renderedContent = 'Final Content';
+        mockTemplateProvider.getTemplate.mockImplementation(async (path) => {
+            if (path.includes('fragments/arch/hexagonal.md.ejs')) {
+                return folderStructureContent;
+            }
+            if (path.includes('architect.md.ejs')) {
+                return templateContent;
+            }
+            return '';
+        });
+        mockTemplateProvider.render.mockReturnValue(renderedContent);
+        mockFileSystem.createDirectory.mockResolvedValue(undefined);
+        mockFileSystem.writeFile.mockResolvedValue(undefined);
+        await workflowGenerator.generateWorkflows(mockProject, roles);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith('en/fragments/arch/hexagonal.md.ejs');
+        expect(mockTemplateProvider.render).toHaveBeenCalledWith(templateContent, expect.objectContaining({
+            folderStructure: folderStructureContent
+        }));
+        expect(mockFileSystem.writeFile).toHaveBeenCalled();
+    });
+    it('should NOT inject folder structure for Developer role', async () => {
+        const roles = [types_1.WorkflowRole.DEVELOPER];
+        const templateContent = 'Dev Template Content';
+        mockTemplateProvider.getTemplate.mockResolvedValue(templateContent);
+        mockTemplateProvider.render.mockReturnValue('Final Content');
+        await workflowGenerator.generateWorkflows(mockProject, roles);
+        expect(mockTemplateProvider.getTemplate).not.toHaveBeenCalledWith(expect.stringContaining('fragments/arch/'));
+    });
+    it('should log error if template generation fails', async () => {
+        mockTemplateProvider.getTemplate.mockRejectedValue(new Error('Template Error'));
+        await workflowGenerator.generateWorkflows(mockProject, [types_1.WorkflowRole.DEVELOPER]);
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to generate'));
+    });
+    it('should log error if file writing fails', async () => {
+        mockTemplateProvider.getTemplate.mockResolvedValue('content');
+        mockTemplateProvider.render.mockReturnValue('content');
+        mockFileSystem.exists.mockResolvedValue(false);
+        mockFileSystem.writeFile.mockRejectedValue(new Error('Write Error'));
+        await workflowGenerator.generateWorkflows(mockProject, [types_1.WorkflowRole.DEVELOPER]);
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to write'));
+    });
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "antigravity-flow",
+  "version": "1.0.0",
+  "description": "Universal AI Context Generator & Workflow CLI for Cursor, Windsurf, and Antigravity.",
+  "main": "dist/src/core/index.js",
+  "bin": {
+    "ag-flow": "./dist/bin/ag-flow.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node scripts/clean.js && tsc && node scripts/copy-assets.js",
+    "start": "node dist/bin/ag-flow.js",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write 'src/**/*.ts'",
+    "prepublishOnly": "npm run test && npm run build"
+  },
+  "keywords": [
+    "cli",
+    "agent",
+    "workflow",
+    "ai",
+    "automation",
+    "rigor",
+    "antigravity"
+  ],
+  "author": "Coulibaly Yetinin Olivier",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^14.0.2",
+    "ejs": "^3.1.10",
+    "fs-extra": "^11.3.3",
+    "inquirer": "^8.2.7"
+  },
+  "devDependencies": {
+    "@types/ejs": "^3.1.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.52.0",
+    "@typescript-eslint/parser": "^8.52.0",
+    "eslint": "^9.39.2",
+    "jest": "^30.2.0",
+    "prettier": "^3.7.4",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}