antigravity-flow 1.0.0

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

@@ -0,0 +1,97 @@
+"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 });
+const ConfigService_1 = require("../../src/core/ConfigService");
+const types_1 = require("../../src/core/types");
+const path = __importStar(require("path"));
+describe('ConfigService', () => {
+    let configService;
+    let mockFileSystem;
+    let mockLogger;
+    const projectDetails = {
+        rootPath: '/test/root',
+        workflowDirectory: '.github/workflows',
+        rulesDirectory: '.agent/rules',
+        techStack: { frontend: types_1.FrontendFramework.NONE, backend: types_1.BackendFramework.NODE, smartContract: types_1.SmartContractFramework.NONE },
+        architecture: types_1.ArchitectureType.MVC,
+        rigor: types_1.RigorMode.STRICT,
+        buildCommand: 'npm run build',
+        testCommand: 'npm run test',
+    };
+    beforeEach(() => {
+        mockFileSystem = {
+            exists: jest.fn(),
+            readFile: jest.fn(),
+            writeFile: jest.fn(),
+            createDirectory: jest.fn(),
+        };
+        mockLogger = {
+            info: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            success: jest.fn(),
+        };
+        configService = new ConfigService_1.ConfigService(mockFileSystem, mockLogger);
+    });
+    it('should save configuration successfully', async () => {
+        await configService.saveConfig(projectDetails);
+        const expectedPath = path.join(projectDetails.rootPath, '.agent/antigravity.json');
+        expect(mockFileSystem.createDirectory).toHaveBeenCalledWith(path.dirname(expectedPath));
+        expect(mockFileSystem.writeFile).toHaveBeenCalledWith(expectedPath, JSON.stringify(projectDetails, null, 2));
+        expect(mockLogger.success).toHaveBeenCalledWith(expect.stringContaining('Configuration saved'));
+    });
+    it('should load configuration if exists', async () => {
+        const expectedPath = path.join(process.cwd(), '.agent/antigravity.json');
+        mockFileSystem.exists.mockResolvedValue(true);
+        mockFileSystem.readFile.mockResolvedValue(JSON.stringify(projectDetails));
+        // Note: loadConfig currently uses process.cwd() as internal variable logic might differ.
+        // Let's check implementation behavior regarding rootPath argument.
+        // My implementation: async loadConfig(rootPath: string)
+        await configService.loadConfig('/test/loader');
+        const expectedCallPath = path.join('/test/loader', '.agent/antigravity.json');
+        expect(mockFileSystem.exists).toHaveBeenCalledWith(expectedCallPath);
+        expect(mockFileSystem.readFile).toHaveBeenCalledWith(expectedCallPath);
+    });
+    it('should return null if configuration does not exist', async () => {
+        mockFileSystem.exists.mockResolvedValue(false);
+        const result = await configService.loadConfig('/test/missing');
+        expect(result).toBeNull();
+    });
+    it('should handle errors during save', async () => {
+        mockFileSystem.writeFile.mockRejectedValue(new Error('Write Error'));
+        await configService.saveConfig(projectDetails);
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to save configuration'));
+    });
+});

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ContextGenerator_1 = require("../../src/core/ContextGenerator");
+const types_1 = require("../../src/core/types");
+describe('ContextGenerator', () => {
+    let contextGenerator;
+    let mockTemplateProvider;
+    let mockLocalizationService;
+    beforeEach(() => {
+        mockTemplateProvider = {
+            getTemplate: jest.fn(),
+            render: jest.fn(),
+        };
+        mockLocalizationService = {
+            setLanguage: jest.fn(),
+            getLanguage: jest.fn().mockReturnValue('en'),
+            translate: jest.fn(),
+        };
+        contextGenerator = new ContextGenerator_1.ContextGenerator(mockTemplateProvider, mockLocalizationService);
+    });
+    it('should generate project context using the template', async () => {
+        const project = {
+            rootPath: '/test/root',
+            workflowDirectory: '.agent/workflows',
+            buildCommand: 'npm run build',
+            testCommand: 'npm test',
+            techStack: { frontend: types_1.FrontendFramework.REACT, backend: types_1.BackendFramework.NESTJS },
+            architecture: types_1.ArchitectureType.HEXAGONAL,
+            rigor: types_1.RigorMode.STRICT,
+            projectDescription: 'Test Project',
+            isMonorepo: true,
+            apps: ['app1', 'app2'],
+        };
+        const templateContent = 'Context Template';
+        const renderedContent = 'Rendered Context';
+        mockTemplateProvider.getTemplate.mockResolvedValue(templateContent);
+        mockTemplateProvider.render.mockReturnValue(renderedContent);
+        const result = await contextGenerator.generateContext(project);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith('en/project-context.md.ejs');
+        expect(mockTemplateProvider.render).toHaveBeenCalledWith(templateContent, {
+            projectDescription: 'Test Project',
+            techStack: 'Frontend: react, Backend: nestjs',
+            architecture: 'hexagonal',
+            buildCommand: 'npm run build',
+            testCommand: 'npm test',
+            isMonorepo: true,
+            apps: ['app1', 'app2'],
+        });
+        expect(result).toBe(renderedContent);
+    });
+});

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

@@ -0,0 +1,206 @@
+"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 });
+const PipelineGenerator_1 = require("../../src/core/PipelineGenerator");
+const types_1 = require("../../src/core/types");
+const path = __importStar(require("path"));
+describe('PipelineGenerator', () => {
+    let pipelineGenerator;
+    let mockFileSystem;
+    let mockTemplateProvider;
+    let mockLogger;
+    beforeEach(() => {
+        mockFileSystem = {
+            createDirectory: jest.fn(),
+            exists: jest.fn(),
+            readFile: jest.fn(),
+            writeFile: jest.fn(),
+        };
+        mockTemplateProvider = {
+            getTemplate: jest.fn(),
+            render: jest.fn(),
+        };
+        mockLogger = {
+            info: jest.fn(),
+            warn: jest.fn(),
+            success: jest.fn(),
+            error: jest.fn(),
+        };
+        pipelineGenerator = new PipelineGenerator_1.PipelineGenerator(mockFileSystem, mockTemplateProvider, mockLogger);
+    });
+    it('should generate a React pipeline workflow', async () => {
+        const projectDetails = {
+            rootPath: '/test/root',
+            workflowDirectory: '.github/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: { frontend: types_1.FrontendFramework.REACT, backend: types_1.BackendFramework.NONE },
+            architecture: types_1.ArchitectureType.MVC,
+            rigor: types_1.RigorMode.STRICT,
+            buildCommand: 'npm run build',
+            testCommand: 'npm run test',
+        };
+        const templateContent = 'React Workflow Content';
+        mockTemplateProvider.getTemplate.mockResolvedValue(templateContent);
+        mockTemplateProvider.render.mockReturnValue(templateContent);
+        await pipelineGenerator.generatePipeline(projectDetails);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('github-react.yml.ejs'));
+        expect(mockFileSystem.createDirectory).toHaveBeenCalledWith(projectDetails.workflowDirectory);
+        expect(mockFileSystem.writeFile).toHaveBeenCalledWith(path.join(projectDetails.workflowDirectory, 'ci.yml'), templateContent);
+        expect(mockLogger.success).toHaveBeenCalledWith('CI/CD Pipeline generated: .github/workflows/ci.yml');
+    });
+    it('should generate a Flutter pipeline workflow', async () => {
+        const projectDetails = {
+            rootPath: '/test/root',
+            workflowDirectory: '.github/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: { frontend: types_1.FrontendFramework.FLUTTER, backend: types_1.BackendFramework.NONE },
+            architecture: types_1.ArchitectureType.MVC,
+            rigor: types_1.RigorMode.PROTOTYPE,
+            buildCommand: 'flutter build apk',
+            testCommand: 'flutter test',
+        };
+        const templateContent = 'Flutter Workflow Content';
+        mockTemplateProvider.getTemplate.mockResolvedValue(templateContent);
+        mockTemplateProvider.render.mockReturnValue(templateContent);
+        await pipelineGenerator.generatePipeline(projectDetails);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('github-flutter.yml.ejs'));
+    });
+    it('should generate a Scrypto pipeline workflow', async () => {
+        const projectDetails = {
+            rootPath: '/test/root',
+            workflowDirectory: '.github/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: { frontend: types_1.FrontendFramework.NONE, backend: types_1.BackendFramework.NONE, smartContract: types_1.SmartContractFramework.SCRYPTO },
+            architecture: types_1.ArchitectureType.MVC,
+            rigor: types_1.RigorMode.STRICT,
+            buildCommand: 'cargo build',
+            testCommand: 'cargo test',
+        };
+        mockTemplateProvider.getTemplate.mockResolvedValue('Scrypto Content');
+        await pipelineGenerator.generatePipeline(projectDetails);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('github-scrypto.yml.ejs'));
+    });
+    it('should generate a NestJS pipeline workflow', async () => {
+        const projectDetails = {
+            rootPath: '/test/root',
+            workflowDirectory: '.github/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: { frontend: types_1.FrontendFramework.NONE, backend: types_1.BackendFramework.NESTJS },
+            architecture: types_1.ArchitectureType.HEXAGONAL,
+            rigor: types_1.RigorMode.STRICT,
+            buildCommand: 'npm run build',
+            testCommand: 'npm test',
+        };
+        const templateContent = 'NestJS Content';
+        mockTemplateProvider.getTemplate.mockResolvedValue(templateContent);
+        await pipelineGenerator.generatePipeline(projectDetails);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('github-nestjs.yml.ejs'));
+    });
+    it('should generate a .NET pipeline workflow', async () => {
+        const projectDetails = {
+            rootPath: '/test/root',
+            workflowDirectory: '.github/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: { frontend: types_1.FrontendFramework.NONE, backend: types_1.BackendFramework.ASPNET_CORE },
+            architecture: types_1.ArchitectureType.MVC,
+            rigor: types_1.RigorMode.STRICT,
+            buildCommand: 'dotnet build',
+            testCommand: 'dotnet test',
+        };
+        mockTemplateProvider.getTemplate.mockResolvedValue('content');
+        await pipelineGenerator.generatePipeline(projectDetails);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('github-dotnet.yml.ejs'));
+    });
+    it('should generate a Python pipeline workflow', async () => {
+        const projectDetails = {
+            rootPath: '/test/root',
+            workflowDirectory: '.github/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: { frontend: types_1.FrontendFramework.NONE, backend: types_1.BackendFramework.PYTHON },
+            architecture: types_1.ArchitectureType.MVC,
+            rigor: types_1.RigorMode.STRICT,
+            buildCommand: 'python build',
+            testCommand: 'python test',
+        };
+        mockTemplateProvider.getTemplate.mockResolvedValue('content');
+        await pipelineGenerator.generatePipeline(projectDetails);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('github-python.yml.ejs'));
+    });
+    it('should generate a Rust pipeline workflow', async () => {
+        const projectDetails = {
+            rootPath: '/test/root',
+            workflowDirectory: '.github/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: { frontend: types_1.FrontendFramework.NONE, backend: types_1.BackendFramework.RUST },
+            architecture: types_1.ArchitectureType.MVC,
+            rigor: types_1.RigorMode.STRICT,
+            buildCommand: 'cargo build',
+            testCommand: 'cargo test',
+        };
+        mockTemplateProvider.getTemplate.mockResolvedValue('Rust Content');
+        await pipelineGenerator.generatePipeline(projectDetails);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('github-rust.yml.ejs'));
+    });
+    it('should generate a default Node pipeline workflow', async () => {
+        const projectDetails = {
+            rootPath: '/test/root',
+            workflowDirectory: '.github/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: { frontend: types_1.FrontendFramework.NONE, backend: types_1.BackendFramework.NODE },
+            architecture: types_1.ArchitectureType.MVC,
+            rigor: types_1.RigorMode.STRICT,
+            buildCommand: 'npm run build',
+            testCommand: 'npm test',
+        };
+        mockTemplateProvider.getTemplate.mockResolvedValue('Node Content');
+        await pipelineGenerator.generatePipeline(projectDetails);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('github-node.yml.ejs'));
+    });
+    it('should log error if generation fails', async () => {
+        const projectDetails = {
+            rootPath: '/test/root',
+            workflowDirectory: '.github/workflows',
+            rulesDirectory: '.agent/rules',
+            techStack: { frontend: types_1.FrontendFramework.REACT, backend: types_1.BackendFramework.NONE },
+            architecture: types_1.ArchitectureType.MVC,
+            rigor: types_1.RigorMode.STRICT,
+            buildCommand: 'npm run build',
+            testCommand: 'npm run test',
+        };
+        mockTemplateProvider.getTemplate.mockRejectedValue(new Error('Template Fail'));
+        await pipelineGenerator.generatePipeline(projectDetails);
+        expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to generate pipeline'));
+    });
+});

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RulesComposer_1 = require("../../src/core/RulesComposer");
+const types_1 = require("../../src/core/types");
+describe('RulesComposer', () => {
+    let rulesComposer;
+    let mockTemplateProvider;
+    let mockLocalizationService;
+    beforeEach(() => {
+        mockTemplateProvider = {
+            getTemplate: jest.fn(),
+            render: jest.fn(),
+        };
+        mockLocalizationService = {
+            setLanguage: jest.fn(),
+            getLanguage: jest.fn().mockReturnValue('en'),
+            translate: jest.fn(),
+        };
+        rulesComposer = new RulesComposer_1.RulesComposer(mockTemplateProvider, mockLocalizationService);
+    });
+    it('should compose rules with base, rigor and framework specific fragments', async () => {
+        const stack = {
+            frontend: types_1.FrontendFramework.REACT,
+            backend: types_1.BackendFramework.NESTJS,
+        };
+        const rigor = types_1.RigorMode.STRICT;
+        const baseTemplate = 'Base Rules\n';
+        const rigorTemplate = 'Strict Rules\n';
+        const reactTemplate = 'React Rules\n';
+        const nestTemplate = 'NestJS Rules\n';
+        mockTemplateProvider.getTemplate.mockImplementation(async (path) => {
+            if (path.includes('base-rules.md.ejs'))
+                return baseTemplate;
+            if (path.includes('strict.md.ejs'))
+                return rigorTemplate;
+            if (path.includes('react.md.ejs'))
+                return reactTemplate;
+            if (path.includes('nestjs.md.ejs'))
+                return nestTemplate;
+            return '';
+        });
+        // Mock render to just return the content as is for this test
+        mockTemplateProvider.render.mockImplementation((content) => content);
+        const result = await rulesComposer.composeRules(stack, rigor);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('base-rules'));
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('strict'));
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('react'));
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('nestjs'));
+        expect(result).toContain('Base Rules');
+        expect(result).toContain('Strict Rules');
+        expect(result).toContain('React Rules');
+        expect(result).toContain('NestJS Rules');
+    });
+    it('should not include framework rules if framework is NONE', async () => {
+        const stack = {
+            frontend: types_1.FrontendFramework.NONE,
+            backend: types_1.BackendFramework.NONE,
+        };
+        const rigor = types_1.RigorMode.PROTOTYPE;
+        mockTemplateProvider.getTemplate.mockResolvedValue('Rule Content');
+        mockTemplateProvider.render.mockImplementation((c) => c);
+        await rulesComposer.composeRules(stack, rigor);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('base-rules'));
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('prototype'));
+        expect(mockTemplateProvider.getTemplate).not.toHaveBeenCalledWith(expect.stringContaining('react'));
+        expect(mockTemplateProvider.getTemplate).not.toHaveBeenCalledWith(expect.stringContaining('node'));
+    });
+    it('should include smart contract rules if present', async () => {
+        const stack = {
+            frontend: types_1.FrontendFramework.NONE,
+            backend: types_1.BackendFramework.NONE,
+            smartContract: types_1.SmartContractFramework.SCRYPTO,
+        };
+        const rigor = types_1.RigorMode.STRICT;
+        mockTemplateProvider.getTemplate.mockImplementation(async (path) => {
+            if (path.includes('base-rules.md.ejs'))
+                return 'Base';
+            if (path.includes('strict.md.ejs'))
+                return 'Strict';
+            if (path.includes('scrypto.md.ejs'))
+                return 'Scrypto Rules';
+            return '';
+        });
+        mockTemplateProvider.render.mockImplementation((c) => c);
+        const result = await rulesComposer.composeRules(stack, rigor);
+        expect(mockTemplateProvider.getTemplate).toHaveBeenCalledWith(expect.stringContaining('scrypto.md.ejs'));
+        expect(result).toContain('Scrypto Rules');
+    });
+});

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const StackDetector_1 = require("../../src/core/StackDetector");
+const types_1 = require("../../src/core/types");
+describe('StackDetector', () => {
+    let stackDetector;
+    let mockFileSystem;
+    let mockLogger;
+    beforeEach(() => {
+        mockFileSystem = {
+            exists: jest.fn(),
+            readFile: jest.fn(),
+            writeFile: jest.fn(),
+            createDirectory: jest.fn(),
+        };
+        mockLogger = {
+            info: jest.fn(),
+            warn: jest.fn(),
+            success: jest.fn(),
+            error: jest.fn(),
+        };
+        stackDetector = new StackDetector_1.StackDetector(mockFileSystem, mockLogger);
+    });
+    it('should detect Rust backend', async () => {
+        mockFileSystem.exists.mockImplementation(async (p) => p.endsWith('Cargo.toml'));
+        mockFileSystem.readFile.mockResolvedValue('name = "test"');
+        const result = await stackDetector.detectStack('/root');
+        expect(result.backend).toBe(types_1.BackendFramework.RUST);
+    });
+    it('should detect Scrypto smart contract', async () => {
+        mockFileSystem.exists.mockImplementation(async (p) => p.endsWith('Cargo.toml'));
+        mockFileSystem.readFile.mockResolvedValue('[dependencies]\nscrypto = "1.0"');
+        const result = await stackDetector.detectStack('/root');
+        expect(result.smartContract).toBe(types_1.SmartContractFramework.SCRYPTO);
+    });
+    it('should detect Flutter frontend', async () => {
+        mockFileSystem.exists.mockImplementation(async (p) => p.endsWith('pubspec.yaml'));
+        const result = await stackDetector.detectStack('/root');
+        expect(result.frontend).toBe(types_1.FrontendFramework.FLUTTER);
+    });
+    it('should detect Python backend', async () => {
+        mockFileSystem.exists.mockImplementation(async (p) => p.endsWith('requirements.txt'));
+        const result = await stackDetector.detectStack('/root');
+        expect(result.backend).toBe(types_1.BackendFramework.PYTHON);
+    });
+    it('should detect React frontend (package.json)', async () => {
+        mockFileSystem.exists.mockImplementation(async (p) => p.endsWith('package.json'));
+        mockFileSystem.readFile.mockResolvedValue(JSON.stringify({
+            dependencies: { react: '^18.0.0' }
+        }));
+        const result = await stackDetector.detectStack('/root');
+        expect(result.frontend).toBe(types_1.FrontendFramework.REACT);
+        expect(result.backend).toBe(types_1.BackendFramework.NODE); // Default fallback
+    });
+    it('should detect NestJS backend (package.json)', async () => {
+        mockFileSystem.exists.mockImplementation(async (p) => p.endsWith('package.json'));
+        mockFileSystem.readFile.mockResolvedValue(JSON.stringify({
+            dependencies: { '@nestjs/core': '^8.0.0' }
+        }));
+        const result = await stackDetector.detectStack('/root');
+        expect(result.backend).toBe(types_1.BackendFramework.NESTJS);
+    });
+    it('should handle errors gracefully', async () => {
+        mockFileSystem.exists.mockRejectedValue(new Error('FS Error'));
+        const result = await stackDetector.detectStack('/root');
+        expect(result).toEqual({});
+        expect(mockLogger.warn).toHaveBeenCalled();
+    });
+});