@friggframework/devtools 2.0.0-next.29 → 2.0.0-next.30

package/frigg-cli/utils/app-resolver.js

@@ -0,0 +1,319 @@
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+class AppResolver {
+    constructor() {
+        this.cache = new Map();
+    }
+
+    async resolveAppPath(options = {}) {
+        const cacheKey = JSON.stringify(options);
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+
+        let resolvedPath;
+
+        // Priority 1: Explicit flags (--app-path, --config, --app)
+        if (options.appPath || options.config || options.app) {
+            const explicitPath = options.appPath || options.config || options.app;
+            resolvedPath = await this.validateAndResolvePath(explicitPath);
+            if (resolvedPath) {
+                this.cache.set(cacheKey, resolvedPath);
+                return resolvedPath;
+            }
+            throw new Error(`Invalid app path specified: ${explicitPath}`);
+        }
+
+        // Priority 2: Environment variable
+        if (process.env.FRIGG_APP_PATH) {
+            resolvedPath = await this.validateAndResolvePath(process.env.FRIGG_APP_PATH);
+            if (resolvedPath) {
+                this.cache.set(cacheKey, resolvedPath);
+                return resolvedPath;
+            }
+            console.warn(`Warning: FRIGG_APP_PATH environment variable points to invalid path: ${process.env.FRIGG_APP_PATH}`);
+        }
+
+        // Priority 3: Current directory auto-detection (backward compatibility)
+        resolvedPath = await this.autoDetectFriggApp();
+        if (resolvedPath) {
+            this.cache.set(cacheKey, resolvedPath);
+            return resolvedPath;
+        }
+
+        // Priority 4: Search common development directories
+        resolvedPath = await this.searchCommonDirectories();
+        if (resolvedPath) {
+            this.cache.set(cacheKey, resolvedPath);
+            return resolvedPath;
+        }
+
+        throw new Error('No Frigg application found. Use --app-path to specify the application directory.');
+    }
+
+    async validateAndResolvePath(inputPath) {
+        if (!inputPath) return null;
+
+        // Handle different path formats
+        let resolvedPath;
+        if (inputPath.startsWith('~/')) {
+            resolvedPath = path.join(os.homedir(), inputPath.slice(2));
+        } else if (path.isAbsolute(inputPath)) {
+            resolvedPath = inputPath;
+        } else {
+            resolvedPath = path.resolve(process.cwd(), inputPath);
+        }
+
+        try {
+            const stats = await fs.stat(resolvedPath);
+            if (!stats.isDirectory()) {
+                // If it's a file, check if it's a config file and use its directory
+                if (await this.isConfigFile(resolvedPath)) {
+                    resolvedPath = path.dirname(resolvedPath);
+                } else {
+                    return null;
+                }
+            }
+
+            // Validate that this is a Frigg application
+            if (await this.isFriggApplication(resolvedPath)) {
+                return resolvedPath;
+            }
+        } catch (error) {
+            // Path doesn't exist or is not accessible
+            return null;
+        }
+
+        return null;
+    }
+
+    async isConfigFile(filePath) {
+        const basename = path.basename(filePath);
+        const configFiles = [
+            'frigg.config.js',
+            'frigg.config.json',
+            '.friggrc',
+            '.friggrc.js',
+            '.friggrc.json',
+            'package.json'
+        ];
+        
+        return configFiles.includes(basename);
+    }
+
+    async isFriggApplication(dirPath) {
+        try {
+            // Check for package.json with Frigg dependencies
+            const packageJsonPath = path.join(dirPath, 'package.json');
+            try {
+                const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
+                const packageJson = JSON.parse(packageJsonContent);
+                
+                // Check for @friggframework dependencies
+                const deps = {
+                    ...packageJson.dependencies,
+                    ...packageJson.devDependencies,
+                    ...packageJson.peerDependencies
+                };
+                
+                if (Object.keys(deps).some(dep => dep.startsWith('@friggframework/'))) {
+                    return true;
+                }
+
+                // Check for frigg scripts
+                if (packageJson.scripts) {
+                    const scriptNames = Object.keys(packageJson.scripts);
+                    if (scriptNames.some(script => script.includes('frigg'))) {
+                        return true;
+                    }
+                }
+            } catch (error) {
+                // package.json doesn't exist or is invalid, continue checking other indicators
+            }
+
+            // Check for Frigg configuration files
+            const configFiles = [
+                'frigg.config.js',
+                'frigg.config.json',
+                '.friggrc',
+                '.friggrc.js',
+                '.friggrc.json'
+            ];
+
+            for (const configFile of configFiles) {
+                try {
+                    await fs.access(path.join(dirPath, configFile));
+                    return true;
+                } catch (error) {
+                    // File doesn't exist, continue
+                }
+            }
+
+            // Check for Frigg-specific directories
+            const friggDirectories = [
+                '.frigg',
+                'frigg-modules',
+                'api-modules'
+            ];
+
+            for (const friggDir of friggDirectories) {
+                try {
+                    const dirStat = await fs.stat(path.join(dirPath, friggDir));
+                    if (dirStat.isDirectory()) {
+                        return true;
+                    }
+                } catch (error) {
+                    // Directory doesn't exist, continue
+                }
+            }
+
+            // Check for serverless.yml with Frigg references
+            try {
+                const serverlessPath = path.join(dirPath, 'serverless.yml');
+                const serverlessContent = await fs.readFile(serverlessPath, 'utf8');
+                if (serverlessContent.includes('frigg') || serverlessContent.includes('Frigg')) {
+                    return true;
+                }
+            } catch (error) {
+                // serverless.yml doesn't exist or can't be read
+            }
+
+            // Check for infrastructure.js (common in Frigg apps)
+            try {
+                await fs.access(path.join(dirPath, 'infrastructure.js'));
+                return true;
+            } catch (error) {
+                // infrastructure.js doesn't exist
+            }
+
+            return false;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async autoDetectFriggApp() {
+        // Start from current directory and search up to 3 levels
+        let currentDir = process.cwd();
+        
+        for (let i = 0; i < 3; i++) {
+            if (await this.isFriggApplication(currentDir)) {
+                return currentDir;
+            }
+            
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                // Reached filesystem root
+                break;
+            }
+            currentDir = parentDir;
+        }
+
+        return null;
+    }
+
+    async searchCommonDirectories() {
+        const commonDirs = [
+            path.join(os.homedir(), 'Documents'),
+            path.join(os.homedir(), 'Projects'),
+            path.join(os.homedir(), 'Development'),
+            path.join(os.homedir(), 'dev'),
+            path.join(os.homedir(), 'workspace')
+        ];
+
+        for (const baseDir of commonDirs) {
+            try {
+                const friggApp = await this.searchDirectoryRecursively(baseDir, 3);
+                if (friggApp) {
+                    return friggApp;
+                }
+            } catch (error) {
+                // Directory doesn't exist or can't be accessed, continue
+            }
+        }
+
+        return null;
+    }
+
+    async searchDirectoryRecursively(dirPath, maxDepth) {
+        if (maxDepth <= 0) return null;
+
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            
+            // First check if current directory is a Frigg app
+            if (await this.isFriggApplication(dirPath)) {
+                return dirPath;
+            }
+
+            // Then search subdirectories
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+                
+                // Skip common directories that shouldn't contain Frigg apps
+                const skipDirs = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage'];
+                if (skipDirs.includes(entry.name)) continue;
+
+                const subDirPath = path.join(dirPath, entry.name);
+                const result = await this.searchDirectoryRecursively(subDirPath, maxDepth - 1);
+                if (result) {
+                    return result;
+                }
+            }
+        } catch (error) {
+            // Directory can't be read, skip
+        }
+
+        return null;
+    }
+
+    async loadAppConfig(appPath) {
+        const configPaths = [
+            path.join(appPath, 'frigg.config.js'),
+            path.join(appPath, 'frigg.config.json'),
+            path.join(appPath, '.friggrc.js'),
+            path.join(appPath, '.friggrc.json'),
+            path.join(appPath, '.friggrc')
+        ];
+
+        for (const configPath of configPaths) {
+            try {
+                const stats = await fs.stat(configPath);
+                if (stats.isFile()) {
+                    if (configPath.endsWith('.js')) {
+                        delete require.cache[require.resolve(configPath)];
+                        return require(configPath);
+                    } else {
+                        const content = await fs.readFile(configPath, 'utf8');
+                        return JSON.parse(content);
+                    }
+                }
+            } catch (error) {
+                // Config file doesn't exist or can't be read, continue
+            }
+        }
+
+        // Fallback to package.json frigg configuration
+        try {
+            const packageJsonPath = path.join(appPath, 'package.json');
+            const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
+            const packageJson = JSON.parse(packageJsonContent);
+            
+            if (packageJson.frigg) {
+                return packageJson.frigg;
+            }
+        } catch (error) {
+            // package.json doesn't exist or doesn't have frigg config
+        }
+
+        return {};
+    }
+
+    clearCache() {
+        this.cache.clear();
+    }
+}
+
+module.exports = { AppResolver };

package/frigg-cli/utils/backend-path.js

@@ -0,0 +1,25 @@
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Finds the nearest backend package.json by traversing up the directory tree
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} - Path to the backend directory or null if not found
+ */
+function findNearestBackendPackageJson(startDir = process.cwd()) {
+    let currentDir = startDir;
+    
+    while (currentDir !== path.dirname(currentDir)) {
+        const backendPath = path.join(currentDir, 'backend', 'package.json');
+        if (fs.existsSync(backendPath)) {
+            return path.dirname(backendPath);
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    
+    return null;
+}
+
+module.exports = {
+    findNearestBackendPackageJson
+};

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

@@ -0,0 +1,167 @@
+/**
+ * NPM Registry Service for CLI
+ * CommonJS version of the npm-registry service
+ */
+
+'use strict';
+
+const axios = require('axios');
+const NodeCache = require('node-cache');
+const semver = require('semver');
+
+class NPMRegistryService {
+    constructor() {
+        // Cache with 1 hour TTL by default
+        this.cache = new NodeCache({ 
+            stdTTL: 3600,
+            checkperiod: 600,
+            useClones: false
+        });
+        
+        this.npmRegistryUrl = 'https://registry.npmjs.org';
+        this.searchUrl = `${this.npmRegistryUrl}/-/v1/search`;
+        this.packageScope = '@friggframework';
+        this.modulePrefix = 'api-module-';
+    }
+
+    /**
+     * Search for all @friggframework/api-module-* packages
+     * @param {Object} options - Search options
+     * @param {boolean} options.includePrerelease - Include prerelease versions
+     * @param {boolean} options.forceRefresh - Force cache refresh
+     * @returns {Promise<Array>} Array of package information
+     */
+    async searchApiModules(options = {}) {
+        const cacheKey = `api-modules-${JSON.stringify(options)}`;
+        
+        // Check cache first unless force refresh is requested
+        if (!options.forceRefresh) {
+            const cached = this.cache.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+
+        try {
+            // Search for packages matching our pattern
+            const searchQuery = `${this.packageScope}/${this.modulePrefix}`;
+            const response = await axios.get(this.searchUrl, {
+                params: {
+                    text: searchQuery,
+                    size: 250, // Get up to 250 results
+                    quality: 0.65,
+                    popularity: 0.98,
+                    maintenance: 0.5
+                },
+                timeout: 10000
+            });
+
+            const packages = response.data.objects
+                .filter(obj => obj.package.name.startsWith(`${this.packageScope}/${this.modulePrefix}`))
+                .map(obj => this.formatPackageInfo(obj.package));
+
+            // Filter out prereleases if requested
+            const filtered = options.includePrerelease 
+                ? packages 
+                : packages.filter(pkg => !semver.prerelease(pkg.version));
+
+            // Cache the results
+            this.cache.set(cacheKey, filtered);
+            
+            return filtered;
+        } catch (error) {
+            console.error('Error searching NPM registry:', error.message);
+            // Return empty array on error to allow offline usage
+            return [];
+        }
+    }
+
+    /**
+     * Extract integration name from package name
+     * @private
+     */
+    extractIntegrationName(packageName) {
+        return packageName
+            .replace(`${this.packageScope}/${this.modulePrefix}`, '')
+            .replace(/-/g, ' ')
+            .replace(/\b\w/g, l => l.toUpperCase());
+    }
+
+    /**
+     * Format package information for API response
+     * @private
+     */
+    formatPackageInfo(pkg) {
+        return {
+            name: pkg.name,
+            version: pkg.version,
+            description: pkg.description,
+            keywords: pkg.keywords || [],
+            author: pkg.author,
+            publisher: pkg.publisher,
+            date: pkg.date,
+            links: pkg.links,
+            integrationName: this.extractIntegrationName(pkg.name),
+            category: this.categorizeModule(pkg)
+        };
+    }
+
+    /**
+     * Categorize module based on keywords and name
+     * @private
+     */
+    categorizeModule(module) {
+        const name = module.name?.toLowerCase() || '';
+        const keywords = module.keywords?.map(k => k.toLowerCase()) || [];
+        const allTerms = [...keywords, name];
+
+        // Categories based on common integration types - ordered by specificity
+        const categories = {
+            'Marketing': ['marketing', 'mailchimp', 'campaign', 'automation', 'klaviyo', 'activecampaign'],
+            'CRM': ['crm', 'customer', 'salesforce', 'hubspot', 'pipedrive', 'zoho'],
+            'E-commerce': ['ecommerce', 'shop', 'store', 'payment', 'stripe', 'paypal', 'shopify', 'woocommerce'],
+            'Analytics': ['analytics', 'tracking', 'google-analytics', 'mixpanel', 'segment', 'amplitude'],
+            'Social Media': ['social', 'facebook', 'twitter', 'instagram', 'linkedin', 'youtube'],
+            'Project Management': ['project', 'task', 'jira', 'trello', 'asana', 'monday', 'notion'],
+            'Storage': ['storage', 'file', 'dropbox', 'google-drive', 's3', 'box', 'onedrive'],
+            'Productivity': ['spreadsheet', 'google-sheets', 'airtable', 'calendar', 'todo'],
+            'Development': ['github', 'gitlab', 'bitbucket', 'git', 'ci', 'cd', 'jenkins'],
+            'Support': ['support', 'zendesk', 'freshdesk', 'intercom', 'helpdesk'],
+            'Finance': ['accounting', 'quickbooks', 'xero', 'sage', 'invoice', 'billing'],
+            'Communication': ['email', 'sms', 'chat', 'messaging', 'slack', 'discord', 'twilio', 'sendgrid'],
+            'Other': []
+        };
+
+        for (const [category, terms] of Object.entries(categories)) {
+            if (category === 'Other') continue;
+            
+            if (terms.some(term => allTerms.some(t => t.includes(term)))) {
+                return category;
+            }
+        }
+
+        return 'Other';
+    }
+
+    /**
+     * Get grouped modules by integration type
+     * @returns {Promise<Object>} Modules grouped by type
+     */
+    async getModulesByType() {
+        const modules = await this.searchApiModules();
+        
+        const grouped = modules.reduce((acc, module) => {
+            const type = module.category;
+            if (!acc[type]) {
+                acc[type] = [];
+            }
+            acc[type].push(module);
+            return acc;
+        }, {});
+
+        return grouped;
+    }
+}
+
+// Export singleton instance
+module.exports = new NPMRegistryService();