@friggframework/devtools 2.0.0-next.3 → 2.0.0-next.31

package/frigg-cli/test/npm-registry.test.js

@@ -0,0 +1,319 @@
+const axios = require('axios');
+
+// Mock dependencies
+jest.mock('axios');
+jest.mock('node-cache');
+
+describe('NPMRegistryService', () => {
+    let npmRegistry;
+    let mockCache;
+    let NodeCache;
+    
+    beforeEach(() => {
+        jest.clearAllMocks();
+        
+        // Mock cache methods
+        mockCache = {
+            get: jest.fn(),
+            set: jest.fn(),
+            del: jest.fn()
+        };
+        
+        // Re-require NodeCache and set up mock
+        NodeCache = require('node-cache');
+        NodeCache.mockImplementation(() => mockCache);
+        
+        // Create new instance for each test
+        jest.isolateModules(() => {
+            npmRegistry = require('../utils/npm-registry');
+            // Access the cache directly to ensure our mock is used
+            npmRegistry.cache = mockCache;
+        });
+    });
+
+    describe('searchApiModules', () => {
+        const mockApiResponse = {
+            data: {
+                objects: [
+                    {
+                        package: {
+                            name: '@friggframework/api-module-slack',
+                            version: '2.0.0',
+                            description: 'Slack integration for Frigg',
+                            keywords: ['frigg', 'slack', 'integration'],
+                            author: { name: 'Frigg Team' },
+                            date: '2024-01-01'
+                        }
+                    },
+                    {
+                        package: {
+                            name: '@friggframework/api-module-hubspot',
+                            version: '2.1.0',
+                            description: 'HubSpot CRM integration',
+                            keywords: ['frigg', 'hubspot', 'crm'],
+                            author: { name: 'Frigg Team' },
+                            date: '2024-01-02'
+                        }
+                    },
+                    {
+                        package: {
+                            name: '@friggframework/not-api-module',
+                            version: '1.0.0',
+                            description: 'Should be filtered out'
+                        }
+                    }
+                ]
+            }
+        };
+
+        it('should fetch and format API modules from npm registry', async () => {
+            mockCache.get.mockReturnValue(null);
+            axios.get.mockResolvedValue(mockApiResponse);
+
+            const result = await npmRegistry.searchApiModules();
+
+            expect(axios.get).toHaveBeenCalledWith(
+                'https://registry.npmjs.org/-/v1/search',
+                expect.objectContaining({
+                    params: expect.objectContaining({
+                        text: '@friggframework/api-module-',
+                        size: 250
+                    }),
+                    timeout: 10000
+                })
+            );
+
+            expect(result).toHaveLength(2);
+            expect(result[0]).toMatchObject({
+                name: '@friggframework/api-module-slack',
+                version: '2.0.0',
+                integrationName: 'Slack',
+                category: 'Communication'
+            });
+            expect(result[1]).toMatchObject({
+                name: '@friggframework/api-module-hubspot',
+                integrationName: 'Hubspot',
+                category: 'CRM'
+            });
+        });
+
+        it('should use cached results when available', async () => {
+            const cachedData = [{ name: 'cached-module' }];
+            mockCache.get.mockReturnValue(cachedData);
+
+            const result = await npmRegistry.searchApiModules();
+
+            expect(axios.get).not.toHaveBeenCalled();
+            expect(result).toEqual(cachedData);
+        });
+
+        it('should force refresh when requested', async () => {
+            const cachedData = [{ name: 'cached-module' }];
+            mockCache.get.mockReturnValue(cachedData);
+            axios.get.mockResolvedValue(mockApiResponse);
+
+            const result = await npmRegistry.searchApiModules({ forceRefresh: true });
+
+            expect(axios.get).toHaveBeenCalled();
+            expect(result).toHaveLength(2);
+        });
+
+        it('should filter out prerelease versions by default', async () => {
+            const responseWithPrerelease = {
+                data: {
+                    objects: [
+                        {
+                            package: {
+                                name: '@friggframework/api-module-test',
+                                version: '2.0.0-beta.1',
+                                description: 'Prerelease version'
+                            }
+                        },
+                        {
+                            package: {
+                                name: '@friggframework/api-module-stable',
+                                version: '1.0.0',
+                                description: 'Stable version'
+                            }
+                        }
+                    ]
+                }
+            };
+
+            mockCache.get.mockReturnValue(null);
+            axios.get.mockResolvedValue(responseWithPrerelease);
+
+            const result = await npmRegistry.searchApiModules();
+
+            expect(result).toHaveLength(1);
+            expect(result[0].name).toBe('@friggframework/api-module-stable');
+        });
+
+        it('should include prerelease versions when requested', async () => {
+            const responseWithPrerelease = {
+                data: {
+                    objects: [
+                        {
+                            package: {
+                                name: '@friggframework/api-module-test',
+                                version: '2.0.0-beta.1'
+                            }
+                        }
+                    ]
+                }
+            };
+
+            mockCache.get.mockReturnValue(null);
+            axios.get.mockResolvedValue(responseWithPrerelease);
+
+            const result = await npmRegistry.searchApiModules({ includePrerelease: true });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].version).toBe('2.0.0-beta.1');
+        });
+
+        it('should handle network errors gracefully', async () => {
+            mockCache.get.mockReturnValue(null);
+            axios.get.mockRejectedValue(new Error('Network error'));
+
+            const result = await npmRegistry.searchApiModules();
+
+            expect(result).toEqual([]);
+        });
+
+        it('should cache results after successful fetch', async () => {
+            mockCache.get.mockReturnValue(null);
+            axios.get.mockResolvedValue(mockApiResponse);
+
+            await npmRegistry.searchApiModules();
+
+            expect(mockCache.set).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.arrayContaining([
+                    expect.objectContaining({ name: '@friggframework/api-module-slack' })
+                ])
+            );
+        });
+    });
+
+    describe('categorizeModule', () => {
+        it('should categorize modules based on keywords and name', async () => {
+            const testCases = [
+                { name: '@friggframework/api-module-salesforce', keywords: ['crm'], expected: 'CRM' },
+                { name: '@friggframework/api-module-slack', keywords: ['chat'], expected: 'Communication' },
+                { name: '@friggframework/api-module-stripe', keywords: ['payment'], expected: 'E-commerce' },
+                { name: '@friggframework/api-module-google-analytics', keywords: [], expected: 'Analytics' },
+                { name: '@friggframework/api-module-mailchimp', keywords: ['email', 'marketing'], expected: 'Marketing' },
+                { name: '@friggframework/api-module-facebook', keywords: [], expected: 'Social Media' },
+                { name: '@friggframework/api-module-jira', keywords: ['project'], expected: 'Project Management' },
+                { name: '@friggframework/api-module-dropbox', keywords: ['storage'], expected: 'Storage' },
+                { name: '@friggframework/api-module-airtable', keywords: [], expected: 'Productivity' },
+                { name: '@friggframework/api-module-github', keywords: ['git'], expected: 'Development' },
+                { name: '@friggframework/api-module-zendesk', keywords: ['support'], expected: 'Support' },
+                { name: '@friggframework/api-module-quickbooks', keywords: ['accounting'], expected: 'Finance' },
+                { name: '@friggframework/api-module-unknown', keywords: [], expected: 'Other' }
+            ];
+
+            mockCache.get.mockReturnValue(null);
+            axios.get.mockResolvedValue({
+                data: {
+                    objects: testCases.map(tc => ({
+                        package: {
+                            name: tc.name,
+                            version: '1.0.0',
+                            keywords: tc.keywords
+                        }
+                    }))
+                }
+            });
+
+            const results = await npmRegistry.searchApiModules();
+
+            testCases.forEach((testCase, index) => {
+                expect(results[index].category).toBe(testCase.expected);
+            });
+        });
+    });
+
+    describe('getModulesByType', () => {
+        it('should group modules by category', async () => {
+            mockCache.get.mockReturnValue(null);
+            axios.get.mockResolvedValue({
+                data: {
+                    objects: [
+                        {
+                            package: {
+                                name: '@friggframework/api-module-slack',
+                                version: '1.0.0',
+                                keywords: ['chat', 'communication']
+                            }
+                        },
+                        {
+                            package: {
+                                name: '@friggframework/api-module-discord',
+                                version: '1.0.0',
+                                keywords: ['chat', 'communication']
+                            }
+                        },
+                        {
+                            package: {
+                                name: '@friggframework/api-module-salesforce',
+                                version: '1.0.0',
+                                keywords: ['crm']
+                            }
+                        }
+                    ]
+                }
+            });
+
+            const grouped = await npmRegistry.getModulesByType();
+
+            expect(grouped).toMatchObject({
+                'Communication': expect.arrayContaining([
+                    expect.objectContaining({ name: '@friggframework/api-module-slack' }),
+                    expect.objectContaining({ name: '@friggframework/api-module-discord' })
+                ]),
+                'CRM': expect.arrayContaining([
+                    expect.objectContaining({ name: '@friggframework/api-module-salesforce' })
+                ])
+            });
+
+            expect(grouped['Communication']).toHaveLength(2);
+            expect(grouped['CRM']).toHaveLength(1);
+        });
+
+        it('should handle empty results', async () => {
+            mockCache.get.mockReturnValue(null);
+            axios.get.mockResolvedValue({ data: { objects: [] } });
+
+            const grouped = await npmRegistry.getModulesByType();
+
+            expect(grouped).toEqual({});
+        });
+    });
+
+    describe('extractIntegrationName', () => {
+        it('should extract and format integration names correctly', async () => {
+            const testCases = [
+                { input: '@friggframework/api-module-slack', expected: 'Slack' },
+                { input: '@friggframework/api-module-google-sheets', expected: 'Google Sheets' },
+                { input: '@friggframework/api-module-hubspot-crm', expected: 'Hubspot Crm' }
+            ];
+
+            mockCache.get.mockReturnValue(null);
+            axios.get.mockResolvedValue({
+                data: {
+                    objects: testCases.map(tc => ({
+                        package: { name: tc.input, version: '1.0.0' }
+                    }))
+                }
+            });
+
+            const results = await npmRegistry.searchApiModules();
+
+            testCases.forEach((testCase, index) => {
+                expect(results[index].integrationName).toBe(testCase.expected);
+            });
+        });
+    });
+});

package/frigg-cli/ui-command/index.js

@@ -0,0 +1,154 @@
+const open = require('open');
+const chalk = require('chalk');
+const path = require('path');
+const ProcessManager = require('../utils/process-manager');
+const { 
+    getCurrentRepositoryInfo, 
+    discoverFriggRepositories, 
+    promptRepositorySelection,
+    formatRepositoryInfo 
+} = require('../utils/repo-detection');
+
+async function uiCommand(options) {
+    const { port = 3001, open: shouldOpen = true, repo: specifiedRepo, dev = false } = options;
+    
+    let targetRepo = null;
+    let workingDirectory = process.cwd();
+
+    // If a specific repo path is provided, use it
+    if (specifiedRepo) {
+        const repoPath = path.resolve(specifiedRepo);
+        console.log(chalk.blue(`Using specified repository: ${repoPath}`));
+        workingDirectory = repoPath;
+        targetRepo = { path: repoPath, name: path.basename(repoPath) };
+    } else {
+        // Check if we're already in a Frigg repository
+        console.log(chalk.blue('Detecting Frigg repository...'));
+        const currentRepo = await getCurrentRepositoryInfo();
+        
+        if (currentRepo) {
+            console.log(chalk.green(`✓ Found Frigg repository: ${formatRepositoryInfo(currentRepo)}`));
+            if (currentRepo.currentSubPath) {
+                console.log(chalk.gray(`  Currently in subdirectory: ${currentRepo.currentSubPath}`));
+            }
+            targetRepo = currentRepo;
+            workingDirectory = currentRepo.path;
+        } else {
+            // Discover Frigg repositories
+            console.log(chalk.yellow('Current directory is not a Frigg repository.'));
+            console.log(chalk.blue('Searching for Frigg repositories...'));
+            
+            const discoveredRepos = await discoverFriggRepositories();
+            
+            if (discoveredRepos.length === 0) {
+                console.log(chalk.red('No Frigg repositories found. Please create one first.'));
+                process.exit(1);
+            }
+            
+            // For UI command, we'll let the UI handle repository selection
+            // Set a placeholder and pass the discovered repos via environment
+            targetRepo = { 
+                name: 'Multiple Repositories Available', 
+                path: process.cwd(),
+                isMultiRepo: true,
+                availableRepos: discoveredRepos
+            };
+            workingDirectory = process.cwd();
+            
+            console.log(chalk.blue(`Found ${discoveredRepos.length} Frigg repositories. You'll be able to select one in the UI.`));
+        }
+    }
+
+    console.log(chalk.blue('🚀 Starting Frigg Management UI...'));
+    
+    const processManager = new ProcessManager();
+    
+    try {
+        const managementUiPath = path.join(__dirname, '../../management-ui');
+        
+        // Check if we're in development mode
+        // For CLI usage, we prefer development mode unless explicitly set to production
+        const fs = require('fs');
+        const isDevelopment = dev || process.env.NODE_ENV !== 'production';
+        
+        if (isDevelopment) {
+            const env = {
+                ...process.env,
+                VITE_API_URL: `http://localhost:${port}`,
+                PORT: port,
+                PROJECT_ROOT: workingDirectory,
+                REPOSITORY_INFO: JSON.stringify(targetRepo),
+                AVAILABLE_REPOSITORIES: targetRepo.isMultiRepo ? JSON.stringify(targetRepo.availableRepos) : null
+            };
+            
+            // Start backend server
+            processManager.spawnProcess(
+                'backend',
+                'npm',
+                ['run', 'server'],
+                { cwd: managementUiPath, env }
+            );
+            
+            // Start frontend dev server
+            processManager.spawnProcess(
+                'frontend',
+                'npm',
+                ['run', 'dev'],
+                { cwd: managementUiPath, env }
+            );
+            
+            // Wait for servers to start
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            // Display clean status
+            processManager.printStatus(
+                'http://localhost:5173',
+                `http://localhost:${port}`,
+                targetRepo.name
+            );
+            
+            // Open browser if requested
+            if (shouldOpen) {
+                setTimeout(() => {
+                    open('http://localhost:5173');
+                }, 1000);
+            }
+            
+        } else {
+            // Production mode - just start the backend server
+            const { FriggManagementServer } = await import('../../management-ui/server/index.js');
+            
+            const server = new FriggManagementServer({ 
+                port, 
+                projectRoot: workingDirectory,
+                repositoryInfo: targetRepo,
+                availableRepositories: targetRepo.isMultiRepo ? targetRepo.availableRepos : null
+            });
+            await server.start();
+            
+            processManager.printStatus(
+                `http://localhost:${port}`,
+                `http://localhost:${port}/api`,
+                targetRepo.name
+            );
+            
+            if (shouldOpen) {
+                setTimeout(() => {
+                    open(`http://localhost:${port}`);
+                }, 1000);
+            }
+        }
+        
+        // Keep the process running
+        process.stdin.resume();
+        
+    } catch (error) {
+        console.error(chalk.red('Failed to start Management UI:'), error.message);
+        if (error.code === 'EADDRINUSE') {
+            console.log(chalk.yellow(`Port ${port} is already in use. Try using a different port with --port <number>`));
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = { uiCommand };