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

package/frigg-cli/NON_INTERACTIVE_MODE.md

@@ -1,290 +0,0 @@
-# Frigg CLI Non-Interactive Mode
-
-This document describes the non-interactive mode implementation for the `frigg init` command, which enables automation, CI/CD pipelines, and Docker containerization.
-
-## Overview
-
-The non-interactive mode allows you to initialize Frigg applications without user prompts, making it suitable for:
-- Automation scripts
-- CI/CD pipelines
-- Docker containerization
-- Infrastructure as Code
-- Developer onboarding automation
-
-## Command Line Options
-
-### Basic Non-Interactive Flags
-
-```bash
-# Use --non-interactive flag
-frigg init my-project --non-interactive --mode standalone
-
-# Use --yes flag (alias for non-interactive with defaults)
-frigg init my-project --yes --mode standalone
-
-# Use --no-interactive flag (legacy support)
-frigg init my-project --no-interactive --mode standalone
-```
-
-### Configuration Options
-
-```bash
-# Application purpose
-frigg init my-project --non-interactive --app-purpose own-app
-frigg init my-project --non-interactive --app-purpose platform
-frigg init my-project --non-interactive --app-purpose exploring
-
-# API module configuration
-frigg init my-project --non-interactive --include-api-module
-frigg init my-project --non-interactive --no-include-api-module
-
-# Integration configuration
-frigg init my-project --non-interactive --include-integrations
-frigg init my-project --non-interactive --no-include-integrations
-
-# Frontend configuration
-frigg init my-project --non-interactive --frontend
-frigg init my-project --non-interactive --no-frontend
-
-# Serverless provider
-frigg init my-project --non-interactive --serverless-provider aws
-frigg init my-project --non-interactive --serverless-provider local
-
-# Dependencies and Git
-frigg init my-project --non-interactive --install-deps
-frigg init my-project --non-interactive --no-install-deps
-frigg init my-project --non-interactive --init-git
-frigg init my-project --non-interactive --no-init-git
-```
-
-### Configuration File Support
-
-```bash
-# Use configuration file
-frigg init my-project --config ./frigg-config.json --non-interactive
-```
-
-Example configuration file (`frigg-config.json`):
-```json
-{
-  "deploymentMode": "standalone",
-  "appPurpose": "own-app",
-  "includeApiModule": true,
-  "includeIntegrations": true,
-  "starterIntegrations": ["salesforce", "hubspot"],
-  "includeFrontend": false,
-  "frontendFramework": "react",
-  "demoAuthMode": "mock",
-  "serverlessProvider": "aws",
-  "installDependencies": true,
-  "initializeGit": true
-}
-```
-
-## Environment Variables
-
-You can also configure the initialization using environment variables:
-
-```bash
-# Set environment variables
-export FRIGG_DEPLOYMENT_MODE=standalone
-export FRIGG_APP_PURPOSE=own-app
-export FRIGG_INCLUDE_API_MODULE=true
-export FRIGG_INCLUDE_INTEGRATIONS=true
-export FRIGG_STARTER_INTEGRATIONS=salesforce,hubspot
-export FRIGG_INCLUDE_FRONTEND=false
-export FRIGG_FRONTEND_FRAMEWORK=react
-export FRIGG_DEMO_AUTH_MODE=mock
-export FRIGG_SERVERLESS_PROVIDER=aws
-export FRIGG_INSTALL_DEPS=true
-export FRIGG_INIT_GIT=true
-
-# Run init command
-frigg init my-project --non-interactive
-```
-
-### Available Environment Variables
-
-| Variable | Description | Values |
-|----------|-------------|---------|
-| `FRIGG_DEPLOYMENT_MODE` | Deployment mode | `standalone`, `embedded` |
-| `FRIGG_APP_PURPOSE` | Application purpose | `own-app`, `platform`, `exploring` |
-| `FRIGG_INCLUDE_API_MODULE` | Include custom API module | `true`, `false` |
-| `FRIGG_INCLUDE_INTEGRATIONS` | Include starter integrations | `true`, `false` |
-| `FRIGG_STARTER_INTEGRATIONS` | Comma-separated list of integrations | `salesforce,hubspot,slack` |
-| `FRIGG_INCLUDE_FRONTEND` | Include demo frontend | `true`, `false` |
-| `FRIGG_FRONTEND_FRAMEWORK` | Frontend framework | `react`, `vue`, `svelte`, `angular` |
-| `FRIGG_DEMO_AUTH_MODE` | Demo authentication mode | `mock`, `real` |
-| `FRIGG_SERVERLESS_PROVIDER` | Serverless provider | `aws`, `local` |
-| `FRIGG_INSTALL_DEPS` | Install dependencies | `true`, `false` |
-| `FRIGG_INIT_GIT` | Initialize Git repository | `true`, `false` |
-
-## Default Configuration
-
-When using non-interactive mode without explicit configuration, the following defaults are used:
-
-```javascript
-{
-  deploymentMode: 'standalone',
-  appPurpose: 'exploring',
-  needsCustomApiModule: false,
-  includeIntegrations: false,
-  starterIntegrations: [],
-  includeDemoFrontend: false,
-  frontendFramework: 'react',
-  demoAuthMode: 'mock',
-  serverlessProvider: 'aws', // for standalone mode
-  installDependencies: true,
-  initializeGit: true
-}
-```
-
-## Examples
-
-### Basic Non-Interactive Setup
-
-```bash
-# Minimal setup for exploring Frigg
-frigg init my-project --non-interactive
-
-# Standalone application for own use
-frigg init my-project --non-interactive --mode standalone --app-purpose own-app
-
-# Platform application with integrations
-frigg init my-project --non-interactive --mode standalone --app-purpose platform --include-integrations
-```
-
-### CI/CD Pipeline Example
-
-```bash
-#!/bin/bash
-# CI/CD pipeline script
-
-# Set configuration via environment variables
-export FRIGG_DEPLOYMENT_MODE=standalone
-export FRIGG_APP_PURPOSE=own-app
-export FRIGG_INCLUDE_API_MODULE=true
-export FRIGG_INCLUDE_INTEGRATIONS=true
-export FRIGG_STARTER_INTEGRATIONS=salesforce,hubspot
-export FRIGG_INSTALL_DEPS=true
-export FRIGG_INIT_GIT=true
-
-# Initialize Frigg application
-frigg init my-frigg-app --non-interactive
-
-# Build and deploy
-cd my-frigg-app
-npm run build
-npm run deploy
-```
-
-### Docker Containerization Example
-
-```dockerfile
-FROM node:18-alpine
-
-# Install Frigg CLI
-RUN npm install -g @friggframework/devtools
-
-# Set non-interactive configuration
-ENV FRIGG_DEPLOYMENT_MODE=standalone
-ENV FRIGG_APP_PURPOSE=platform
-ENV FRIGG_INCLUDE_INTEGRATIONS=true
-ENV FRIGG_INSTALL_DEPS=true
-ENV FRIGG_INIT_GIT=false
-
-# Initialize Frigg application
-RUN frigg init my-app --non-interactive
-
-WORKDIR /my-app
-EXPOSE 3001
-
-CMD ["npm", "start"]
-```
-
-### Configuration File Example
-
-```bash
-# Create configuration file
-cat > frigg-config.json << EOF
-{
-  "deploymentMode": "standalone",
-  "appPurpose": "platform",
-  "includeApiModule": false,
-  "includeIntegrations": true,
-  "starterIntegrations": ["salesforce", "hubspot", "slack"],
-  "includeFrontend": true,
-  "frontendFramework": "react",
-  "demoAuthMode": "mock",
-  "serverlessProvider": "aws",
-  "installDependencies": true,
-  "initializeGit": true
-}
-EOF
-
-# Use configuration file
-frigg init my-platform --config frigg-config.json --non-interactive
-```
-
-## Error Handling
-
-The non-interactive mode includes proper error handling:
-
-- **Missing templates**: Creates basic templates if they don't exist
-- **Invalid configuration**: Shows clear error messages and exits gracefully
-- **Dependency issues**: Continues with warnings if dependency installation fails
-- **Git initialization**: Continues if Git initialization fails (not critical)
-
-## Testing
-
-The non-interactive mode is thoroughly tested with:
-
-- Unit tests for configuration merging
-- Integration tests for command-line options
-- Environment variable testing
-- Configuration file testing
-- Error handling scenarios
-
-Run tests with:
-```bash
-npm test -- --testPathPattern="init-command"
-```
-
-## Migration from Interactive Mode
-
-If you have existing scripts using interactive mode, you can migrate them by:
-
-1. Adding `--non-interactive` flag
-2. Specifying required options explicitly
-3. Using environment variables for configuration
-4. Creating configuration files for complex setups
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Command hangs**: Make sure you're using `--non-interactive` or `--yes` flag
-2. **Missing templates**: The CLI will create basic templates automatically
-3. **Dependency errors**: Check that you're in a valid Node.js environment
-4. **Configuration conflicts**: Command-line options override environment variables and config files
-
-### Debug Mode
-
-Use `--verbose` flag for detailed output:
-```bash
-frigg init my-project --non-interactive --verbose
-```
-
-## Implementation Details
-
-The non-interactive mode is implemented in:
-
-- `init-command/index.js`: Command-line option parsing and configuration merging
-- `init-command/backend-first-handler.js`: Non-interactive logic and default configuration
-- `index.js`: CLI argument definitions
-
-Key features:
-- Configuration precedence: CLI options > Environment variables > Config file > Defaults
-- Graceful error handling
-- Comprehensive testing
-- Backward compatibility with existing interactive mode

package/frigg-cli/__tests__/unit/commands/backend-first-handler.test.js

@@ -1,207 +0,0 @@
-const path = require('path');
-const fs = require('fs-extra');
-const BackendFirstHandler = require('../../../init-command/backend-first-handler');
-
-// Mock dependencies
-jest.mock('fs-extra');
-jest.mock('chalk', () => ({
-    blue: jest.fn(text => text),
-    green: jest.fn(text => text),
-    red: jest.fn(text => text),
-    yellow: jest.fn(text => text),
-    gray: jest.fn(text => text),
-    cyan: jest.fn(text => text),
-    bold: jest.fn(text => text)
-}));
-jest.mock('@inquirer/prompts');
-jest.mock('child_process');
-jest.mock('cross-spawn');
-jest.mock('../../../utils/npm-registry');
-jest.mock('@friggframework/schemas');
-
-describe('BackendFirstHandler', () => {
-    const mockTargetPath = '/test/project/path';
-    let mockConsoleLog;
-    let mockConsoleError;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        
-        // Mock console methods
-        mockConsoleLog = jest.spyOn(console, 'log').mockImplementation();
-        mockConsoleError = jest.spyOn(console, 'error').mockImplementation();
-        
-        // Mock fs-extra methods
-        const fs = require('fs-extra');
-        fs.ensureDir.mockResolvedValue();
-        fs.pathExists.mockResolvedValue(false);
-        fs.readdir.mockResolvedValue([]);
-        fs.writeFile.mockResolvedValue();
-        fs.writeJSON.mockResolvedValue();
-        fs.readFile.mockResolvedValue('mock content');
-        fs.copy.mockResolvedValue();
-        fs.ensureDirSync.mockImplementation();
-        fs.readdirSync.mockReturnValue([]);
-        fs.writeFileSync.mockImplementation();
-        fs.lstatSync.mockReturnValue({ isDirectory: () => false });
-    });
-
-    afterEach(() => {
-        mockConsoleLog.mockRestore();
-        mockConsoleError.mockRestore();
-    });
-
-    describe('Non-Interactive Mode', () => {
-        it('should use default configuration in non-interactive mode', () => {
-            const options = {
-                nonInteractive: true,
-                mode: 'standalone',
-                appPurpose: 'own-app'
-            };
-
-            const handler = new BackendFirstHandler(mockTargetPath, options);
-            const config = handler.getDefaultConfiguration('standalone');
-
-            expect(config).toEqual({
-                deploymentMode: 'standalone',
-                appPurpose: 'own-app',
-                needsCustomApiModule: true, // Should default to true for 'own-app'
-                includeIntegrations: false,
-                starterIntegrations: [],
-                includeDemoFrontend: false,
-                frontendFramework: 'react',
-                demoAuthMode: 'mock',
-                serverlessProvider: 'aws',
-                installDependencies: true,
-                initializeGit: true
-            });
-        });
-
-        it('should use provided options in non-interactive mode', () => {
-            const options = {
-                nonInteractive: true,
-                mode: 'embedded',
-                appPurpose: 'platform',
-                includeApiModule: false,
-                includeIntegrations: true,
-                starterIntegrations: ['salesforce', 'hubspot'],
-                frontend: true,
-                frontendFramework: 'vue',
-                demoAuthMode: 'real',
-                serverlessProvider: 'local',
-                installDependencies: false,
-                initializeGit: false
-            };
-
-            const handler = new BackendFirstHandler(mockTargetPath, options);
-            const config = handler.getDefaultConfiguration('embedded');
-
-            expect(config).toEqual({
-                deploymentMode: 'embedded',
-                appPurpose: 'platform',
-                needsCustomApiModule: false,
-                includeIntegrations: true,
-                starterIntegrations: ['salesforce', 'hubspot'],
-                includeDemoFrontend: true,
-                frontendFramework: 'vue',
-                demoAuthMode: 'real',
-                serverlessProvider: 'local',
-                installDependencies: false,
-                initializeGit: false
-            });
-        });
-
-        it('should default to exploring mode when no app purpose specified', () => {
-            const options = {
-                nonInteractive: true,
-                mode: 'standalone'
-            };
-
-            const handler = new BackendFirstHandler(mockTargetPath, options);
-            const config = handler.getDefaultConfiguration('standalone');
-
-            expect(config.appPurpose).toBe('exploring');
-            expect(config.needsCustomApiModule).toBe(false);
-        });
-
-        it('should handle undefined options gracefully', () => {
-            const options = {
-                nonInteractive: true
-            };
-
-            const handler = new BackendFirstHandler(mockTargetPath, options);
-            const config = handler.getDefaultConfiguration('standalone');
-
-            expect(config).toEqual({
-                deploymentMode: 'standalone',
-                appPurpose: 'exploring',
-                needsCustomApiModule: false,
-                includeIntegrations: false,
-                starterIntegrations: [],
-                includeDemoFrontend: false,
-                frontendFramework: 'react',
-                demoAuthMode: 'mock',
-                serverlessProvider: 'aws',
-                installDependencies: true,
-                initializeGit: true
-            });
-        });
-    });
-
-    describe('Interactive Mode', () => {
-        it('should use interactive prompts when interactive is true', async () => {
-            const { select, confirm, multiselect } = require('@inquirer/prompts');
-            
-            // Mock the prompts
-            select.mockResolvedValue('standalone');
-            confirm.mockResolvedValue(true);
-            if (multiselect) {
-                multiselect.mockResolvedValue(['salesforce']);
-            }
-
-            const options = {
-                interactive: true,
-                nonInteractive: false
-            };
-
-            const handler = new BackendFirstHandler(mockTargetPath, options);
-            
-            // Mock the initialize method to avoid full execution
-            const initializeSpy = jest.spyOn(handler, 'initialize').mockResolvedValue();
-            
-            await handler.initialize();
-            
-            expect(initializeSpy).toHaveBeenCalled();
-        });
-    });
-
-    describe('Configuration Merging', () => {
-        it('should merge options with defaults correctly', () => {
-            const options = {
-                nonInteractive: true,
-                mode: 'standalone',
-                appPurpose: 'own-app',
-                includeApiModule: true,
-                includeIntegrations: true,
-                starterIntegrations: ['salesforce'],
-                frontend: true,
-                frontendFramework: 'angular',
-                demoAuthMode: 'real',
-                serverlessProvider: 'aws',
-                installDependencies: true,
-                initializeGit: true
-            };
-
-            const handler = new BackendFirstHandler(mockTargetPath, options);
-            const config = handler.getDefaultConfiguration('standalone');
-
-            expect(config.appPurpose).toBe('own-app');
-            expect(config.needsCustomApiModule).toBe(true);
-            expect(config.includeIntegrations).toBe(true);
-            expect(config.starterIntegrations).toEqual(['salesforce']);
-            expect(config.includeDemoFrontend).toBe(true);
-            expect(config.frontendFramework).toBe('angular');
-            expect(config.demoAuthMode).toBe('real');
-        });
-    });
-});

package/frigg-cli/init-command/frigg-config.example.json

@@ -1,13 +0,0 @@
-{
-  "deploymentMode": "standalone",
-  "appPurpose": "own-app",
-  "includeApiModule": true,
-  "includeIntegrations": true,
-  "starterIntegrations": ["salesforce", "hubspot"],
-  "includeFrontend": false,
-  "frontendFramework": "react",
-  "demoAuthMode": "mock",
-  "serverlessProvider": "aws",
-  "installDependencies": true,
-  "initializeGit": true
-}

package/frigg-cli/templates/backend/index.js

@@ -1,42 +0,0 @@
-/**
- * Frigg Application Definition
- * 
- * This file defines your Frigg application configuration.
- * Modify the integrations array to include the API modules you want to use.
- */
-
-// Import your integrations here
-// const ExampleIntegration = require('./src/integrations/ExampleIntegration');
-
-const appDefinition = {
-    integrations: [
-        // Add your integrations here as you install them
-        // Example:
-        // ExampleIntegration,
-    ],
-    user: {
-        password: true
-    },
-    encryption: {
-        useDefaultKMSForFieldLevelEncryption: true
-    },
-    vpc: {
-        enable: true
-    },
-    security: {
-        cors: {
-            origin: 'http://localhost:3000',
-            credentials: true
-        }
-    },
-    logging: {
-        level: 'info'
-    },
-    custom: {
-        appName: 'My Frigg Application',
-        version: '1.0.0',
-        environment: 'development'
-    }
-};
-
-module.exports = appDefinition;

package/frigg-cli/templates/backend/infrastructure.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Frigg Infrastructure Management
- * 
- * This script handles starting, building, and deploying your Frigg application.
- */
-
-const { spawn } = require('child_process');
-const path = require('path');
-
-const command = process.argv[2];
-
-switch (command) {
-    case 'start':
-        console.log('Starting Frigg backend...');
-        // In a real implementation, this would start the Frigg backend
-        console.log('Backend started on http://localhost:3001');
-        break;
-        
-    case 'package':
-        console.log('Packaging Frigg application...');
-        // In a real implementation, this would package the application
-        console.log('Application packaged successfully');
-        break;
-        
-    case 'deploy':
-        console.log('Deploying Frigg application...');
-        // In a real implementation, this would deploy to AWS Lambda
-        console.log('Application deployed successfully');
-        break;
-        
-    default:
-        console.log('Usage: node infrastructure.js [start|package|deploy]');
-        process.exit(1);
-}

package/frigg-cli/templates/backend/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "frigg-backend-template",
-  "version": "1.0.0",
-  "description": "Frigg backend application template",
-  "main": "index.js",
-  "scripts": {
-    "start": "node infrastructure.js start",
-    "build": "node infrastructure.js package",
-    "deploy": "node infrastructure.js deploy"
-  },
-  "dependencies": {
-    "@friggframework/core": "^2.0.0"
-  },
-  "devDependencies": {
-    "serverless": "^3.0.0",
-    "serverless-offline": "^12.0.0"
-  }
-}

package/frigg-cli/templates/backend/serverless.yml

@@ -1,25 +0,0 @@
-service: frigg-application
-
-provider:
-  name: aws
-  runtime: nodejs18.x
-  stage: ${opt:stage, 'dev'}
-  region: ${opt:region, 'us-east-1'}
-  environment:
-    NODE_ENV: ${self:provider.stage}
-
-functions:
-  api:
-    handler: index.handler
-    events:
-      - http:
-          path: /{proxy+}
-          method: ANY
-          cors: true
-
-plugins:
-  - serverless-offline
-
-custom:
-  serverless-offline:
-    httpPort: 3001

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

@@ -1,48 +0,0 @@
-const { Command } = require('commander');
-
-describe('frigg CLI init command', () => {
-  const setupProgram = action => {
-    const program = new Command();
-    program
-      .command('init [projectName]')
-      .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('-f, --force', 'overwrite existing directory')
-      .option('-v, --verbose', 'enable verbose output')
-      .action(action);
-    return program;
-  };
-
-  it('parses flags and forwards them to initCommand', async () => {
-    const mockInit = jest.fn();
-    const program = setupProgram(mockInit);
-
-    await program.parseAsync([
-      'node',
-      'test',
-      'init',
-      'my-app',
-      '--mode',
-      'standalone',
-      '--no-frontend',
-      '--no-interactive',
-      '--force',
-      '--verbose'
-    ]);
-
-    expect(mockInit).toHaveBeenCalledWith(
-      'my-app',
-      expect.objectContaining({
-        mode: 'standalone',
-        frontend: false,
-        interactive: false,
-        force: true,
-        verbose: true
-      }),
-      expect.anything()
-    );
-  });
-});
-