@l4yercak3/cli 1.3.2 → 2.0.0-alpha.1

package/src/detectors/model-detector.js

@@ -1,318 +0,0 @@
-/**
- * Model/Type Scanner
- * Detects data models and types across multiple sources:
- * - Prisma schemas
- * - TypeScript interfaces/types
- * - Drizzle table definitions
- * - Convex schemas
- */
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * @typedef {Object} DetectedModel
- * @property {string} name - Model name
- * @property {string} source - Source identifier (e.g., 'prisma/schema.prisma')
- * @property {string[]} fields - Field names
- */
-
-/**
- * Check if a path exists
- * @param {string} filePath
- * @returns {boolean}
- */
-function exists(filePath) {
-  try {
-    return fs.existsSync(filePath);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Safely read a file
- * @param {string} filePath
- * @returns {string|null}
- */
-function readFile(filePath) {
-  try {
-    return fs.readFileSync(filePath, 'utf8');
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Find files matching a pattern in a directory (non-recursive)
- * @param {string} dir
- * @param {RegExp} pattern
- * @returns {string[]}
- */
-function findFiles(dir, pattern) {
-  if (!exists(dir)) return [];
-  try {
-    return fs.readdirSync(dir)
-      .filter(f => pattern.test(f))
-      .map(f => path.join(dir, f));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Parse Prisma schema file for model definitions
- * @param {string} filePath - Path to schema.prisma
- * @returns {DetectedModel[]}
- */
-function parsePrismaSchema(filePath) {
-  const content = readFile(filePath);
-  if (!content) return [];
-
-  const models = [];
-  const modelRegex = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
-  let match;
-
-  while ((match = modelRegex.exec(content)) !== null) {
-    const name = match[1];
-    const body = match[2];
-    const fields = [];
-
-    for (const line of body.split('\n')) {
-      const trimmed = line.trim();
-      // Skip empty lines, comments, and @@ annotations
-      if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@')) continue;
-      // Extract field name (first word on the line)
-      const fieldMatch = trimmed.match(/^(\w+)\s+/);
-      if (fieldMatch) {
-        fields.push(fieldMatch[1]);
-      }
-    }
-
-    models.push({
-      name,
-      source: 'prisma/schema.prisma',
-      fields,
-    });
-  }
-
-  return models;
-}
-
-/**
- * Parse TypeScript files for interface and type definitions
- * @param {string[]} dirs - Directories to scan
- * @param {string} projectPath - Project root for relative paths
- * @returns {DetectedModel[]}
- */
-function parseTypeScriptTypes(dirs, projectPath) {
-  const models = [];
-  const filePattern = /\.(ts|tsx)$/;
-
-  for (const dir of dirs) {
-    const files = findFiles(dir, filePattern);
-
-    for (const filePath of files) {
-      const content = readFile(filePath);
-      if (!content) continue;
-
-      const relativePath = path.relative(projectPath, filePath);
-
-      // Match interface declarations
-      const interfaceRegex = /^(?:export\s+)?interface\s+(\w+)\s*(?:extends\s+[\w,\s<>]+)?\s*\{([^}]+)\}/gm;
-      let match;
-
-      while ((match = interfaceRegex.exec(content)) !== null) {
-        const name = match[1];
-        const body = match[2];
-        const fields = extractTsFields(body);
-        if (fields.length > 0) {
-          models.push({ name, source: relativePath, fields });
-        }
-      }
-
-      // Match type aliases with object shapes
-      const typeRegex = /^(?:export\s+)?type\s+(\w+)\s*=\s*\{([^}]+)\}/gm;
-      while ((match = typeRegex.exec(content)) !== null) {
-        const name = match[1];
-        const body = match[2];
-        const fields = extractTsFields(body);
-        if (fields.length > 0) {
-          models.push({ name, source: relativePath, fields });
-        }
-      }
-    }
-  }
-
-  return models;
-}
-
-/**
- * Extract field names from a TypeScript object body
- * @param {string} body
- * @returns {string[]}
- */
-function extractTsFields(body) {
-  const fields = [];
-  for (const line of body.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('/*')) continue;
-    // Match: fieldName: type or fieldName?: type
-    const fieldMatch = trimmed.match(/^(\w+)\s*\??:/);
-    if (fieldMatch) {
-      fields.push(fieldMatch[1]);
-    }
-  }
-  return fields;
-}
-
-/**
- * Parse Drizzle schema files for table definitions
- * @param {string[]} dirs - Directories to scan
- * @param {string} projectPath - Project root for relative paths
- * @returns {DetectedModel[]}
- */
-function parseDrizzleSchemas(dirs, projectPath) {
-  const models = [];
-  const filePattern = /schema.*\.(ts|js)$/;
-
-  for (const dir of dirs) {
-    const files = findFiles(dir, filePattern);
-
-    for (const filePath of files) {
-      const content = readFile(filePath);
-      if (!content) continue;
-
-      const relativePath = path.relative(projectPath, filePath);
-
-      // Match: export const tableName = pgTable('table_name', { ... })
-      const tableRegex = /export\s+const\s+(\w+)\s*=\s*(?:pgTable|mysqlTable|sqliteTable)\s*\(\s*['"](\w+)['"]\s*,\s*\{([^}]+)\}/g;
-      let match;
-
-      while ((match = tableRegex.exec(content)) !== null) {
-        // match[1] is the variable name (e.g., 'users'), match[2] is the SQL table name
-        const tableName = match[2];
-        const body = match[3];
-        const fields = [];
-
-        for (const line of body.split('\n')) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed.startsWith('//')) continue;
-          // Match: columnName: type(...)
-          const colMatch = trimmed.match(/^(\w+)\s*:/);
-          if (colMatch) {
-            fields.push(colMatch[1]);
-          }
-        }
-
-        // Use PascalCase version of table name as model name
-        const name = tableName
-          .split('_')
-          .map(w => w.charAt(0).toUpperCase() + w.slice(1))
-          .join('');
-
-        models.push({ name, source: relativePath, fields });
-      }
-    }
-  }
-
-  return models;
-}
-
-/**
- * Parse Convex schema file
- * @param {string} filePath - Path to convex/schema.ts
- * @param {string} projectPath - Project root
- * @returns {DetectedModel[]}
- */
-function parseConvexSchema(filePath, projectPath) {
-  const content = readFile(filePath);
-  if (!content) return [];
-
-  const models = [];
-  const relativePath = path.relative(projectPath, filePath);
-
-  // Match: tableName: defineTable({ ... })
-  const tableRegex = /(\w+)\s*:\s*defineTable\s*\(\s*\{([^}]+)\}/g;
-  let match;
-
-  while ((match = tableRegex.exec(content)) !== null) {
-    const tableName = match[1];
-    const body = match[2];
-    const fields = [];
-
-    for (const line of body.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith('//')) continue;
-      const fieldMatch = trimmed.match(/^(\w+)\s*:/);
-      if (fieldMatch) {
-        fields.push(fieldMatch[1]);
-      }
-    }
-
-    const name = tableName.charAt(0).toUpperCase() + tableName.slice(1);
-    models.push({ name, source: relativePath, fields });
-  }
-
-  return models;
-}
-
-/**
- * Detect all models/types in a project
- * @param {string} projectPath - Project root path
- * @returns {{ hasModels: boolean, models: DetectedModel[] }}
- */
-function detect(projectPath = process.cwd()) {
-  const allModels = [];
-
-  // 1. Prisma
-  const prismaPath = path.join(projectPath, 'prisma', 'schema.prisma');
-  if (exists(prismaPath)) {
-    allModels.push(...parsePrismaSchema(prismaPath));
-  }
-
-  // 2. TypeScript types/interfaces
-  const tsDirs = [
-    path.join(projectPath, 'types'),
-    path.join(projectPath, 'src', 'types'),
-    path.join(projectPath, 'models'),
-    path.join(projectPath, 'src', 'models'),
-  ].filter(d => exists(d));
-
-  if (tsDirs.length > 0) {
-    allModels.push(...parseTypeScriptTypes(tsDirs, projectPath));
-  }
-
-  // 3. Drizzle
-  const drizzleDirs = [
-    path.join(projectPath, 'drizzle'),
-    path.join(projectPath, 'src', 'db'),
-    path.join(projectPath, 'db'),
-  ].filter(d => exists(d));
-
-  if (drizzleDirs.length > 0) {
-    allModels.push(...parseDrizzleSchemas(drizzleDirs, projectPath));
-  }
-
-  // 4. Convex
-  const convexSchemaTs = path.join(projectPath, 'convex', 'schema.ts');
-  const convexSchemaJs = path.join(projectPath, 'convex', 'schema.js');
-  if (exists(convexSchemaTs)) {
-    allModels.push(...parseConvexSchema(convexSchemaTs, projectPath));
-  } else if (exists(convexSchemaJs)) {
-    allModels.push(...parseConvexSchema(convexSchemaJs, projectPath));
-  }
-
-  return {
-    hasModels: allModels.length > 0,
-    models: allModels,
-  };
-}
-
-module.exports = {
-  detect,
-  parsePrismaSchema,
-  parseTypeScriptTypes,
-  parseDrizzleSchemas,
-  parseConvexSchema,
-};

package/src/detectors/nextjs-detector.js

@@ -1,139 +0,0 @@
-/**
- * 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();

package/src/detectors/oauth-detector.js

@@ -1,122 +0,0 @@
-/**
- * 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();
-
-
-
-