@friggframework/devtools 2.0.0--canary.400.bed3308.0 → 2.0.0--canary.404.e9d4980.0

package/frigg-cli/package.json

@@ -1,75 +0,0 @@
-{
-  "name": "@friggframework/cli",
-  "version": "1.0.0",
-  "description": "Frigg Framework CLI for serverless application development",
-  "main": "index.js",
-  "bin": {
-    "frigg": "./index.js"
-  },
-  "scripts": {
-    "test": "jest --config __tests__/jest.config.js",
-    "test:watch": "jest --config __tests__/jest.config.js --watch",
-    "test:coverage": "jest --config __tests__/jest.config.js --coverage",
-    "test:unit": "jest --config __tests__/jest.config.js --testPathPattern=unit",
-    "test:integration": "jest --config __tests__/jest.config.js --testPathPattern=integration",
-    "test:e2e": "jest --config __tests__/jest.config.js --testPathPattern=e2e",
-    "test:ci": "jest --config __tests__/jest.config.js --coverage --ci --watchAll=false",
-    "lint": "eslint *.js **/*.js --ignore-pattern node_modules --ignore-pattern __tests__",
-    "lint:fix": "eslint *.js **/*.js --ignore-pattern node_modules --ignore-pattern __tests__ --fix",
-    "typecheck": "echo 'No TypeScript files to check'",
-    "pretest": "npm run lint",
-    "posttest": "npm run test:coverage"
-  },
-  "keywords": [
-    "frigg",
-    "framework",
-    "cli",
-    "serverless",
-    "aws",
-    "lambda",
-    "api",
-    "integration"
-  ],
-  "author": "Frigg Framework Team",
-  "license": "MIT",
-  "dependencies": {
-    "commander": "^11.0.0",
-    "@friggframework/core": "workspace:*"
-  },
-  "devDependencies": {
-    "jest": "^29.7.0",
-    "jest-junit": "^16.0.0",
-    "jest-sonar-reporter": "^2.0.0",
-    "eslint": "^8.57.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.29.0",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^6.1.0"
-  },
-  "engines": {
-    "node": ">=18.0.0",
-    "npm": ">=9.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/friggframework/frigg.git",
-    "directory": "packages/devtools/frigg-cli"
-  },
-  "bugs": {
-    "url": "https://github.com/friggframework/frigg/issues"
-  },
-  "homepage": "https://github.com/friggframework/frigg#readme",
-  "files": [
-    "*.js",
-    "install-command/",
-    "build-command/",
-    "deploy-command/",
-    "generate-command/",
-    "ui-command/",
-    "utils/",
-    "README.md"
-  ],
-  "publishConfig": {
-    "access": "public"
-  }
-}

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

@@ -1,167 +0,0 @@
-const open = require('open');
-const chalk = require('chalk');
-const path = require('path');
-const ProcessManager = require('../utils/process-manager');
-const { AppResolver } = require('../utils/app-resolver');
-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();
-
-    // Check if new app path options are provided
-    if (options.appPath || options.config || options.app || process.env.FRIGG_APP_PATH) {
-        // Use AppResolver for new path resolution
-        const appResolver = new AppResolver();
-        try {
-            workingDirectory = await appResolver.resolveAppPath(options);
-            targetRepo = { path: workingDirectory, name: path.basename(workingDirectory) };
-            console.log(chalk.green(`✓ Resolved Frigg application: ${workingDirectory}`));
-        } catch (error) {
-            console.error(chalk.red('Error:'), error.message);
-            process.exit(1);
-        }
-    } else if (specifiedRepo) {
-        // Legacy repo option support
-        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 };

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

@@ -1,319 +0,0 @@
-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

@@ -1,38 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const PACKAGE_JSON = 'package.json';
-
-function findNearestBackendPackageJson() {
-    let currentDir = process.cwd();
-    
-    // First check if we're in production by looking for package.json in the current directory
-    const rootPackageJson = path.join(currentDir, PACKAGE_JSON);
-    if (fs.existsSync(rootPackageJson)) {
-        // In production environment, check for index.js in the same directory
-        const indexJs = path.join(currentDir, 'index.js');
-        if (fs.existsSync(indexJs)) {
-            return rootPackageJson;
-        }
-    }
-
-    // If not found at root or not in production, look for it in the backend directory
-    while (currentDir !== path.parse(currentDir).root) {
-        const packageJsonPath = path.join(currentDir, 'backend', PACKAGE_JSON);
-        if (fs.existsSync(packageJsonPath)) {
-            return packageJsonPath;
-        }
-        currentDir = path.dirname(currentDir);
-    }
-    return null;
-}
-
-function validateBackendPath(backendPath) {
-    if (!backendPath) {
-        throw new Error('Could not find a backend package.json file.');
-    }
-}
-
-module.exports = {
-    findNearestBackendPackageJson,
-    validateBackendPath,
-};