@friggframework/devtools 2.0.0--canary.545.69acce5.0 → 2.0.0--canary.549.b074651.0

package/frigg-cli/init-command/backend-first-handler.js

@@ -1,7 +1,7 @@
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
-const { select, confirm, checkbox } = require('@inquirer/prompts');
+const { select, confirm, multiselect } = require('@inquirer/prompts');
 const { execSync } = require('child_process');
 const spawn = require('cross-spawn');
 const npmRegistry = require('../utils/npm-registry');
@@ -35,15 +35,15 @@ class BackendFirstHandler {
         await this.createProject(deploymentMode, config);
 
         console.log(chalk.green('\n✅ Frigg application created successfully!'));
-
-        // If user needs custom API module, prompt to create it (skip in --yes mode)
-        if (config.needsCustomApiModule && !this.options.yes) {
+        
+        // If user needs custom API module, prompt to create it
+        if (config.needsCustomApiModule) {
             console.log(chalk.cyan('\n🔧 Now let\'s create your custom API module...'));
             const createModule = await confirm({
                 message: 'Would you like to create your custom API module now?',
                 default: true
             });
-
+            
             if (createModule) {
                 console.log(chalk.gray('\n   Run this command after setup:'));
                 console.log(chalk.cyan(`   cd ${path.relative(process.cwd(), this.targetPath)}`));
@@ -62,11 +62,6 @@ class BackendFirstHandler {
             return this.options.mode;
         }
 
-        // If --yes flag is set, use default
-        if (this.options.yes) {
-            return 'standalone';
-        }
-
         const mode = await select({
             message: 'How will you deploy this Frigg application?',
             choices: [
@@ -93,21 +88,6 @@ class BackendFirstHandler {
     async getProjectConfiguration(deploymentMode) {
         const config = { deploymentMode };
 
-        // If --yes flag is set, use all defaults
-        if (this.options.yes) {
-            return {
-                deploymentMode,
-                appPurpose: 'exploring',
-                needsCustomApiModule: false,
-                includeIntegrations: false,
-                starterIntegrations: [],
-                includeDemoFrontend: false,
-                serverlessProvider: deploymentMode === 'standalone' ? 'aws' : undefined,
-                installDependencies: true,
-                initializeGit: true,
-            };
-        }
-
         // Ask about the purpose of this Frigg application
         config.appPurpose = await select({
             message: 'What are you building with Frigg?',
@@ -178,7 +158,7 @@ class BackendFirstHandler {
                     }
                 });
 
-                config.starterIntegrations = await checkbox({
+                config.starterIntegrations = await multiselect({
                     message: 'Select API modules to integrate (space to select, enter to confirm):',
                     choices,
                     instructions: '\n  Press <space> to select, <a> to toggle all, <enter> to confirm\n',
@@ -286,115 +266,63 @@ class BackendFirstHandler {
 
     /**
      * Create standalone Frigg service
-     *
-     * Structure:
-     * my-app/
-     * ├── package.json          # Root - delegates to backend with "cd backend &&"
-     * ├── backend/              # Actual Frigg app with its own package.json & node_modules
-     * │   ├── index.js
-     * │   ├── infrastructure.js
-     * │   ├── package.json
-     * │   └── src/
-     * └── ui-extensions/        # Platform-specific UI extensions
-     *     └── README.md
      */
     async createStandaloneProject(config) {
-        const backendPath = path.join(this.targetPath, 'backend');
-        const uiExtensionsPath = path.join(this.targetPath, 'ui-extensions');
-
-        // Copy backend template to backend/ subdirectory
+        // Copy backend template
         const backendTemplate = path.join(this.templatesDir, 'backend');
-        await fs.copy(backendTemplate, backendPath);
-
-        // Read template package.json
-        const templatePackageJsonPath = path.join(backendPath, 'package.json');
-        let templatePackageJson = {};
-        if (await fs.pathExists(templatePackageJsonPath)) {
-            templatePackageJson = await fs.readJSON(templatePackageJsonPath);
-        }
+        await fs.copy(backendTemplate, this.targetPath);
 
-        // Create backend package.json with all dependencies
-        const backendPackageJson = {
-            name: `${this.appName}-backend`,
+        // Create package.json for standalone mode
+        const packageJson = {
+            name: this.appName,
             version: '0.1.0',
             private: true,
-            prettier: templatePackageJson.prettier || '@friggframework/prettier-config',
             scripts: {
-                ...templatePackageJson.scripts,
                 "backend-start": "node infrastructure.js start",
                 "start": "npm run backend-start",
                 "build": "node infrastructure.js package",
                 "deploy": "node infrastructure.js deploy",
+                "test": "jest"
             },
             dependencies: {
-                ...templatePackageJson.dependencies,
-                "@friggframework/core": "2.0.0-next.58"
-            },
-            devDependencies: {
-                ...templatePackageJson.devDependencies
-            }
-        };
-
-        // Add selected integrations as dependencies to backend
-        if (config.starterIntegrations && config.starterIntegrations.length > 0) {
-            for (const integration of config.starterIntegrations) {
-                backendPackageJson.dependencies[`@friggframework/api-module-${integration}`] = '^2.0.0';
-            }
-        }
-
-        await fs.writeJSON(templatePackageJsonPath, backendPackageJson, { spaces: 2 });
-
-        // Create root package.json that delegates to backend
-        const rootPackageJson = {
-            name: this.appName,
-            version: '0.1.0',
-            private: true,
-            scripts: {
-                "start": "cd backend && npm run frigg:start",
-                "docker:start": "cd backend && npm run docker:start",
-                "docker:stop": "cd backend && npm run docker:stop",
-                "test": "cd backend && npm test",
-                "build": "cd backend && npm run build",
-                "deploy": "cd backend && npm run deploy",
-                "lint": "cd backend && npm run lint",
-                "format": "cd backend && npm run format"
+                "@friggframework/core": "^2.0.0"
             }
         };
 
         // Add demo frontend if requested
         if (config.includeDemoFrontend) {
-            rootPackageJson.scripts['dev'] = 'concurrently "cd backend && npm run backend-start" "cd frontend && npm run dev"';
-            rootPackageJson.scripts['frontend:dev'] = 'cd frontend && npm run dev';
-            rootPackageJson.devDependencies = { concurrently: '^8.2.2' };
-
+            packageJson.workspaces = ['backend', 'frontend'];
+            packageJson.scripts['dev'] = 'concurrently "npm run backend-start" "npm run frontend:dev"';
+            packageJson.scripts['frontend:dev'] = 'cd frontend && npm run dev';
+            
             await this.createDemoFrontend(config);
         }
 
+        // Add selected integrations as dependencies
+        if (config.starterIntegrations && config.starterIntegrations.length > 0) {
+            for (const integration of config.starterIntegrations) {
+                packageJson.dependencies[`@friggframework/api-module-${integration}`] = '^2.0.0';
+            }
+        }
+
         await fs.writeJSON(
             path.join(this.targetPath, 'package.json'),
-            rootPackageJson,
+            packageJson,
             { spaces: 2 }
         );
 
-        // Create ui-extensions directory with README
-        await fs.ensureDir(uiExtensionsPath);
-        const uiExtensionsReadme = path.join(this.templatesDir, 'backend', 'ui-extensions', 'README.md');
-        if (await fs.pathExists(uiExtensionsReadme)) {
-            await fs.copy(uiExtensionsReadme, path.join(uiExtensionsPath, 'README.md'));
-        }
-
         // Update index.js with selected integrations
         if (config.starterIntegrations && config.starterIntegrations.length > 0) {
-            await this.updateAppDefinition(config.starterIntegrations, backendPath);
+            await this.updateAppDefinition(config.starterIntegrations);
         }
 
         // Validate generated app definition against schema
-        const appDefPath = path.join(backendPath, 'index.js');
+        const appDefPath = path.join(this.targetPath, 'index.js');
         await this.validateGeneratedAppDefinition(appDefPath);
 
         // Update serverless.yml based on provider
         if (config.serverlessProvider === 'aws') {
-            await this.configureAWSServerless(backendPath);
+            await this.configureAWSServerless();
         }
     }
 
@@ -578,9 +506,9 @@ To integrate Frigg into your production application:
     /**
      * Configure AWS serverless
      */
-    async configureAWSServerless(targetDir = this.targetPath) {
+    async configureAWSServerless() {
         // Update serverless.yml for AWS
-        const serverlessPath = path.join(targetDir, 'serverless.yml');
+        const serverlessPath = path.join(this.targetPath, 'serverless.yml');
         if (await fs.pathExists(serverlessPath)) {
             // Keep existing AWS configuration
             console.log(chalk.gray('AWS Lambda configuration ready'));
@@ -605,25 +533,23 @@ To integrate Frigg into your production application:
     }
 
     /**
-     * Install dependencies in the backend directory
+     * Install dependencies
      */
     async installDependencies(config) {
-        console.log(chalk.blue('\n📦 Installing dependencies in backend...'));
-
+        console.log(chalk.blue('\n📦 Installing dependencies...'));
+        
         const useYarn = this.isUsingYarn();
         const command = useYarn ? 'yarn' : 'npm';
         const args = useYarn ? [] : ['install'];
 
-        // Install in backend directory where package.json with dependencies lives
-        const backendPath = path.join(this.targetPath, 'backend');
         const proc = spawn.sync(command, args, {
-            cwd: backendPath,
+            cwd: this.targetPath,
             stdio: 'inherit'
         });
 
         if (proc.status !== 0) {
             console.log(chalk.yellow('\n⚠️  Dependency installation failed'));
-            console.log(chalk.gray(`You can install manually with: cd backend && ${command} install`));
+            console.log(chalk.gray(`You can install manually with: ${command} install`));
         }
     }
 
@@ -651,7 +577,7 @@ To integrate Frigg into your production application:
      * Select from default integrations when npm is unavailable
      */
     async selectDefaultIntegrations() {
-        return await checkbox({
+        return await multiselect({
             message: 'Select starter integrations (space to select, enter to confirm):',
             choices: [
                 { name: 'Salesforce - CRM integration', value: 'salesforce' },
@@ -670,8 +596,8 @@ To integrate Frigg into your production application:
     /**
      * Update index.js with selected integrations
      */
-    async updateAppDefinition(integrations, targetDir = this.targetPath) {
-        const appDefPath = path.join(targetDir, 'index.js');
+    async updateAppDefinition(integrations) {
+        const appDefPath = path.join(this.targetPath, 'index.js');
         if (await fs.pathExists(appDefPath)) {
             let content = await fs.readFile(appDefPath, 'utf8');
             
@@ -794,18 +720,14 @@ To integrate Frigg into your production application:
         console.log(chalk.cyan(`   cd ${cdPath}\n`));
 
         if (deploymentMode === 'standalone') {
-            console.log(`2. Install backend dependencies:`);
-            console.log(chalk.cyan(`   cd backend && npm install\n`));
-
-            console.log(`3. Start the development server:`);
+            console.log(`2. Start the development server:`);
             console.log(chalk.cyan(`   npm start\n`));
-            console.log(chalk.gray(`   (or from backend: npm run frigg:start)\n`));
 
-            console.log(`4. Open the Frigg UI for development:`);
+            console.log(`3. Open the Frigg UI for development:`);
             console.log(chalk.cyan(`   frigg ui\n`));
 
             if (config.serverlessProvider === 'aws') {
-                console.log(`5. Deploy to AWS Lambda:`);
+                console.log(`4. Deploy to AWS Lambda:`);
                 console.log(chalk.cyan(`   npm run deploy\n`));
             }
         } else {
@@ -825,12 +747,8 @@ To integrate Frigg into your production application:
             console.log(chalk.gray('   See frontend/README.md for integration guidance.'));
         }
 
-        console.log(chalk.gray('\n📁 Project Structure:'));
-        console.log(chalk.gray('   backend/         - Frigg app (run npm install here)'));
-        console.log(chalk.gray('   ui-extensions/   - Platform-specific UI extensions'));
-
         console.log(chalk.green('\n🎉 Happy integrating with Frigg!\n'));
-        console.log(chalk.gray('Documentation: https://docs.friggframework.org'));
+        console.log(chalk.gray('Documentation: https://docs.frigg.dev'));
         console.log(chalk.gray('Support: https://github.com/friggframework/frigg/issues'));
     }
 }

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

@@ -68,8 +68,7 @@ async function initCommand(projectName, options) {
                 force,
                 verbose,
                 mode: options.mode,
-                frontend: options.frontend,
-                yes: options.yes
+                frontend: options.frontend
             });
             
             await handler.initialize();

package/frigg-cli/init-command/template-handler.js

@@ -75,16 +75,6 @@ class TemplateHandler {
                 return !['node_modules', '.serverless', 'dist', 'build'].includes(basename);
             }
         });
-
-        // Rename .env.default to .env if it exists and .env doesn't already exist
-        const envDefaultPath = path.join(target, '.env.default');
-        const envPath = path.join(target, '.env');
-        if (fs.existsSync(envDefaultPath) && !fs.existsSync(envPath)) {
-            await fs.rename(envDefaultPath, envPath);
-        } else if (fs.existsSync(envDefaultPath)) {
-            // Remove the .env.default if .env already exists
-            await fs.remove(envDefaultPath);
-        }
     }
 
     /**
@@ -110,14 +100,14 @@ class TemplateHandler {
     async updateServerlessConfig() {
         const serverlessPath = path.join(this.targetPath, 'serverless.yml');
         let serverlessContent = await fs.readFile(serverlessPath, 'utf8');
-
+        
         // Update service name based on directory name
         const projectName = path.basename(this.targetPath);
         serverlessContent = serverlessContent.replace(
-            /^service: frigg-app$/m,
+            /^service: create-frigg-app$/m,
             `service: ${projectName}`
         );
-
+        
         await fs.writeFile(serverlessPath, serverlessContent);
     }
 

package/frigg-cli/install-command/backend-js.js

@@ -1,12 +1,12 @@
 const fs = require('fs-extra');
 const path = require('path');
-const output = require('../utils/output');
+const { logInfo } = require('./logger');
 const INTEGRATIONS_DIR = 'src/integrations';
 const BACKEND_JS = 'backend.js';
 
 function updateBackendJsFile(backendPath, apiModuleName) {
     const backendJsPath = path.join(path.dirname(backendPath), BACKEND_JS);
-    output.debug(`Updating backend.js: ${backendJsPath}`);
+    logInfo(`Updating backend.js: ${backendJsPath}`);
     updateBackendJs(backendJsPath, apiModuleName);
 }
 
@@ -21,7 +21,7 @@ function updateBackendJs(backendJsPath, apiModuleName) {
         );
         fs.writeFileSync(backendJsPath, importStatement + updatedContent);
     } else {
-        output.debug(
+        logInfo(
             `Import statement for ${apiModuleName}Integration already exists in backend.js`
         );
     }

package/frigg-cli/install-command/environment-variables.js

@@ -1,8 +1,9 @@
 const fs = require('fs');
 const dotenv = require('dotenv');
 const { readFileSync, writeFileSync, existsSync } = require('fs');
-const output = require('../utils/output');
+const { logInfo } = require('./logger');
 const { resolve } = require('node:path');
+const { confirm, input } = require('@inquirer/prompts');
 const { parse } = require('@babel/parser');
 const traverse = require('@babel/traverse').default;
 
@@ -42,14 +43,15 @@ const extractRawEnvVariables = (modulePath) => {
     return envVariables;
 };
 const handleEnvVariables = async (backendPath, modulePath) => {
-    output.info('Searching for missing environment variables...');
+    logInfo('Searching for missing environment variables...');
     const Definition = { env: extractRawEnvVariables(modulePath) };
     if (Definition && Definition.env) {
-        output.debug('Definition.env:', JSON.stringify(Definition.env));
+        console.log('Here is Definition.env:', Definition.env);
         const envVars = Object.values(Definition.env);
 
-        output.info(
-            `Found environment variables in API module: ${envVars.join(', ')}`
+        console.log(
+            'Found the following environment variables in the API module:',
+            envVars
         );
 
         const localEnvPath = resolve(backendPath, '../.env');
@@ -76,19 +78,23 @@ const handleEnvVariables = async (backendPath, modulePath) => {
             (envVar) => !localEnvVars[envVar] && !localDevConfig[envVar]
         );
 
-        if (missingEnvVars.length > 0) {
-            output.warn(`Missing environment variables: ${missingEnvVars.join(', ')}`);
+        logInfo(`Missing environment variables: ${missingEnvVars.join(', ')}`);
 
-            const addEnvVars = await output.confirm(
-                `The following environment variables are required: ${missingEnvVars.join(
+        if (missingEnvVars.length > 0) {
+            const addEnvVars = await confirm({
+                message: `The following environment variables are required: ${missingEnvVars.join(
                     ', '
-                )}. Do you want to add them now?`
-            );
+                )}. Do you want to add them now?`,
+            });
 
             if (addEnvVars) {
                 const envValues = {};
                 for (const envVar of missingEnvVars) {
-                    const value = await output.input(`Enter value for ${envVar}:`);
+                    const value = await input({
+                        type: 'input',
+                        name: 'value',
+                        message: `Enter value for ${envVar}:`,
+                    });
                     envValues[envVar] = value;
                 }
 
@@ -111,12 +117,9 @@ const handleEnvVariables = async (backendPath, modulePath) => {
                         JSON.stringify(updatedDevConfig, null, 2)
                     );
                 }
-                output.success('Environment variables added successfully');
             } else {
-                output.info("Edit whenever you're able, safe travels friend!");
+                logInfo("Edit whenever you're able, safe travels friend!");
             }
-        } else {
-            output.success('All required environment variables are already configured');
         }
     }
 };

package/frigg-cli/install-command/environment-variables.test.js

@@ -1,14 +1,16 @@
 const { handleEnvVariables } = require('./environment-variables');
-const output = require('../utils/output');
+const { logInfo } = require('./logger');
+const inquirer = require('inquirer');
 const fs = require('fs');
 const dotenv = require('dotenv');
 const { resolve } = require('node:path');
 const { parse } = require('@babel/parser');
 const traverse = require('@babel/traverse');
 
-jest.mock('../utils/output');
+jest.mock('inquirer');
 jest.mock('fs');
 jest.mock('dotenv');
+jest.mock('./logger');
 jest.mock('@babel/parser');
 jest.mock('@babel/traverse');
 
@@ -97,23 +99,22 @@ describe('handleEnvVariables', () => {
             return '';
         });
 
-        output.confirm.mockResolvedValueOnce(true);
-        output.input
-            .mockResolvedValueOnce('client_id_value')
-            .mockResolvedValueOnce('client_secret_value')
-            .mockResolvedValueOnce('redirect_uri_value')
-            .mockResolvedValueOnce('scope_value');
+        inquirer.prompt
+            .mockResolvedValueOnce({ addEnvVars: true })
+            .mockResolvedValueOnce({ value: 'client_id_value' })
+            .mockResolvedValueOnce({ value: 'client_secret_value' })
+            .mockResolvedValueOnce({ value: 'redirect_uri_value' })
+            .mockResolvedValueOnce({ value: 'scope_value' });
 
         await handleEnvVariables(backendPath, modulePath);
 
-        expect(output.info).toHaveBeenCalledWith(
+        expect(logInfo).toHaveBeenCalledWith(
             'Searching for missing environment variables...'
         );
-        expect(output.warn).toHaveBeenCalledWith(
+        expect(logInfo).toHaveBeenCalledWith(
             'Missing environment variables: GOOGLE_CALENDAR_CLIENT_ID, GOOGLE_CALENDAR_CLIENT_SECRET, REDIRECT_URI, GOOGLE_CALENDAR_SCOPE'
         );
-        expect(output.confirm).toHaveBeenCalledTimes(1);
-        expect(output.input).toHaveBeenCalledTimes(4);
+        expect(inquirer.prompt).toHaveBeenCalledTimes(5);
         expect(fs.appendFileSync).toHaveBeenCalledWith(
             localEnvPath,
             '\nGOOGLE_CALENDAR_CLIENT_ID=client_id_value\nGOOGLE_CALENDAR_CLIENT_SECRET=client_secret_value\nREDIRECT_URI=redirect_uri_value\nGOOGLE_CALENDAR_SCOPE=scope_value'

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

@@ -2,7 +2,7 @@ const { installPackage } = require('./install-package');
 const { createIntegrationFile } = require('./integration-file');
 const { resolve } = require('node:path');
 const { updateBackendJsFile } = require('./backend-js');
-const output = require('../utils/output');
+const { logInfo, logError } = require('./logger');
 const { commitChanges } = require('./commit-changes');
 const { handleEnvVariables } = require('./environment-variables');
 const {
@@ -35,23 +35,18 @@ const installCommand = async (apiModuleName) => {
             const sanitizedLabel = label.replace(
                 /[<>:"/\\|?*\x00-\x1F\s]/g,
                 ''
-            ); // Remove invalid characters and spaces
-
-            const spinner = output.spinner(`Installing integration for ${sanitizedLabel}...`);
-            try {
-                createIntegrationFile(backendPath, sanitizedLabel, ApiClass);
-                updateBackendJsFile(backendPath, sanitizedLabel);
-                commitChanges(backendPath, sanitizedLabel);
-                spinner.succeed(`Successfully installed ${packageName} and updated the project.`);
-            } catch (innerError) {
-                spinner.fail(`Failed to install ${packageName}`);
-                throw innerError;
-            }
+            ); // Remove invalid characters and spaces            console.log('Installing integration for:', sanitizedLabel);
+            createIntegrationFile(backendPath, sanitizedLabel, ApiClass);
+            updateBackendJsFile(backendPath, sanitizedLabel);
+            commitChanges(backendPath, sanitizedLabel);
+            logInfo(
+                `Successfully installed ${packageName} and updated the project.`
+            );
 
             await handleEnvVariables(backendPath, modulePath);
         }
     } catch (error) {
-        output.error('An error occurred:', error);
+        logError('An error occurred:', error);
         process.exit(1);
     }
 };

package/frigg-cli/install-command/integration-file.js

@@ -1,6 +1,6 @@
 const fs = require('fs-extra');
 const path = require('path');
-const output = require('../utils/output');
+const { logInfo } = require('./logger');
 const { getIntegrationTemplate } = require('./template');
 const INTEGRATIONS_DIR = 'src/integrations';
 
@@ -9,14 +9,14 @@ function createIntegrationFile(backendPath, apiModuleName, ApiClass) {
         path.dirname(backendPath),
         INTEGRATIONS_DIR
     );
-    output.debug(`Ensuring directory exists: ${integrationDir}`);
+    logInfo(`Ensuring directory exists: ${integrationDir}`);
     fs.ensureDirSync(integrationDir);
 
     const integrationFilePath = path.join(
         integrationDir,
         `${apiModuleName}Integration.js`
     );
-    output.debug(`Writing integration file: ${integrationFilePath}`);
+    logInfo(`Writing integration file: ${integrationFilePath}`);
     const integrationTemplate = getIntegrationTemplate(
         apiModuleName,
         backendPath,

package/frigg-cli/install-command/logger.js

@@ -0,0 +1,12 @@
+function logInfo(message) {
+    console.log(message);
+}
+
+function logError(message, error) {
+    console.error(message, error);
+}
+
+module.exports = {
+    logInfo,
+    logError,
+};

package/frigg-cli/install-command/validate-package.js

@@ -1,6 +1,7 @@
 const { execSync } = require('child_process');
 const axios = require('axios');
-const output = require('../utils/output');
+const { logError } = require('./logger');
+const { checkbox } = require('@inquirer/prompts');
 
 async function searchPackages(apiModuleName) {
     const searchCommand = `npm search @friggframework/api-module-${apiModuleName} --json`;
@@ -30,7 +31,7 @@ const searchAndSelectPackage = async (apiModuleName) => {
     const searchResults = await searchPackages(apiModuleName || '');
 
     if (searchResults.length === 0) {
-        output.error(`No packages found matching ${apiModuleName}`);
+        logError(`No packages found matching ${apiModuleName}`);
         process.exit(1);
     }
 
@@ -43,7 +44,7 @@ const searchAndSelectPackage = async (apiModuleName) => {
         const earlierVersions = searchResults
             .map((pkg) => `${pkg.name} (${pkg.version})`)
             .join(', ');
-        output.error(
+        logError(
             `No packages found with version 1.0.0 or above for ${apiModuleName}. Found earlier versions: ${earlierVersions}`
         );
         process.exit(1);
@@ -57,8 +58,11 @@ const searchAndSelectPackage = async (apiModuleName) => {
         };
     });
 
-    const selectedPackages = await output.checkbox('Select the packages to install:', choices);
-    output.info(`Selected packages: ${selectedPackages.join(', ')}`);
+    const selectedPackages = await checkbox({
+        message: 'Select the packages to install:',
+        choices,
+    });
+    console.log('Selected packages:', selectedPackages);
 
     return selectedPackages.map((choice) => choice.split(' ')[0]);
 };

package/frigg-cli/jest.config.js

@@ -1,8 +1,5 @@
-const path = require('path');
-
 module.exports = {
   displayName: 'Frigg CLI Tests',
-  rootDir: __dirname,
   testMatch: [
     '<rootDir>/__tests__/**/*.test.js',
     '<rootDir>/__tests__/**/*.spec.js',
@@ -96,7 +93,7 @@ module.exports = {
     }
   },
   setupFilesAfterEnv: [
-    path.join(__dirname, '__tests__', 'utils', 'test-setup.js')
+    '<rootDir>/__tests__/utils/test-setup.js'
   ],
   testTimeout: 10000,
   maxWorkers: '50%',