@l4yercak3/cli 1.2.16 → 1.2.18

package/src/mcp/registry/index.js

@@ -16,6 +16,7 @@ const eventsDomain = require('./domains/events');
 const formsDomain = require('./domains/forms');
 const codegenDomain = require('./domains/codegen');
 const applicationsDomain = require('./domains/applications');
+const benefitsDomain = require('./domains/benefits');
 
 /**
  * @typedef {Object} ToolDefinition
@@ -44,6 +45,7 @@ const toolDomains = [
   crmDomain,
   eventsDomain,
   formsDomain,
+  benefitsDomain,
   codegenDomain,
 ];
 

package/tests/database-detector.test.js

@@ -0,0 +1,221 @@
+/**
+ * Tests for Database Detector
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const databaseDetector = require('../src/detectors/database-detector');
+
+describe('DatabaseDetector', () => {
+  const mockProjectPath = '/test/project';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+  });
+
+  describe('detect', () => {
+    it('returns hasDatabase false when no database detected', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(false);
+      expect(result.detections).toHaveLength(0);
+      expect(result.primary).toBeNull();
+    });
+
+    it('detects Convex from directory', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'convex') ||
+               filePath === path.join(mockProjectPath, 'convex', 'schema.ts');
+      });
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      expect(result.primary.type).toBe('convex');
+      expect(result.primary.confidence).toBe('high');
+      expect(result.primary.hasSchema).toBe(true);
+    });
+
+    it('detects Supabase from directory', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'supabase') ||
+               filePath === path.join(mockProjectPath, 'supabase', 'migrations');
+      });
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      expect(result.primary.type).toBe('supabase');
+      expect(result.primary.confidence).toBe('high');
+      expect(result.primary.hasMigrations).toBe(true);
+    });
+
+    it('detects Prisma from directory', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'prisma') ||
+               filePath === path.join(mockProjectPath, 'prisma', 'schema.prisma');
+      });
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      expect(result.primary.type).toBe('prisma');
+      expect(result.primary.confidence).toBe('high');
+      expect(result.primary.hasSchema).toBe(true);
+    });
+
+    it('detects Drizzle from config file', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'drizzle.config.ts');
+      });
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      expect(result.primary.type).toBe('drizzle');
+      expect(result.primary.confidence).toBe('high');
+    });
+
+    it('detects database from package.json dependencies', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'package.json');
+      });
+
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          'convex': '^1.0.0',
+        },
+      }));
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      expect(result.primary.type).toBe('convex');
+      expect(result.primary.confidence).toBe('medium');
+      expect(result.primary.source).toBe('package.json');
+    });
+
+    it('detects Supabase from package.json', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'package.json');
+      });
+
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          '@supabase/supabase-js': '^2.0.0',
+        },
+      }));
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      expect(result.primary.type).toBe('supabase');
+    });
+
+    it('detects MongoDB/Mongoose from package.json', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'package.json');
+      });
+
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          'mongoose': '^7.0.0',
+        },
+      }));
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      expect(result.primary.type).toBe('mongodb');
+      expect(result.primary.details.client).toBe('mongoose');
+    });
+
+    it('detects Firebase from package.json', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'package.json');
+      });
+
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          'firebase': '^9.0.0',
+        },
+      }));
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      expect(result.primary.type).toBe('firebase');
+    });
+
+    it('prioritizes high confidence detections', () => {
+      // Both directory and package.json detected
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'convex') ||
+               filePath === path.join(mockProjectPath, 'package.json');
+      });
+
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          'mongoose': '^7.0.0',
+        },
+      }));
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      // Convex directory detection should be primary (high confidence)
+      expect(result.primary.type).toBe('convex');
+      expect(result.primary.confidence).toBe('high');
+      // MongoDB should also be in detections
+      expect(result.detections.some(d => d.type === 'mongodb')).toBe(true);
+    });
+
+    it('returns multiple detections when multiple databases found', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'package.json');
+      });
+
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: {
+          'convex': '^1.0.0',
+          'mongoose': '^7.0.0',
+        },
+      }));
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(true);
+      expect(result.detections.length).toBeGreaterThan(1);
+    });
+
+    it('handles malformed package.json gracefully', () => {
+      fs.existsSync.mockImplementation((filePath) => {
+        return filePath === path.join(mockProjectPath, 'package.json');
+      });
+
+      fs.readFileSync.mockReturnValue('not valid json');
+
+      const result = databaseDetector.detect(mockProjectPath);
+
+      expect(result.hasDatabase).toBe(false);
+    });
+
+    it('uses current directory as default', () => {
+      const originalCwd = process.cwd;
+      process.cwd = jest.fn().mockReturnValue(mockProjectPath);
+
+      fs.existsSync.mockReturnValue(false);
+
+      const result = databaseDetector.detect();
+
+      expect(result.hasDatabase).toBe(false);
+      process.cwd = originalCwd;
+    });
+  });
+});

package/tests/generators-index.test.js

@@ -27,7 +27,7 @@ describe('FileGenerator', () => {
     fs.readFileSync.mockReturnValue('');
   });
 
-  describe('generate', () => {
+  describe('legacy generate (backward compatibility)', () => {
     it('returns results object with expected structure', async () => {
       const options = {
         projectPath: mockProjectPath,
@@ -38,6 +38,7 @@ describe('FileGenerator', () => {
         oauthProviders: [],
         isTypeScript: false,
         routerType: 'app',
+        integrationPath: 'legacy', // Use legacy path for backward compatibility tests
       };
 
       const result = await FileGenerator.generate(options);
@@ -58,6 +59,7 @@ describe('FileGenerator', () => {
         features: ['crm'],
         oauthProviders: [],
         isTypeScript: false,
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -75,6 +77,7 @@ describe('FileGenerator', () => {
         features: [],
         oauthProviders: [],
         isTypeScript: false,
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -90,6 +93,7 @@ describe('FileGenerator', () => {
         organizationId: 'org-123',
         features: [],
         oauthProviders: [],
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -108,7 +112,8 @@ describe('FileGenerator', () => {
         oauthProviders: ['google'],
         isTypeScript: false,
         routerType: 'app',
-        frameworkType: 'nextjs', // NextAuth is Next.js only
+        frameworkType: 'nextjs',
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -126,6 +131,7 @@ describe('FileGenerator', () => {
         oauthProviders: ['google'],
         isTypeScript: true,
         frameworkType: 'expo',
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -143,6 +149,7 @@ describe('FileGenerator', () => {
         oauthProviders: ['google'],
         isTypeScript: false,
         routerType: 'app',
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -160,6 +167,7 @@ describe('FileGenerator', () => {
         oauthProviders: null,
         isTypeScript: false,
         routerType: 'app',
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -177,6 +185,7 @@ describe('FileGenerator', () => {
         oauthProviders: ['google'],
         productionDomain: 'example.com',
         appName: 'Test App',
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -193,6 +202,7 @@ describe('FileGenerator', () => {
         organizationId: 'org-123',
         features: ['crm'],
         oauthProviders: [],
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -208,11 +218,11 @@ describe('FileGenerator', () => {
         organizationId: 'org-123',
         features: [],
         oauthProviders: [],
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
 
-      // gitignore generator returns path or null depending on if update needed
       expect(result).toHaveProperty('gitignore');
     });
 
@@ -229,6 +239,7 @@ describe('FileGenerator', () => {
         productionDomain: 'example.com',
         appName: 'Full App',
         frameworkType: 'nextjs',
+        integrationPath: 'legacy',
       };
 
       const result = await FileGenerator.generate(options);
@@ -239,4 +250,205 @@ describe('FileGenerator', () => {
       expect(result.oauthGuide).not.toBeNull();
     });
   });
+
+  describe('api-only integration path', () => {
+    it('returns results object with expected structure', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm'],
+        oauthProviders: [],
+        isTypeScript: true,
+        integrationPath: 'api-only',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result).toHaveProperty('apiClient');
+      expect(result).toHaveProperty('types');
+      expect(result).toHaveProperty('webhooks');
+      expect(result).toHaveProperty('index');
+      expect(result).toHaveProperty('envFile');
+      expect(result).toHaveProperty('gitignore');
+    });
+
+    it('generates typed client file', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm'],
+        oauthProviders: [],
+        isTypeScript: true,
+        integrationPath: 'api-only',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.apiClient).not.toBeNull();
+      expect(result.apiClient).toContain('client.ts');
+    });
+
+    it('generates types file for TypeScript projects', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm'],
+        oauthProviders: [],
+        isTypeScript: true,
+        integrationPath: 'api-only',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.types).not.toBeNull();
+      expect(result.types).toContain('types.ts');
+    });
+
+    it('does not generate types file for JavaScript projects', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm'],
+        oauthProviders: [],
+        isTypeScript: false,
+        integrationPath: 'api-only',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.types).toBeNull();
+    });
+
+    it('generates webhooks utility file', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm'],
+        oauthProviders: [],
+        isTypeScript: true,
+        integrationPath: 'api-only',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.webhooks).not.toBeNull();
+      expect(result.webhooks).toContain('webhooks.ts');
+    });
+  });
+
+  describe('quickstart integration path', () => {
+    it('returns results object with expected structure', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm', 'oauth'],
+        oauthProviders: ['google'],
+        isTypeScript: true,
+        frameworkType: 'nextjs',
+        integrationPath: 'quickstart',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result).toHaveProperty('apiClient');
+      expect(result).toHaveProperty('types');
+      expect(result).toHaveProperty('webhooks');
+      expect(result).toHaveProperty('envFile');
+      expect(result).toHaveProperty('nextauth');
+      expect(result).toHaveProperty('oauthGuide');
+      expect(result).toHaveProperty('gitignore');
+    });
+
+    it('generates NextAuth for Next.js with oauth feature', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm', 'oauth'],
+        oauthProviders: ['google'],
+        isTypeScript: true,
+        frameworkType: 'nextjs',
+        integrationPath: 'quickstart',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.nextauth).not.toBeNull();
+      expect(result.oauthGuide).not.toBeNull();
+    });
+  });
+
+  describe('mcp-assisted integration path', () => {
+    it('returns results object with expected structure', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        organizationName: 'Test Org',
+        features: ['crm'],
+        oauthProviders: [],
+        isTypeScript: true,
+        integrationPath: 'mcp-assisted',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result).toHaveProperty('mcpConfig');
+      expect(result).toHaveProperty('mcpGuide');
+      expect(result).toHaveProperty('envFile');
+      expect(result).toHaveProperty('gitignore');
+    });
+
+    it('generates MCP config file', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        organizationName: 'Test Org',
+        features: ['crm'],
+        oauthProviders: [],
+        isTypeScript: true,
+        integrationPath: 'mcp-assisted',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.mcpConfig).not.toBeNull();
+      expect(result.mcpConfig).toContain('mcp.json');
+    });
+
+    it('generates MCP guide file', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        organizationName: 'Test Org',
+        features: ['crm'],
+        oauthProviders: [],
+        isTypeScript: true,
+        integrationPath: 'mcp-assisted',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.mcpGuide).not.toBeNull();
+      expect(result.mcpGuide).toContain('L4YERCAK3_MCP_GUIDE.md');
+    });
+  });
 });