@l4yercak3/cli 1.0.0

package/src/detectors/oauth-detector.js

@@ -0,0 +1,122 @@
+/**
+ * OAuth Setup Detector
+ * Detects existing OAuth/NextAuth.js configuration
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class OAuthDetector {
+  /**
+   * Detect existing OAuth setup
+   */
+  detect(projectPath = process.cwd()) {
+    const results = {
+      hasOAuth: false,
+      oauthType: null, // 'nextauth', 'custom', 'unknown'
+      configPath: null,
+      providers: [], // ['google', 'microsoft', 'github']
+      hasEnvVars: false,
+    };
+
+    // Check for NextAuth.js configuration
+    const nextAuthPaths = [
+      // App Router
+      'app/api/auth/[...nextauth]/route.ts',
+      'app/api/auth/[...nextauth]/route.js',
+      'src/app/api/auth/[...nextauth]/route.ts',
+      'src/app/api/auth/[...nextauth]/route.js',
+      // Pages Router
+      'pages/api/auth/[...nextauth].ts',
+      'pages/api/auth/[...nextauth].js',
+      'src/pages/api/auth/[...nextauth].ts',
+      'src/pages/api/auth/[...nextauth].js',
+    ];
+
+    for (const configPath of nextAuthPaths) {
+      const fullPath = path.join(projectPath, configPath);
+      if (fs.existsSync(fullPath)) {
+        results.hasOAuth = true;
+        results.oauthType = 'nextauth';
+        results.configPath = configPath;
+
+        // Try to detect providers from config file
+        try {
+          const content = fs.readFileSync(fullPath, 'utf8');
+          const detectedProviders = [];
+
+          if (content.includes('GoogleProvider') || content.includes('google')) {
+            detectedProviders.push('google');
+          }
+          if (content.includes('AzureADProvider') || content.includes('microsoft') || content.includes('azure')) {
+            detectedProviders.push('microsoft');
+          }
+          if (content.includes('GitHubProvider') || content.includes('github')) {
+            detectedProviders.push('github');
+          }
+
+          results.providers = detectedProviders;
+        } catch (error) {
+          // Couldn't read config file
+        }
+        break;
+      }
+    }
+
+    // Check for OAuth-related environment variables
+    const envFiles = ['.env.local', '.env', '.env.development'];
+    for (const envFile of envFiles) {
+      const envPath = path.join(projectPath, envFile);
+      if (fs.existsSync(envPath)) {
+        try {
+          const content = fs.readFileSync(envPath, 'utf8');
+          const oauthVars = [
+            'NEXTAUTH_URL',
+            'NEXTAUTH_SECRET',
+            'GOOGLE_CLIENT_ID',
+            'GOOGLE_CLIENT_SECRET',
+            'MICROSOFT_CLIENT_ID',
+            'MICROSOFT_CLIENT_SECRET',
+            'GITHUB_CLIENT_ID',
+            'GITHUB_CLIENT_SECRET',
+            'GOOGLE_OAUTH_CLIENT_ID',
+            'GOOGLE_OAUTH_CLIENT_SECRET',
+          ];
+
+          const hasOAuthVars = oauthVars.some(varName => content.includes(varName));
+          if (hasOAuthVars) {
+            results.hasEnvVars = true;
+          }
+        } catch (error) {
+          // Couldn't read env file
+        }
+      }
+    }
+
+    // Check package.json for NextAuth.js dependency
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        
+        if (deps['next-auth'] || deps.nextauth) {
+          results.hasOAuth = true;
+          if (!results.oauthType) {
+            results.oauthType = 'nextauth';
+          }
+        }
+      } catch (error) {
+        // Couldn't read package.json
+      }
+    }
+
+    return results;
+  }
+}
+
+module.exports = new OAuthDetector();
+
+
+
+

package/src/detectors/registry.js

@@ -0,0 +1,97 @@
+/**
+ * Detector Registry
+ * 
+ * Central registry for all project type detectors.
+ * Detectors are automatically sorted by priority (highest first).
+ */
+
+const nextJsDetector = require('./nextjs-detector');
+// Future detectors will be added here:
+// const reactDetector = require('./react-detector');
+// const vueDetector = require('./vue-detector');
+
+/**
+ * All registered detectors
+ * Add new detectors here as they're implemented
+ */
+const detectors = [
+  nextJsDetector,
+  // Future: reactDetector, vueDetector, etc.
+];
+
+/**
+ * Sort detectors by priority (highest first)
+ */
+const sortedDetectors = [...detectors].sort((a, b) => b.priority - a.priority);
+
+/**
+ * Detect project type
+ * 
+ * Runs all detectors in priority order and returns the first match
+ * with confidence > 0.8, or all results if no high-confidence match.
+ * 
+ * @param {string} projectPath - Path to project directory
+ * @returns {object} Detection results
+ */
+function detectProjectType(projectPath = process.cwd()) {
+  const results = {
+    detected: null,      // Best match detector
+    confidence: 0,       // Confidence of best match
+    metadata: {},       // Metadata from best match
+    allResults: [],     // All detector results (for debugging)
+  };
+
+  // Run all detectors
+  for (const detector of sortedDetectors) {
+    try {
+      const result = detector.detect(projectPath);
+      
+      results.allResults.push({
+        detector: detector.name,
+        priority: detector.priority,
+        ...result,
+      });
+
+      // If this detector found a match with high confidence, use it
+      if (result.detected && result.confidence > 0.8) {
+        if (result.confidence > results.confidence) {
+          results.detected = detector.name;
+          results.confidence = result.confidence;
+          results.metadata = result.metadata;
+        }
+      }
+    } catch (error) {
+      console.error(`Error in detector ${detector.name}:`, error);
+      // Continue with other detectors
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get detector by name
+ * 
+ * @param {string} name - Detector name
+ * @returns {object|null} Detector instance or null
+ */
+function getDetector(name) {
+  return detectors.find(d => d.name === name) || null;
+}
+
+/**
+ * Get all registered detectors
+ * 
+ * @returns {array} Array of detector instances
+ */
+function getAllDetectors() {
+  return sortedDetectors;
+}
+
+module.exports = {
+  detectProjectType,
+  getDetector,
+  getAllDetectors,
+  detectors: sortedDetectors, // Expose sorted list
+};
+

package/src/generators/api-client-generator.js

@@ -0,0 +1,197 @@
+/**
+ * API Client Generator
+ * Generates API client code for the project
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ApiClientGenerator {
+  /**
+   * Generate API client file
+   */
+  generate(options) {
+    const {
+      projectPath,
+      apiKey,
+      backendUrl,
+      organizationId,
+      isTypeScript,
+    } = options;
+
+    // Determine output path based on project structure
+    const libDir = fs.existsSync(path.join(projectPath, 'src'))
+      ? path.join(projectPath, 'src', 'lib')
+      : path.join(projectPath, 'lib');
+
+    // Ensure lib directory exists
+    if (!fs.existsSync(libDir)) {
+      fs.mkdirSync(libDir, { recursive: true });
+    }
+
+    const extension = isTypeScript ? 'ts' : 'js';
+    const outputPath = path.join(libDir, `api-client.${extension}`);
+
+    // Generate API client code
+    const code = this.generateCode({
+      apiKey,
+      backendUrl,
+      organizationId,
+      isTypeScript,
+    });
+
+    fs.writeFileSync(outputPath, code, 'utf8');
+    return outputPath;
+  }
+
+  /**
+   * Generate API client code
+   */
+  generateCode({ apiKey, backendUrl, organizationId, isTypeScript }) {
+    const returnType = isTypeScript ? ': Promise<any>' : '';
+
+    return `/**
+ * L4YERCAK3 API Client
+ * Auto-generated by @l4yercak3/cli
+ * 
+ * This client handles authenticated requests to the L4YERCAK3 backend API.
+ * Organization ID: ${organizationId}
+ */
+
+// Using native fetch (available in Next.js 13+)
+
+class L4YERCAK3Client {
+  constructor(apiKey${isTypeScript ? ': string' : ''} = '${apiKey}', baseUrl${isTypeScript ? ': string' : ''} = '${backendUrl}') {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.organizationId = '${organizationId}';
+  }
+
+  /**
+   * Make authenticated API request
+   */
+  async request(endpoint${isTypeScript ? ': string' : ''}, options${isTypeScript ? ': RequestInit' : ''} = {})${returnType} {
+    const url = \`\${this.baseUrl}\${endpoint}\`;
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': \`Bearer \${this.apiKey}\`,
+      'X-Organization-Id': this.organizationId,
+      ...options.headers,
+    };
+
+    const response = await fetch(url, {
+      ...options,
+      headers,
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: 'Request failed' }));
+      throw new Error(error.message || \`API request failed: \${response.status}\`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * CRM Methods
+   */
+
+  async getContacts()${returnType} {
+    return this.request('/api/v1/crm/contacts');
+  }
+
+  async getContact(contactId${isTypeScript ? ': string' : ''})${returnType} {
+    return this.request(\`/api/v1/crm/contacts/\${contactId}\`);
+  }
+
+  async createContact(data${isTypeScript ? ': any' : ''})${returnType} {
+    return this.request('/api/v1/crm/contacts', {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async updateContact(contactId${isTypeScript ? ': string' : ''}, data${isTypeScript ? ': any' : ''})${returnType} {
+    return this.request(\`/api/v1/crm/contacts/\${contactId}\`, {
+      method: 'PATCH',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async deleteContact(contactId${isTypeScript ? ': string' : ''})${returnType} {
+    return this.request(\`/api/v1/crm/contacts/\${contactId}\`, {
+      method: 'DELETE',
+    });
+  }
+
+  /**
+   * Projects Methods
+   */
+
+  async getProjects()${returnType} {
+    return this.request('/api/v1/projects');
+  }
+
+  async getProject(projectId${isTypeScript ? ': string' : ''})${returnType} {
+    return this.request(\`/api/v1/projects/\${projectId}\`);
+  }
+
+  async createProject(data${isTypeScript ? ': any' : ''})${returnType} {
+    return this.request('/api/v1/projects', {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async updateProject(projectId${isTypeScript ? ': string' : ''}, data${isTypeScript ? ': any' : ''})${returnType} {
+    return this.request(\`/api/v1/projects/\${projectId}\`, {
+      method: 'PATCH',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async deleteProject(projectId${isTypeScript ? ': string' : ''})${returnType} {
+    return this.request(\`/api/v1/projects/\${projectId}\`, {
+      method: 'DELETE',
+    });
+  }
+
+  /**
+   * Invoices Methods
+   */
+
+  async getInvoices()${returnType} {
+    return this.request('/api/v1/invoices');
+  }
+
+  async getInvoice(invoiceId${isTypeScript ? ': string' : ''})${returnType} {
+    return this.request(\`/api/v1/invoices/\${invoiceId}\`);
+  }
+
+  async createInvoice(data${isTypeScript ? ': any' : ''})${returnType} {
+    return this.request('/api/v1/invoices', {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async updateInvoice(invoiceId${isTypeScript ? ': string' : ''}, data${isTypeScript ? ': any' : ''})${returnType} {
+    return this.request(\`/api/v1/invoices/\${invoiceId}\`, {
+      method: 'PATCH',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async deleteInvoice(invoiceId${isTypeScript ? ': string' : ''})${returnType} {
+    return this.request(\`/api/v1/invoices/\${invoiceId}\`, {
+      method: 'DELETE',
+    });
+  }
+}
+
+${isTypeScript ? 'export default L4YERCAK3Client;' : 'module.exports = L4YERCAK3Client;'}
+`;
+  }
+}
+
+module.exports = new ApiClientGenerator();

package/src/generators/env-generator.js

@@ -0,0 +1,162 @@
+/**
+ * Environment File Generator
+ * Generates .env.local file with configuration
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class EnvGenerator {
+  /**
+   * Generate or update .env.local file
+   */
+  generate(options) {
+    const {
+      projectPath,
+      apiKey,
+      backendUrl,
+      organizationId,
+      features,
+      oauthProviders,
+    } = options;
+
+    const envPath = path.join(projectPath, '.env.local');
+    const existingEnv = this.readExistingEnv(envPath);
+
+    // Merge with new values
+    const envVars = {
+      ...existingEnv,
+      // Core API configuration
+      L4YERCAK3_API_KEY: apiKey,
+      L4YERCAK3_BACKEND_URL: backendUrl,
+      L4YERCAK3_ORGANIZATION_ID: organizationId,
+      NEXT_PUBLIC_L4YERCAK3_BACKEND_URL: backendUrl,
+    };
+
+    // Add OAuth variables if OAuth is enabled
+    if (features.includes('oauth') && oauthProviders) {
+      if (oauthProviders.includes('google')) {
+        envVars.GOOGLE_CLIENT_ID = existingEnv.GOOGLE_CLIENT_ID || 'your_google_client_id_here';
+        envVars.GOOGLE_CLIENT_SECRET = existingEnv.GOOGLE_CLIENT_SECRET || 'your_google_client_secret_here';
+      }
+      if (oauthProviders.includes('microsoft')) {
+        envVars.AZURE_CLIENT_ID = existingEnv.AZURE_CLIENT_ID || 'your_azure_client_id_here';
+        envVars.AZURE_CLIENT_SECRET = existingEnv.AZURE_CLIENT_SECRET || 'your_azure_client_secret_here';
+        envVars.AZURE_TENANT_ID = existingEnv.AZURE_TENANT_ID || 'your_azure_tenant_id_here';
+      }
+      if (oauthProviders.includes('github')) {
+        envVars.GITHUB_CLIENT_ID = existingEnv.GITHUB_CLIENT_ID || 'your_github_client_id_here';
+        envVars.GITHUB_CLIENT_SECRET = existingEnv.GITHUB_CLIENT_SECRET || 'your_github_client_secret_here';
+      }
+      envVars.NEXTAUTH_URL = existingEnv.NEXTAUTH_URL || 'http://localhost:3000';
+      envVars.NEXTAUTH_SECRET = existingEnv.NEXTAUTH_SECRET || 'generate_with_openssl_rand_base64_32';
+    }
+
+    // Add Stripe variables if Stripe is enabled
+    if (features.includes('stripe')) {
+      envVars.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY = existingEnv.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY || 'your_stripe_publishable_key_here';
+      envVars.STRIPE_SECRET_KEY = existingEnv.STRIPE_SECRET_KEY || 'your_stripe_secret_key_here';
+      envVars.STRIPE_WEBHOOK_SECRET = existingEnv.STRIPE_WEBHOOK_SECRET || 'your_stripe_webhook_secret_here';
+    }
+
+    // Write env file
+    const envContent = this.formatEnvFile(envVars);
+    fs.writeFileSync(envPath, envContent, 'utf8');
+
+    return envPath;
+  }
+
+  /**
+   * Read existing .env.local file
+   */
+  readExistingEnv(envPath) {
+    const envVars = {};
+    
+    if (!fs.existsSync(envPath)) {
+      return envVars;
+    }
+
+    try {
+      const content = fs.readFileSync(envPath, 'utf8');
+      const lines = content.split('\n');
+      
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#')) {
+          const match = trimmed.match(/^([^=]+)=(.*)$/);
+          if (match) {
+            const key = match[1].trim();
+            const value = match[2].trim();
+            envVars[key] = value;
+          }
+        }
+      }
+    } catch (error) {
+      // Error reading file, return empty object
+    }
+
+    return envVars;
+  }
+
+  /**
+   * Format environment variables as .env file
+   */
+  formatEnvFile(envVars) {
+    let content = `# L4YERCAK3 Configuration
+# Auto-generated by @l4yercak3/cli
+# DO NOT commit this file to git - it contains sensitive credentials
+
+# Core API Configuration
+L4YERCAK3_API_KEY=${envVars.L4YERCAK3_API_KEY}
+L4YERCAK3_BACKEND_URL=${envVars.L4YERCAK3_BACKEND_URL}
+L4YERCAK3_ORGANIZATION_ID=${envVars.L4YERCAK3_ORGANIZATION_ID}
+NEXT_PUBLIC_L4YERCAK3_BACKEND_URL=${envVars.NEXT_PUBLIC_L4YERCAK3_BACKEND_URL}
+
+`;
+
+    // Add OAuth section if present
+    if (envVars.GOOGLE_CLIENT_ID || envVars.AZURE_CLIENT_ID || envVars.GITHUB_CLIENT_ID) {
+      content += `# OAuth Configuration
+`;
+      if (envVars.GOOGLE_CLIENT_ID) {
+        content += `GOOGLE_CLIENT_ID=${envVars.GOOGLE_CLIENT_ID}
+GOOGLE_CLIENT_SECRET=${envVars.GOOGLE_CLIENT_SECRET}
+
+`;
+      }
+      if (envVars.AZURE_CLIENT_ID) {
+        content += `AZURE_CLIENT_ID=${envVars.AZURE_CLIENT_ID}
+AZURE_CLIENT_SECRET=${envVars.AZURE_CLIENT_SECRET}
+AZURE_TENANT_ID=${envVars.AZURE_TENANT_ID}
+
+`;
+      }
+      if (envVars.GITHUB_CLIENT_ID) {
+        content += `GITHUB_CLIENT_ID=${envVars.GITHUB_CLIENT_ID}
+GITHUB_CLIENT_SECRET=${envVars.GITHUB_CLIENT_SECRET}
+
+`;
+      }
+      if (envVars.NEXTAUTH_URL) {
+        content += `NEXTAUTH_URL=${envVars.NEXTAUTH_URL}
+NEXTAUTH_SECRET=${envVars.NEXTAUTH_SECRET}
+
+`;
+      }
+    }
+
+    // Add Stripe section if present
+    if (envVars.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY) {
+      content += `# Stripe Configuration
+NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=${envVars.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY}
+STRIPE_SECRET_KEY=${envVars.STRIPE_SECRET_KEY}
+STRIPE_WEBHOOK_SECRET=${envVars.STRIPE_WEBHOOK_SECRET}
+
+`;
+    }
+
+    return content;
+  }
+}
+
+module.exports = new EnvGenerator();

package/src/generators/gitignore-generator.js

@@ -0,0 +1,92 @@
+/**
+ * Gitignore Generator
+ * Updates .gitignore to ensure sensitive files are not committed
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class GitignoreGenerator {
+  /**
+   * Update .gitignore file
+   */
+  generate(options) {
+    const { projectPath } = options;
+    const gitignorePath = path.join(projectPath, '.gitignore');
+    
+    // Required entries to ensure are present
+    const requiredEntries = [
+      '# L4YERCAK3 Configuration',
+      '.env.local',
+      '.env*.local',
+      '.l4yercak3/',
+    ];
+
+    let gitignoreContent = '';
+    let needsUpdate = false;
+
+    // Read existing .gitignore if it exists
+    if (fs.existsSync(gitignorePath)) {
+      gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+    }
+
+    // Check if required entries are missing
+    for (const entry of requiredEntries) {
+      // Skip comment lines for checking
+      if (entry.startsWith('#')) {
+        if (!gitignoreContent.includes(entry)) {
+          needsUpdate = true;
+        }
+      } else {
+        // Check for the actual entry (with or without leading/trailing whitespace)
+        const entryRegex = new RegExp(`^\\s*${entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'm');
+        if (!entryRegex.test(gitignoreContent)) {
+          needsUpdate = true;
+        }
+      }
+    }
+
+    // If no update needed, return null
+    if (!needsUpdate && gitignoreContent) {
+      return null;
+    }
+
+    // Append required entries if they're missing
+    if (needsUpdate) {
+      if (gitignoreContent && !gitignoreContent.endsWith('\n')) {
+        gitignoreContent += '\n';
+      }
+      
+      // Add section header if not present
+      if (!gitignoreContent.includes('# L4YERCAK3 Configuration')) {
+        gitignoreContent += '\n# L4YERCAK3 Configuration\n';
+        gitignoreContent += '# Auto-generated by @l4yercak3/cli\n';
+        gitignoreContent += '# DO NOT commit sensitive configuration files\n\n';
+      }
+
+      // Add entries if missing
+      const entriesToAdd = [
+        '.env.local',
+        '.env*.local',
+        '.l4yercak3/',
+      ];
+
+      for (const entry of entriesToAdd) {
+        const entryRegex = new RegExp(`^\\s*${entry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'm');
+        if (!entryRegex.test(gitignoreContent)) {
+          gitignoreContent += `${entry}\n`;
+        }
+      }
+    }
+
+    // Write updated .gitignore
+    fs.writeFileSync(gitignorePath, gitignoreContent, 'utf8');
+    return gitignorePath;
+  }
+}
+
+module.exports = new GitignoreGenerator();
+
+
+
+