@friggframework/devtools 2.0.0--canary.517.179491e.0 → 2.0.0--canary.522.893db5d.0

package/frigg-cli/infrastructure/repositories/FileSystemIntegrationRepository.js

@@ -0,0 +1,277 @@
+const path = require('path');
+const {IIntegrationRepository} = require('../../domain/ports/IIntegrationRepository');
+const {Integration} = require('../../domain/entities/Integration');
+const {IntegrationName} = require('../../domain/value-objects/IntegrationName');
+
+/**
+ * FileSystemIntegrationRepository
+ * Persists Integration entities to the file system
+ */
+class FileSystemIntegrationRepository extends IIntegrationRepository {
+    constructor(fileSystemAdapter, backendPath, schemaValidator, templateEngine = null) {
+        super();
+        this.fileSystemAdapter = fileSystemAdapter;
+        this.backendPath = backendPath;
+        this.schemaValidator = schemaValidator;
+        this.templateEngine = templateEngine;
+        this.integrationsDir = path.join(backendPath, 'src/integrations');
+    }
+
+    /**
+     * Save integration to file system
+     */
+    async save(integration) {
+        // Validate domain entity
+        const validation = integration.validate();
+        if (!validation.isValid) {
+            throw new Error(`Invalid integration: ${validation.errors.join(', ')}`);
+        }
+
+        // Convert to persistence format
+        const persistenceData = this._toPersistenceFormat(integration);
+
+        // Validate against schema
+        const schemaValidation = await this.schemaValidator.validate(
+            'integration-definition',
+            persistenceData.definition
+        );
+
+        if (!schemaValidation.valid) {
+            throw new Error(`Schema validation failed: ${schemaValidation.errors.join(', ')}`);
+        }
+
+        // Ensure integrations directory exists
+        await this.fileSystemAdapter.ensureDirectory(this.integrationsDir);
+
+        // Write single Integration.js file
+        // Note: Integration.js should only be written on creation, not on updates
+        // to preserve manual edits and module additions
+        const integrationJsPath = this._getIntegrationFilePath(integration.name.value);
+        const integrationJsExists = await this.fileSystemAdapter.exists(integrationJsPath);
+
+        if (!integrationJsExists) {
+            await this.fileSystemAdapter.writeFile(integrationJsPath, persistenceData.classFile);
+        }
+
+        return integration;
+    }
+
+    /**
+     * Find integration by name
+     */
+    async findByName(name) {
+        const nameStr = typeof name === 'string' ? name : name.value;
+        const integrationPath = this._getIntegrationFilePath(nameStr);
+
+        if (!await this.fileSystemAdapter.exists(integrationPath)) {
+            return null;
+        }
+
+        // Read the Integration.js file and extract static Definition
+        const content = await this.fileSystemAdapter.readFile(integrationPath);
+
+        // Parse the static Definition from the file
+        // This is a simple implementation - could be enhanced with AST parsing
+        const definitionMatch = content.match(/static Definition = ({[\s\S]*?});/);
+        if (!definitionMatch) {
+            return null;
+        }
+
+        try {
+            // Evaluate the definition object (be careful - this is simplified)
+            const definitionStr = definitionMatch[1];
+            // For now, just extract basic info using regex
+            const nameMatch = definitionStr.match(/name:\s*['"]([^'"]+)['"]/);
+            const versionMatch = definitionStr.match(/version:\s*['"]([^'"]+)['"]/);
+
+            if (!nameMatch || !versionMatch) {
+                return null;
+            }
+
+            return new Integration({
+                name: nameMatch[1],
+                version: versionMatch[1],
+                displayName: nameStr,
+                description: '',
+            });
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Check if integration exists
+     */
+    async exists(name) {
+        const nameStr = typeof name === 'string' ? name : name.value;
+        const integrationPath = this._getIntegrationFilePath(nameStr);
+        return await this.fileSystemAdapter.exists(integrationPath);
+    }
+
+    /**
+     * Get the file path for an integration
+     */
+    _getIntegrationFilePath(name) {
+        const className = this._toClassName(name);
+        return path.join(this.integrationsDir, `${className}Integration.js`);
+    }
+
+    /**
+     * Convert kebab-case name to ClassName
+     */
+    _toClassName(name) {
+        return name
+            .split('-')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join('');
+    }
+
+    /**
+     * List all integrations by reading Integration.js files
+     */
+    async list() {
+        if (!await this.fileSystemAdapter.exists(this.integrationsDir)) {
+            return [];
+        }
+
+        const files = await this.fileSystemAdapter.listFiles(this.integrationsDir, '*.js');
+        const integrations = [];
+
+        for (const fileName of files) {
+            // Only process files matching {Name}Integration.js pattern
+            if (!fileName.endsWith('Integration.js')) {
+                continue;
+            }
+
+            try {
+                // Extract integration name from filename
+                const className = fileName.replace('.js', '').replace('Integration', '');
+                const kebabName = this._toKebabCase(className);
+
+                const integration = await this.findByName(kebabName);
+                if (integration) {
+                    integrations.push(integration);
+                }
+            } catch (error) {
+                console.warn(`Failed to load integration ${fileName}:`, error.message);
+            }
+        }
+
+        return integrations;
+    }
+
+    /**
+     * Convert ClassName to kebab-case
+     */
+    _toKebabCase(className) {
+        return className
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .toLowerCase();
+    }
+
+    /**
+     * Convert domain entity to persistence format
+     */
+    _toPersistenceFormat(integration) {
+        const json = integration.toJSON();
+
+        return {
+            classFile: this._generateIntegrationClass(integration),
+            definition: json, // Still needed for schema validation
+        };
+    }
+
+    /**
+     * Convert persistence data to domain entity
+     */
+    _toDomainEntity(persistenceData) {
+        return new Integration({
+            name: persistenceData.name,
+            version: persistenceData.version,
+            displayName: persistenceData.display?.name,
+            description: persistenceData.display?.description,
+            type: persistenceData.options?.type || 'custom',
+            category: persistenceData.display?.category,
+            tags: persistenceData.display?.tags || [],
+            entities: persistenceData.entities || {},
+            apiModules: [], // Would need to extract from somewhere
+            capabilities: persistenceData.capabilities || {},
+            requirements: persistenceData.requirements || {},
+            options: persistenceData.options || {}
+        });
+    }
+
+    /**
+     * Generate Integration.js class file
+     */
+    _generateIntegrationClass(integration) {
+        const className = integration.name.value
+            .split('-')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join('');
+
+        const obj = integration.toObject();
+
+        return `const { IntegrationBase } = require('@friggframework/core');
+
+/**
+ * ${integration.displayName} Integration
+ * ${integration.description || 'No description provided'}
+ */
+class ${className}Integration extends IntegrationBase {
+    static Definition = {
+        name: '${obj.name}',
+        version: '${obj.version}',
+        supportedVersions: ['${obj.version}'],
+        hasUserConfig: false,
+
+        display: {
+            label: '${integration.displayName}',
+            description: '${integration.description || 'No description provided'}',
+            category: '${integration.category || 'Other'}',
+            detailsUrl: '',
+            icon: '',
+        },
+        modules: {
+            // Add your API modules here
+            // Example:
+            // myModule: {
+            //     definition: myModule.Definition,
+            // },
+        },
+        routes: [
+            // Define your integration routes here
+            // Example:
+            // {
+            //     path: '/auth',
+            //     method: 'GET',
+            //     event: 'AUTH_REQUEST',
+            // },
+        ],
+    };
+
+    constructor() {
+        super();
+        this.events = {
+            // Define your event handlers here
+            // Example:
+            // AUTH_REQUEST: {
+            //     handler: this.authRequest.bind(this),
+            // },
+        };
+    }
+
+    // TODO: Add your integration methods here
+    // Example:
+    // async authRequest({ res }) {
+    //     return res.json({ url: 'https://example.com/auth' });
+    // }
+}
+
+module.exports = ${className}Integration;
+`;
+    }
+
+}
+
+module.exports = {FileSystemIntegrationRepository};

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, multiselect } = require('@inquirer/prompts');
+const { select, confirm, checkbox } = 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
-        if (config.needsCustomApiModule) {
+
+        // If user needs custom API module, prompt to create it (skip in --yes mode)
+        if (config.needsCustomApiModule && !this.options.yes) {
             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,6 +62,11 @@ 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: [
@@ -88,6 +93,21 @@ 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?',
@@ -158,7 +178,7 @@ class BackendFirstHandler {
                     }
                 });
 
-                config.starterIntegrations = await multiselect({
+                config.starterIntegrations = await checkbox({
                     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',
@@ -266,63 +286,115 @@ 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) {
-        // Copy backend template
+        const backendPath = path.join(this.targetPath, 'backend');
+        const uiExtensionsPath = path.join(this.targetPath, 'ui-extensions');
+
+        // Copy backend template to backend/ subdirectory
         const backendTemplate = path.join(this.templatesDir, 'backend');
-        await fs.copy(backendTemplate, this.targetPath);
+        await fs.copy(backendTemplate, backendPath);
 
-        // Create package.json for standalone mode
-        const packageJson = {
-            name: this.appName,
+        // Read template package.json
+        const templatePackageJsonPath = path.join(backendPath, 'package.json');
+        let templatePackageJson = {};
+        if (await fs.pathExists(templatePackageJsonPath)) {
+            templatePackageJson = await fs.readJSON(templatePackageJsonPath);
+        }
+
+        // Create backend package.json with all dependencies
+        const backendPackageJson = {
+            name: `${this.appName}-backend`,
             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: {
-                "@friggframework/core": "^2.0.0"
+                ...templatePackageJson.dependencies,
+                "@friggframework/core": "2.0.0-next.58"
+            },
+            devDependencies: {
+                ...templatePackageJson.devDependencies
             }
         };
 
-        // Add demo frontend if requested
-        if (config.includeDemoFrontend) {
-            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
+        // Add selected integrations as dependencies to backend
         if (config.starterIntegrations && config.starterIntegrations.length > 0) {
             for (const integration of config.starterIntegrations) {
-                packageJson.dependencies[`@friggframework/api-module-${integration}`] = '^2.0.0';
+                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"
+            }
+        };
+
+        // 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' };
+
+            await this.createDemoFrontend(config);
+        }
+
         await fs.writeJSON(
             path.join(this.targetPath, 'package.json'),
-            packageJson,
+            rootPackageJson,
             { 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);
+            await this.updateAppDefinition(config.starterIntegrations, backendPath);
         }
 
         // Validate generated app definition against schema
-        const appDefPath = path.join(this.targetPath, 'index.js');
+        const appDefPath = path.join(backendPath, 'index.js');
         await this.validateGeneratedAppDefinition(appDefPath);
 
         // Update serverless.yml based on provider
         if (config.serverlessProvider === 'aws') {
-            await this.configureAWSServerless();
+            await this.configureAWSServerless(backendPath);
         }
     }
 
@@ -506,9 +578,9 @@ To integrate Frigg into your production application:
     /**
      * Configure AWS serverless
      */
-    async configureAWSServerless() {
+    async configureAWSServerless(targetDir = this.targetPath) {
         // Update serverless.yml for AWS
-        const serverlessPath = path.join(this.targetPath, 'serverless.yml');
+        const serverlessPath = path.join(targetDir, 'serverless.yml');
         if (await fs.pathExists(serverlessPath)) {
             // Keep existing AWS configuration
             console.log(chalk.gray('AWS Lambda configuration ready'));
@@ -533,23 +605,25 @@ To integrate Frigg into your production application:
     }
 
     /**
-     * Install dependencies
+     * Install dependencies in the backend directory
      */
     async installDependencies(config) {
-        console.log(chalk.blue('\n📦 Installing dependencies...'));
-        
+        console.log(chalk.blue('\n📦 Installing dependencies in backend...'));
+
         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: this.targetPath,
+            cwd: backendPath,
             stdio: 'inherit'
         });
 
         if (proc.status !== 0) {
             console.log(chalk.yellow('\n⚠️  Dependency installation failed'));
-            console.log(chalk.gray(`You can install manually with: ${command} install`));
+            console.log(chalk.gray(`You can install manually with: cd backend && ${command} install`));
         }
     }
 
@@ -577,7 +651,7 @@ To integrate Frigg into your production application:
      * Select from default integrations when npm is unavailable
      */
     async selectDefaultIntegrations() {
-        return await multiselect({
+        return await checkbox({
             message: 'Select starter integrations (space to select, enter to confirm):',
             choices: [
                 { name: 'Salesforce - CRM integration', value: 'salesforce' },
@@ -596,8 +670,8 @@ To integrate Frigg into your production application:
     /**
      * Update index.js with selected integrations
      */
-    async updateAppDefinition(integrations) {
-        const appDefPath = path.join(this.targetPath, 'index.js');
+    async updateAppDefinition(integrations, targetDir = this.targetPath) {
+        const appDefPath = path.join(targetDir, 'index.js');
         if (await fs.pathExists(appDefPath)) {
             let content = await fs.readFile(appDefPath, 'utf8');
             
@@ -720,14 +794,18 @@ To integrate Frigg into your production application:
         console.log(chalk.cyan(`   cd ${cdPath}\n`));
 
         if (deploymentMode === 'standalone') {
-            console.log(`2. Start the development server:`);
+            console.log(`2. Install backend dependencies:`);
+            console.log(chalk.cyan(`   cd backend && npm install\n`));
+
+            console.log(`3. 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(`3. Open the Frigg UI for development:`);
+            console.log(`4. Open the Frigg UI for development:`);
             console.log(chalk.cyan(`   frigg ui\n`));
 
             if (config.serverlessProvider === 'aws') {
-                console.log(`4. Deploy to AWS Lambda:`);
+                console.log(`5. Deploy to AWS Lambda:`);
                 console.log(chalk.cyan(`   npm run deploy\n`));
             }
         } else {
@@ -747,8 +825,12 @@ 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.frigg.dev'));
+        console.log(chalk.gray('Documentation: https://docs.friggframework.org'));
         console.log(chalk.gray('Support: https://github.com/friggframework/frigg/issues'));
     }
 }

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

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

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

@@ -75,6 +75,16 @@ 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);
+        }
     }
 
     /**
@@ -100,14 +110,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: create-frigg-app$/m,
+            /^service: 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 { logInfo } = require('./logger');
+const output = require('../utils/output');
 const INTEGRATIONS_DIR = 'src/integrations';
 const BACKEND_JS = 'backend.js';
 
 function updateBackendJsFile(backendPath, apiModuleName) {
     const backendJsPath = path.join(path.dirname(backendPath), BACKEND_JS);
-    logInfo(`Updating backend.js: ${backendJsPath}`);
+    output.debug(`Updating backend.js: ${backendJsPath}`);
     updateBackendJs(backendJsPath, apiModuleName);
 }
 
@@ -21,7 +21,7 @@ function updateBackendJs(backendJsPath, apiModuleName) {
         );
         fs.writeFileSync(backendJsPath, importStatement + updatedContent);
     } else {
-        logInfo(
+        output.debug(
             `Import statement for ${apiModuleName}Integration already exists in backend.js`
         );
     }