@friggframework/devtools 2.0.0--canary.424.a864ff6.0 → 2.0.0--canary.419.daed467.0

package/frigg-cli/index.js

@@ -12,27 +12,11 @@ const { uiCommand } = require('./ui-command');
 const program = new Command();
 
 program
-    .command('init [projectName]')
+    .command('init [templateName]')
     .description('Initialize a new Frigg application')
-    .option('-m, --mode <mode>', 'deployment mode (embedded|standalone)')
-    .option('--frontend', 'include demo frontend')
-    .option('--no-frontend', 'skip demo frontend')
-    .option('--no-interactive', 'run without interactive prompts')
-    .option('--non-interactive', 'run without interactive prompts (alias for --no-interactive)')
-    .option('--yes', 'auto-accept all defaults (non-interactive mode)')
-    .option('--app-purpose <purpose>', 'application purpose (own-app|platform|exploring)')
-    .option('--include-integrations', 'include starter integrations')
-    .option('--no-include-integrations', 'skip starter integrations')
-    .option('--include-api-module', 'create custom API module')
-    .option('--no-include-api-module', 'skip custom API module')
-    .option('--serverless-provider <provider>', 'serverless provider (aws|local)')
-    .option('--install-deps', 'install dependencies')
-    .option('--no-install-deps', 'skip dependency installation')
-    .option('--init-git', 'initialize git repository')
-    .option('--no-init-git', 'skip git initialization')
-    .option('--config <path>', 'configuration file path')
-    .option('-f, --force', 'overwrite existing directory')
-    .option('-v, --verbose', 'enable verbose output')
+    .option('-t, --template <template>', 'template to use', 'backend-only')
+    .option('-n, --name <name>', 'project name')
+    .option('-d, --directory <directory>', 'target directory')
     .action(initCommand);
 
 program
@@ -77,17 +61,6 @@ program
     .option('--no-open', 'do not open browser automatically')
     .action(uiCommand);
 
-if (require.main === module) {
-    program.parse(process.argv);
-}
+program.parse(process.argv);
 
-module.exports = {
-    program,
-    initCommand,
-    installCommand,
-    startCommand,
-    buildCommand,
-    deployCommand,
-    generateIamCommand,
-    uiCommand
-};
+module.exports = { initCommand, installCommand, startCommand, buildCommand, deployCommand, generateIamCommand, uiCommand };

package/frigg-cli/index.test.js

@@ -8,7 +8,7 @@ const { updateBackendJsFile } = require('./install-command/backend-js');
 const { commitChanges } = require('./install-command/commit-changes');
 const { logInfo, logError } = require('./install-command/logger');
 
-describe.skip('CLI Command Tests', () => {
+describe('CLI Command Tests', () => {
     it('should successfully install an API module when all steps complete without errors', async () => {
         const mockApiModuleName = 'testModule';
         const mockPackageName = `@friggframework/api-module-${mockApiModuleName}`;
@@ -46,7 +46,7 @@ describe.skip('CLI Command Tests', () => {
             .description('Install an API module')
             .action(installCommand);
 
-        await program.parseAsync(['node', 'test', 'install', mockApiModuleName]);
+        await program.parseAsync(['node', 'install', mockApiModuleName]);
 
         expect(validatePackageExists).toHaveBeenCalledWith(mockPackageName);
         expect(findNearestBackendPackageJson).toHaveBeenCalled();
@@ -94,7 +94,7 @@ describe.skip('CLI Command Tests', () => {
             .description('Install an API module')
             .action(installCommand);
 
-        await program.parseAsync(['node', 'test', 'install', 'nonexistent-package']);
+        await program.parseAsync(['node', 'install', 'nonexistent-package']);
 
         expect(mockValidatePackageExists).toHaveBeenCalledWith(
             '@friggframework/api-module-nonexistent-package'
@@ -141,7 +141,7 @@ describe.skip('CLI Command Tests', () => {
             .description('Install an API module')
             .action(installCommand);
 
-        await program.parseAsync(['node', 'test', 'install', 'test-module']);
+        await program.parseAsync(['node', 'install', 'test-module']);
 
         expect(mockLogError).toHaveBeenCalledWith(
             'An error occurred:',

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

@@ -14,7 +14,7 @@ class BackendFirstHandler {
     constructor(targetPath, options = {}) {
         this.targetPath = targetPath;
         this.appName = path.basename(targetPath);
-        this.options = { interactive: true, ...options };
+        this.options = options;
         this.templatesDir = path.join(__dirname, '..', 'templates');
     }
 
@@ -36,8 +36,8 @@ class BackendFirstHandler {
 
         console.log(chalk.green('\n✅ Frigg application created successfully!'));
         
-        // If user needs custom API module, prompt to create it (only in interactive mode)
-        if (config.needsCustomApiModule && this.options.interactive && !this.options.nonInteractive) {
+        // 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?',
@@ -49,11 +49,6 @@ class BackendFirstHandler {
                 console.log(chalk.cyan(`   cd ${path.relative(process.cwd(), this.targetPath)}`));
                 console.log(chalk.cyan('   frigg generate:api-module\n'));
             }
-        } else if (config.needsCustomApiModule && (this.options.nonInteractive || !this.options.interactive)) {
-            console.log(chalk.cyan('\n🔧 Custom API module needed'));
-            console.log(chalk.gray('\n   Run this command after setup:'));
-            console.log(chalk.cyan(`   cd ${path.relative(process.cwd(), this.targetPath)}`));
-            console.log(chalk.cyan('   frigg generate:api-module\n'));
         }
         
         this.displayNextSteps(deploymentMode, config);
@@ -67,10 +62,6 @@ class BackendFirstHandler {
             return this.options.mode;
         }
 
-        if (!this.options.interactive || this.options.nonInteractive) {
-            return 'standalone';
-        }
-
         const mode = await select({
             message: 'How will you deploy this Frigg application?',
             choices: [
@@ -91,42 +82,12 @@ class BackendFirstHandler {
         return mode;
     }
 
-    /**
-     * Get default configuration for non-interactive mode
-     */
-    getDefaultConfiguration(deploymentMode) {
-        const config = {
-            deploymentMode,
-            appPurpose: this.options.appPurpose || 'exploring',
-            needsCustomApiModule: this.options.includeApiModule || false,
-            includeIntegrations: this.options.includeIntegrations || false,
-            starterIntegrations: this.options.starterIntegrations || [],
-            includeDemoFrontend: this.options.frontend === true,
-            frontendFramework: this.options.frontendFramework || 'react',
-            demoAuthMode: this.options.demoAuthMode || 'mock',
-            serverlessProvider: this.options.serverlessProvider || (deploymentMode === 'standalone' ? 'aws' : undefined),
-            installDependencies: this.options.installDependencies !== false,
-            initializeGit: this.options.initializeGit !== false
-        };
-
-        // If app purpose is 'own-app' and no explicit API module setting, default to true
-        if (config.appPurpose === 'own-app' && this.options.includeApiModule === undefined) {
-            config.needsCustomApiModule = true;
-        }
-
-        return config;
-    }
-
     /**
      * Get project configuration based on deployment mode
      */
     async getProjectConfiguration(deploymentMode) {
         const config = { deploymentMode };
 
-        if (!this.options.interactive || this.options.nonInteractive) {
-            return this.getDefaultConfiguration(deploymentMode);
-        }
-
         // Ask about the purpose of this Frigg application
         config.appPurpose = await select({
             message: 'What are you building with Frigg?',

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

@@ -9,7 +9,6 @@
 
 const path = require('path');
 const chalk = require('chalk');
-const fs = require('fs-extra');
 const validateProjectName = require('validate-npm-package-name');
 const semver = require('semver');
 const BackendFirstHandler = require('./backend-first-handler');
@@ -55,10 +54,6 @@ async function initCommand(projectName, options) {
     const verbose = options.verbose || false;
     const force = options.force || false;
     
-    // Handle non-interactive mode flags
-    const nonInteractive = options.nonInteractive || options['no-interactive'] || options.yes || false;
-    const interactive = !nonInteractive;
-    
     checkNodeVersion();
 
     const root = path.resolve(projectName);
@@ -66,56 +61,15 @@ async function initCommand(projectName, options) {
 
     checkAppName(appName);
     
-    // Load configuration from file if provided
-    let configFromFile = {};
-    if (options.config) {
-        try {
-            const configPath = path.resolve(options.config);
-            if (await fs.pathExists(configPath)) {
-                configFromFile = await fs.readJSON(configPath);
-            } else {
-                console.log(chalk.yellow(`Warning: Config file not found: ${configPath}`));
-            }
-        } catch (error) {
-            console.log(chalk.yellow(`Warning: Could not load config file: ${error.message}`));
-        }
-    }
-    
-    // Merge options with environment variables and config file
-    const mergedOptions = {
-        force,
-        verbose,
-        mode: options.mode || process.env.FRIGG_DEPLOYMENT_MODE || configFromFile.deploymentMode,
-        frontend: options.frontend !== undefined ? options.frontend : 
-                 process.env.FRIGG_INCLUDE_FRONTEND !== undefined ? process.env.FRIGG_INCLUDE_FRONTEND === 'true' :
-                 configFromFile.includeFrontend,
-        interactive,
-        nonInteractive,
-        appPurpose: options.appPurpose || process.env.FRIGG_APP_PURPOSE || configFromFile.appPurpose,
-        includeIntegrations: options.includeIntegrations !== undefined ? options.includeIntegrations :
-                            process.env.FRIGG_INCLUDE_INTEGRATIONS !== undefined ? process.env.FRIGG_INCLUDE_INTEGRATIONS === 'true' :
-                            configFromFile.includeIntegrations,
-        includeApiModule: options.includeApiModule !== undefined ? options.includeApiModule :
-                         process.env.FRIGG_INCLUDE_API_MODULE !== undefined ? process.env.FRIGG_INCLUDE_API_MODULE === 'true' :
-                         configFromFile.includeApiModule,
-        serverlessProvider: options.serverlessProvider || process.env.FRIGG_SERVERLESS_PROVIDER || configFromFile.serverlessProvider,
-        installDependencies: options.installDeps !== undefined ? options.installDeps :
-                            process.env.FRIGG_INSTALL_DEPS !== undefined ? process.env.FRIGG_INSTALL_DEPS === 'true' :
-                            configFromFile.installDependencies,
-        initializeGit: options.initGit !== undefined ? options.initGit :
-                      process.env.FRIGG_INIT_GIT !== undefined ? process.env.FRIGG_INIT_GIT === 'true' :
-                      configFromFile.initializeGit,
-        starterIntegrations: process.env.FRIGG_STARTER_INTEGRATIONS ? 
-                            process.env.FRIGG_STARTER_INTEGRATIONS.split(',').map(s => s.trim()) :
-                            configFromFile.starterIntegrations,
-        frontendFramework: process.env.FRIGG_FRONTEND_FRAMEWORK || configFromFile.frontendFramework,
-        demoAuthMode: process.env.FRIGG_DEMO_AUTH_MODE || configFromFile.demoAuthMode
-    };
-    
     // Use backend-first handler by default
     if (!options.template && !options.legacyFrontend) {
         try {
-            const handler = new BackendFirstHandler(root, mergedOptions);
+            const handler = new BackendFirstHandler(root, {
+                force,
+                verbose,
+                mode: options.mode,
+                frontend: options.frontend
+            });
             
             await handler.initialize();
             return;

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

@@ -128,89 +128,15 @@ describe('Init Command', () => {
                 force: true,
                 verbose: true,
                 mode: 'standalone',
-                frontend: false,
-                interactive: false
+                frontend: false
             };
-
-            await initCommand(mockProjectName, options);
-
-            expect(BackendFirstHandler).toHaveBeenCalledWith(
-                expect.any(String),
-                expect.objectContaining({
-                    force: true,
-                    verbose: true,
-                    mode: 'standalone',
-                    frontend: false,
-                    interactive: true, // This gets set to true because interactive: false is not the same as nonInteractive: true
-                    nonInteractive: false
-                })
-            );
-        });
-
-        it('should handle non-interactive mode with --non-interactive flag', async () => {
-            const options = {
-                nonInteractive: true,
-                mode: 'standalone',
-                appPurpose: 'own-app'
-            };
-
-            await initCommand(mockProjectName, options);
-
-            expect(BackendFirstHandler).toHaveBeenCalledWith(
-                expect.any(String),
-                expect.objectContaining({
-                    nonInteractive: true,
-                    interactive: false,
-                    mode: 'standalone',
-                    appPurpose: 'own-app'
-                })
-            );
-        });
-
-        it('should handle non-interactive mode with --yes flag', async () => {
-            const options = {
-                yes: true,
-                mode: 'embedded'
-            };
-
-            await initCommand(mockProjectName, options);
-
-            expect(BackendFirstHandler).toHaveBeenCalledWith(
-                expect.any(String),
-                expect.objectContaining({
-                    nonInteractive: true,
-                    interactive: false,
-                    mode: 'embedded'
-                })
-            );
-        });
-
-        it('should handle environment variables', async () => {
-            const originalEnv = process.env.FRIGG_DEPLOYMENT_MODE;
-            process.env.FRIGG_DEPLOYMENT_MODE = 'embedded';
-            process.env.FRIGG_APP_PURPOSE = 'platform';
-
-            const options = {
-                nonInteractive: true
-            };
-
+            
             await initCommand(mockProjectName, options);
-
+            
             expect(BackendFirstHandler).toHaveBeenCalledWith(
                 expect.any(String),
-                expect.objectContaining({
-                    mode: 'embedded',
-                    appPurpose: 'platform'
-                })
+                expect.objectContaining(options)
             );
-
-            // Clean up
-            if (originalEnv !== undefined) {
-                process.env.FRIGG_DEPLOYMENT_MODE = originalEnv;
-            } else {
-                delete process.env.FRIGG_DEPLOYMENT_MODE;
-            }
-            delete process.env.FRIGG_APP_PURPOSE;
         });
 
         it('should handle initialization errors gracefully', async () => {

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

@@ -2,7 +2,7 @@ const axios = require('axios');
 
 // Mock dependencies
 jest.mock('axios');
-jest.mock('node-cache', () => jest.fn(), { virtual: true });
+jest.mock('node-cache');
 
 describe('NPMRegistryService', () => {
     let npmRegistry;