@l4yercak3/cli 1.0.0

package/src/config/config-manager.js

@@ -0,0 +1,205 @@
+/**
+ * Configuration Manager
+ * Handles storing and retrieving CLI configuration and session data
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class ConfigManager {
+  constructor() {
+    this.configDir = path.join(os.homedir(), '.l4yercak3');
+    this.configFile = path.join(this.configDir, 'config.json');
+  }
+
+  /**
+   * Ensure config directory exists
+   */
+  ensureConfigDir() {
+    if (!fs.existsSync(this.configDir)) {
+      fs.mkdirSync(this.configDir, { recursive: true, mode: 0o700 });
+    }
+  }
+
+  /**
+   * Get full config object
+   */
+  getConfig() {
+    this.ensureConfigDir();
+    
+    if (!fs.existsSync(this.configFile)) {
+      return {
+        session: null,
+        organizations: [],
+        settings: {
+          backendUrl: process.env.L4YERCAK3_BACKEND_URL || 'https://backend.l4yercak3.com',
+        },
+      };
+    }
+
+    try {
+      const data = fs.readFileSync(this.configFile, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      console.error('Error reading config file:', error.message);
+      return {
+        session: null,
+        organizations: [],
+        settings: {},
+      };
+    }
+  }
+
+  /**
+   * Save config object
+   */
+  saveConfig(config) {
+    this.ensureConfigDir();
+    
+    try {
+      fs.writeFileSync(
+        this.configFile,
+        JSON.stringify(config, null, 2),
+        { mode: 0o600 } // Read/write for owner only
+      );
+      return true;
+    } catch (error) {
+      console.error('Error saving config file:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get current session
+   */
+  getSession() {
+    const config = this.getConfig();
+    return config.session;
+  }
+
+  /**
+   * Save session
+   */
+  saveSession(session) {
+    const config = this.getConfig();
+    config.session = session;
+    return this.saveConfig(config);
+  }
+
+  /**
+   * Clear session (logout)
+   */
+  clearSession() {
+    const config = this.getConfig();
+    config.session = null;
+    return this.saveConfig(config);
+  }
+
+  /**
+   * Check if user is logged in
+   */
+  isLoggedIn() {
+    const session = this.getSession();
+    if (!session || !session.token) {
+      return false;
+    }
+
+    // Check expiration
+    if (session.expiresAt && session.expiresAt < Date.now()) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Get backend URL from config or env
+   */
+  getBackendUrl() {
+    const config = this.getConfig();
+    return config.settings?.backendUrl || process.env.L4YERCAK3_BACKEND_URL || 'https://backend.l4yercak3.com';
+  }
+
+  /**
+   * Set backend URL
+   */
+  setBackendUrl(url) {
+    const config = this.getConfig();
+    if (!config.settings) {
+      config.settings = {};
+    }
+    config.settings.backendUrl = url;
+    return this.saveConfig(config);
+  }
+
+  /**
+   * Add organization to config
+   */
+  addOrganization(org) {
+    const config = this.getConfig();
+    if (!config.organizations) {
+      config.organizations = [];
+    }
+
+    // Remove if exists
+    config.organizations = config.organizations.filter(o => o.id !== org.id);
+    
+    // Add new
+    config.organizations.push(org);
+    
+    return this.saveConfig(config);
+  }
+
+  /**
+   * Get organizations
+   */
+  getOrganizations() {
+    const config = this.getConfig();
+    return config.organizations || [];
+  }
+
+  /**
+   * Save project configuration
+   * Stores configuration for a specific project (by project path)
+   */
+  saveProjectConfig(projectPath, projectConfig) {
+    const config = this.getConfig();
+    if (!config.projects) {
+      config.projects = {};
+    }
+    
+    // Normalize project path (use absolute path)
+    const normalizedPath = path.resolve(projectPath);
+    config.projects[normalizedPath] = {
+      ...projectConfig,
+      updatedAt: Date.now(),
+    };
+    
+    return this.saveConfig(config);
+  }
+
+  /**
+   * Get project configuration
+   */
+  getProjectConfig(projectPath) {
+    const config = this.getConfig();
+    if (!config.projects) {
+      return null;
+    }
+    
+    const normalizedPath = path.resolve(projectPath);
+    return config.projects[normalizedPath] || null;
+  }
+
+  /**
+   * Get all project configurations
+   */
+  getAllProjectConfigs() {
+    const config = this.getConfig();
+    return config.projects || {};
+  }
+}
+
+module.exports = new ConfigManager();
+

package/src/detectors/api-client-detector.js

@@ -0,0 +1,85 @@
+/**
+ * API Client Pattern Detector
+ * Detects existing API client implementations
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ApiClientDetector {
+  /**
+   * Detect existing API client patterns
+   */
+  detect(projectPath = process.cwd()) {
+    const results = {
+      hasApiClient: false,
+      clientPath: null,
+      clientType: null, // 'fetch', 'axios', 'custom'
+      hasEnvFile: false,
+      envFilePath: null,
+    };
+
+    // Common API client locations
+    const clientPaths = [
+      'lib/api-client.ts',
+      'lib/api-client.js',
+      'lib/api.ts',
+      'lib/api.js',
+      'src/lib/api-client.ts',
+      'src/lib/api-client.js',
+      'src/lib/api.ts',
+      'src/lib/api.js',
+      'utils/api-client.ts',
+      'utils/api-client.js',
+      'utils/api.ts',
+      'utils/api.js',
+      'src/utils/api-client.ts',
+      'src/utils/api-client.js',
+    ];
+
+    // Check for existing API client
+    for (const clientPath of clientPaths) {
+      const fullPath = path.join(projectPath, clientPath);
+      if (fs.existsSync(fullPath)) {
+        results.hasApiClient = true;
+        results.clientPath = clientPath;
+        
+        // Try to detect client type
+        try {
+          const content = fs.readFileSync(fullPath, 'utf8');
+          if (content.includes('axios')) {
+            results.clientType = 'axios';
+          } else if (content.includes('fetch')) {
+            results.clientType = 'fetch';
+          } else {
+            results.clientType = 'custom';
+          }
+        } catch (error) {
+          results.clientType = 'unknown';
+        }
+        break;
+      }
+    }
+
+    // Check for environment files
+    const envFiles = [
+      '.env.local',
+      '.env',
+      '.env.development',
+      '.env.production',
+    ];
+
+    for (const envFile of envFiles) {
+      const fullPath = path.join(projectPath, envFile);
+      if (fs.existsSync(fullPath)) {
+        results.hasEnvFile = true;
+        results.envFilePath = envFile;
+        break;
+      }
+    }
+
+    return results;
+  }
+}
+
+module.exports = new ApiClientDetector();

package/src/detectors/base-detector.js

@@ -0,0 +1,77 @@
+/**
+ * Base Detector Class
+ * 
+ * All project type detectors should extend this class or implement its interface.
+ * This provides a consistent API for detection across all project types.
+ */
+
+class BaseDetector {
+  /**
+   * Unique identifier for this project type
+   * @returns {string} Detector name (e.g., 'nextjs', 'react', 'vue')
+   */
+  get name() {
+    throw new Error('Detector must implement name getter');
+  }
+
+  /**
+   * Detection priority (higher = checked first)
+   * Range: 0-100
+   * 
+   * Priority guidelines:
+   * - 100: Very specific frameworks (Next.js, Nuxt, SvelteKit)
+   * - 75: Framework with build tool (Vite + React, Webpack + Vue)
+   * - 50: Pure frameworks (React, Vue, Svelte)
+   * - 25: Generic JavaScript/TypeScript projects
+   * 
+   * @returns {number} Priority value
+   */
+  get priority() {
+    return 50; // Default priority
+  }
+
+  /**
+   * Detect if project matches this type
+   * 
+   * @param {string} projectPath - Path to project directory (defaults to process.cwd())
+   * @returns {object} Detection result with:
+   *   - detected: {boolean} Is this the project type?
+   *   - confidence: {number} 0-1, how sure are we?
+   *   - metadata: {object} Type-specific information
+   */
+  detect(_projectPath = process.cwd()) {
+    throw new Error('Detector must implement detect() method');
+  }
+
+  /**
+   * Get supported features for this project type
+   * 
+   * @returns {object} Feature support matrix:
+   *   - oauth: {boolean|'manual'} true = full support, 'manual' = guide only, false = not supported
+   *   - stripe: {boolean} Stripe integration support
+   *   - crm: {boolean} CRM features support
+   *   - projects: {boolean} Projects feature support
+   *   - invoices: {boolean} Invoices feature support
+   */
+  getSupportedFeatures() {
+    return {
+      oauth: false,
+      stripe: false,
+      crm: false,
+      projects: false,
+      invoices: false,
+    };
+  }
+
+  /**
+   * Get available generators for this project type
+   * 
+   * @returns {string[]} List of generator names that work with this project type
+   */
+  getAvailableGenerators() {
+    return ['api-client', 'env']; // Default: shared generators only
+  }
+}
+
+module.exports = BaseDetector;
+

package/src/detectors/github-detector.js

@@ -0,0 +1,74 @@
+/**
+ * GitHub Repository Detector
+ * Detects GitHub repository information from git remotes
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+class GitHubDetector {
+  /**
+   * Detect GitHub repository information
+   */
+  detect(projectPath = process.cwd()) {
+    const results = {
+      hasGit: false,
+      isGitHub: false,
+      owner: null,
+      repo: null,
+      url: null,
+      branch: null,
+    };
+
+    // Check if .git directory exists
+    const gitDir = path.join(projectPath, '.git');
+    if (!require('fs').existsSync(gitDir)) {
+      return results;
+    }
+
+    results.hasGit = true;
+
+    try {
+      // Get git remote URL
+      const remoteUrl = execSync('git config --get remote.origin.url', {
+        cwd: projectPath,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+      }).trim();
+
+      if (!remoteUrl) {
+        return results;
+      }
+
+      // Parse GitHub URL (supports both HTTPS and SSH formats)
+      // https://github.com/owner/repo.git
+      // git@github.com:owner/repo.git
+      const githubMatch = remoteUrl.match(/github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?$/);
+      
+      if (githubMatch) {
+        results.isGitHub = true;
+        results.owner = githubMatch[1];
+        results.repo = githubMatch[2].replace(/\.git$/, '');
+        results.url = `https://github.com/${results.owner}/${results.repo}`;
+      }
+
+      // Get current branch
+      try {
+        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+          cwd: projectPath,
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim();
+        results.branch = branch;
+      } catch (error) {
+        // Couldn't get branch
+      }
+    } catch (error) {
+      // Error reading git config
+    }
+
+    return results;
+  }
+}
+
+module.exports = new GitHubDetector();

package/src/detectors/index.js

@@ -0,0 +1,80 @@
+/**
+ * Project Detectors
+ * Main entry point for all project detection
+ * 
+ * This module orchestrates both framework detection (Next.js, React, etc.)
+ * and project metadata detection (GitHub, API clients, etc.)
+ */
+
+const registry = require('./registry');
+const githubDetector = require('./github-detector');
+const apiClientDetector = require('./api-client-detector');
+const oauthDetector = require('./oauth-detector');
+
+class ProjectDetector {
+  /**
+   * Run all detectors and return combined results
+   * 
+   * @param {string} projectPath - Path to project directory
+   * @returns {object} Combined detection results
+   */
+  detect(projectPath = process.cwd()) {
+    // Detect framework/project type
+    const frameworkDetection = registry.detectProjectType(projectPath);
+    
+    // Detect project metadata (framework-agnostic)
+    const githubInfo = githubDetector.detect(projectPath);
+    const apiClientInfo = apiClientDetector.detect(projectPath);
+    const oauthInfo = oauthDetector.detect(projectPath);
+
+    // Get detector instance if we have a match
+    const detector = frameworkDetection.detected 
+      ? registry.getDetector(frameworkDetection.detected)
+      : null;
+
+    return {
+      // Framework detection
+      framework: {
+        type: frameworkDetection.detected,
+        confidence: frameworkDetection.confidence,
+        metadata: frameworkDetection.metadata,
+        supportedFeatures: detector?.getSupportedFeatures() || {},
+        availableGenerators: detector?.getAvailableGenerators() || [],
+      },
+      
+      // Project metadata (framework-agnostic)
+      github: githubInfo,
+      apiClient: apiClientInfo,
+      oauth: oauthInfo,
+      
+      // Raw detection results (for debugging)
+      _raw: {
+        frameworkResults: frameworkDetection.allResults,
+      },
+      
+      // Project path
+      projectPath,
+    };
+  }
+
+  /**
+   * Get detector for a specific project type
+   * 
+   * @param {string} type - Project type name (e.g., 'nextjs')
+   * @returns {object|null} Detector instance or null
+   */
+  getDetector(type) {
+    return registry.getDetector(type);
+  }
+
+  /**
+   * Get all available project types
+   * 
+   * @returns {array} Array of detector names
+   */
+  getAvailableTypes() {
+    return registry.getAllDetectors().map(d => d.name);
+  }
+}
+
+module.exports = new ProjectDetector();

package/src/detectors/nextjs-detector.js

@@ -0,0 +1,139 @@
+/**
+ * Next.js Project Detector
+ * Detects Next.js projects and their configuration
+ */
+
+const fs = require('fs');
+const path = require('path');
+const BaseDetector = require('./base-detector');
+
+class NextJsDetector extends BaseDetector {
+  get name() {
+    return 'nextjs';
+  }
+
+  get priority() {
+    return 100; // High priority - very specific framework
+  }
+
+  /**
+   * Detect if current directory is a Next.js project
+   */
+  detect(projectPath = process.cwd()) {
+    const results = {
+      isNextJs: false,
+      version: null,
+      routerType: null, // 'app' or 'pages'
+      hasTypeScript: false,
+      config: null,
+    };
+
+    // Check for package.json
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+      return results;
+    }
+
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const dependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+      };
+
+      // Check if Next.js is installed
+      if (dependencies.next) {
+        results.isNextJs = true;
+        results.version = dependencies.next;
+      }
+
+      // Check for TypeScript
+      if (dependencies.typescript || fs.existsSync(path.join(projectPath, 'tsconfig.json'))) {
+        results.hasTypeScript = true;
+      }
+
+      // Detect router type (App Router vs Pages Router)
+      const appDir = path.join(projectPath, 'app');
+      const pagesDir = path.join(projectPath, 'pages');
+      const srcAppDir = path.join(projectPath, 'src', 'app');
+      const srcPagesDir = path.join(projectPath, 'src', 'pages');
+
+      if (fs.existsSync(appDir) || fs.existsSync(srcAppDir)) {
+        results.routerType = 'app';
+      } else if (fs.existsSync(pagesDir) || fs.existsSync(srcPagesDir)) {
+        results.routerType = 'pages';
+      }
+
+      // Read Next.js config if exists
+      const configFiles = [
+        'next.config.js',
+        'next.config.mjs',
+        'next.config.ts',
+        'next.config.cjs',
+      ];
+
+      for (const configFile of configFiles) {
+        const configPath = path.join(projectPath, configFile);
+        if (fs.existsSync(configPath)) {
+          try {
+            // For .js/.mjs/.cjs files, we'd need to require them
+            // For now, just note that config exists
+            results.config = configFile;
+            break;
+          } catch (error) {
+            // Config file exists but couldn't be read
+          }
+        }
+      }
+    } catch (error) {
+      // Error reading package.json
+    }
+
+    // Return in BaseDetector format
+    if (!results.isNextJs) {
+      return {
+        detected: false,
+        confidence: 0,
+        metadata: {},
+      };
+    }
+
+    return {
+      detected: true,
+      confidence: 0.95, // High confidence for Next.js detection
+      metadata: {
+        version: results.version,
+        routerType: results.routerType,
+        hasTypeScript: results.hasTypeScript,
+        config: results.config,
+      },
+    };
+  }
+
+  /**
+   * Get supported features for Next.js
+   */
+  getSupportedFeatures() {
+    return {
+      oauth: true,      // Full NextAuth.js support
+      stripe: true,     // Full Stripe support
+      crm: true,        // Full CRM support
+      projects: true,   // Full Projects support
+      invoices: true,    // Full Invoices support
+    };
+  }
+
+  /**
+   * Get available generators for Next.js
+   */
+  getAvailableGenerators() {
+    return [
+      'api-client',
+      'env',
+      'nextauth',      // Next.js-specific
+      'oauth-guide',
+    ];
+  }
+}
+
+module.exports = new NextJsDetector();