@nextsparkjs/core 0.1.0-beta.8 → 0.1.0-beta.82

package/scripts/build/theme.mjs

@@ -32,6 +32,76 @@ function getActiveTheme() {
   return process.env.NEXT_PUBLIC_ACTIVE_THEME
 }
 
+/**
+ * Sync app/globals.css to import from the active theme
+ *
+ * This ensures the import path in app/globals.css always matches
+ * NEXT_PUBLIC_ACTIVE_THEME, handling both npm and monorepo modes.
+ *
+ * @param {object} config - Configuration from getConfig()
+ * @param {string} activeTheme - Active theme name
+ * @returns {boolean} - True if file was updated, false if already correct
+ */
+export function syncAppGlobalsCss(config, activeTheme) {
+  const appGlobalsCssPath = path.join(config.projectRoot, 'app', 'globals.css')
+
+  // Calculate the correct relative path from app/ to theme globals.css
+  const appDir = path.join(config.projectRoot, 'app')
+  const themeGlobalsPath = path.join(config.themesDir, activeTheme, 'styles', 'globals.css')
+  // Normalize to forward slashes for cross-platform CSS compatibility
+  const relativePath = path.relative(appDir, themeGlobalsPath).replace(/\\/g, '/')
+
+  // Expected import statement
+  const expectedImport = `@import "${relativePath}";`
+
+  // Template for app/globals.css
+  const template = `/* =============================================
+   GLOBAL STYLES - Import from Active Theme
+
+   This file imports styles from the active theme.
+   DO NOT edit directly - all styles are in:
+   contents/themes/{theme}/styles/globals.css
+
+   To customize colors, typography and tokens, edit
+   the globals.css file in your active theme.
+   ============================================= */
+
+${expectedImport}
+`
+
+  // Check if file exists and has correct import
+  if (fs.existsSync(appGlobalsCssPath)) {
+    const currentContent = fs.readFileSync(appGlobalsCssPath, 'utf8')
+
+    // Extract current import (handle various formats)
+    const importMatch = currentContent.match(/@import\s+["']([^"']+)["'];?/)
+
+    if (importMatch) {
+      const currentImportPath = importMatch[1]
+
+      // Check if it's already pointing to the correct theme
+      if (currentImportPath === relativePath) {
+        return false // Already correct, no update needed
+      }
+
+      // Update only the import line, preserving any custom comments
+      const updatedContent = currentContent.replace(
+        /@import\s+["'][^"']+["'];?/,
+        expectedImport
+      )
+
+      fs.writeFileSync(appGlobalsCssPath, updatedContent)
+      console.log(`   🔄 Updated app/globals.css import: ${relativePath}`)
+      return true
+    }
+  }
+
+  // File doesn't exist or has no import - write full template
+  fs.writeFileSync(appGlobalsCssPath, template)
+  console.log(`   ✅ Created app/globals.css with import: ${relativePath}`)
+  return true
+}
+
 /**
  * Recursively copy directory contents
  */
@@ -159,6 +229,36 @@ function copyThemePublicAssets(themePath, activeTheme) {
   }
 }
 
+/**
+ * Validate that theme globals.css has all required sections
+ * @param {string} cssContent - Content of the globals.css file
+ * @param {string} themeName - Name of the theme being validated
+ * @returns {boolean} - True if valid, false if missing required sections
+ */
+function validateThemeCSS(cssContent, themeName) {
+  const required = [
+    { pattern: '@import "tailwindcss"', name: 'Tailwind import' },
+    { pattern: ':root', name: 'Light mode variables' },
+    { pattern: '.dark', name: 'Dark mode variables' },
+    { pattern: '@theme', name: 'Tailwind v4 theme mapping' },
+    { pattern: '--background:', name: '--background variable' },
+    { pattern: '--primary:', name: '--primary variable' },
+    { pattern: '--color-background:', name: '@theme background mapping' }
+  ]
+
+  const missing = required.filter(r => !cssContent.includes(r.pattern))
+
+  if (missing.length > 0) {
+    console.warn(`   ⚠️  Theme "${themeName}" globals.css missing required sections:`)
+    missing.forEach(m => console.warn(`      - ${m.name}`))
+    console.warn(`   💡 Theme globals.css should be self-contained with all variables and @theme mapping.`)
+    console.warn(`   📚 See: contents/themes/starter/styles/globals.css for reference`)
+    return false
+  }
+
+  return true
+}
+
 /**
  * Build theme CSS based on active theme
  * @param {string|null} projectRoot - Optional project root path (for NPM mode)
@@ -176,10 +276,6 @@ export async function buildTheme(projectRoot = null) {
 
   const outputDir = path.join(config.projectRoot, '.next')
   const outputPath = path.join(outputDir, 'theme-generated.css')
-  // In npm mode, write to app/theme-styles.css. In source mode, write to core/theme-styles.css
-  const themeStylesPath = config.isNpmMode
-    ? path.join(config.projectRoot, 'app', 'theme-styles.css')
-    : path.join(config.projectRoot, 'core', 'theme-styles.css')
   const themePath = path.join(config.contentsDir, 'themes', activeTheme)
 
   // Ensure output directory exists
@@ -187,24 +283,9 @@ export async function buildTheme(projectRoot = null) {
     fs.mkdirSync(outputDir, { recursive: true })
   }
 
-  // In NPM mode, copy core globals.css to project's app/ directory
-  // This is required because PostCSS processes CSS at project level, not package level
-  if (config.isNpmMode) {
-    const coreGlobalsPath = path.join(config.coreDir, 'globals.css')
-    const appGlobalsPath = path.join(config.projectRoot, 'app', 'globals.css')
-
-    if (fs.existsSync(coreGlobalsPath)) {
-      // Ensure app directory exists
-      const appDir = path.join(config.projectRoot, 'app')
-      if (!fs.existsSync(appDir)) {
-        fs.mkdirSync(appDir, { recursive: true })
-      }
-      fs.copyFileSync(coreGlobalsPath, appGlobalsPath)
-      console.log(`   ✅ Copied core globals.css to app/globals.css`)
-    } else {
-      console.warn(`   ⚠️  Core globals.css not found: ${coreGlobalsPath}`)
-    }
-  }
+  // Sync app/globals.css to import from the active theme
+  // This handles path differences between npm and monorepo modes
+  syncAppGlobalsCss(config, activeTheme)
 
   // Copy theme public assets (for all themes, including default)
   if (fs.existsSync(themePath)) {
@@ -234,7 +315,6 @@ export async function buildTheme(projectRoot = null) {
     // Fallback to empty (core styles only)
     console.log('🔄 Falling back to core styles only')
     fs.writeFileSync(outputPath, `/* Fallback: Theme '${activeTheme}' not found, using core styles */\n`)
-    fs.writeFileSync(themeStylesPath, `/* Fallback: Theme '${activeTheme}' not found, using core styles */\n`)
     return
   }
 
@@ -251,6 +331,9 @@ export async function buildTheme(projectRoot = null) {
     if (fs.existsSync(globalStylesPath)) {
       globalCSS = fs.readFileSync(globalStylesPath, 'utf8')
       console.log(`   ✅ Loaded globals.css (${globalCSS.length} chars)`)
+
+      // Validate that theme has all required sections
+      validateThemeCSS(globalCSS, activeTheme)
     } else {
       console.warn(`   ⚠️  globals.css not found: ${globalStylesPath}`)
     }
@@ -278,13 +361,11 @@ ${globalCSS}
 ${componentCSS}
 `
 
-    // Write final CSS to both locations
+    // Write final CSS to .next directory (for build cache)
     fs.writeFileSync(outputPath, finalCSS)
-    fs.writeFileSync(themeStylesPath, finalCSS)
 
     console.log(`✅ Theme built successfully!`)
     console.log(`📄 Output: ${outputPath} (${finalCSS.length} chars)`)
-    console.log(`📄 Theme styles: ${themeStylesPath} (${finalCSS.length} chars)`)
 
   } catch (error) {
     console.error(`❌ Theme build failed:`, error)
@@ -299,7 +380,6 @@ ${componentCSS}
  */
 `
     fs.writeFileSync(outputPath, errorCSS)
-    fs.writeFileSync(themeStylesPath, errorCSS)
 
     throw error
   }
@@ -344,21 +424,25 @@ async function watchTheme() {
   }
 }
 
-// Main execution
-const watchMode = process.argv.includes('--watch') || process.argv.includes('-w')
+// Main execution - only run when invoked directly, not when imported
+const isMainScript = process.argv[1] && import.meta.url.endsWith(process.argv[1].split('/').pop())
 
-console.log('🎨 Starting theme build process...')
+if (isMainScript) {
+  const watchMode = process.argv.includes('--watch') || process.argv.includes('-w')
 
-try {
-  await buildTheme()
-  console.log('✅ Theme build process completed successfully!')
+  console.log('🎨 Starting theme build process...')
 
-  if (watchMode) {
-    console.log()
-    console.log('👀 Starting watch mode...')
-    await watchTheme()
+  try {
+    await buildTheme()
+    console.log('✅ Theme build process completed successfully!')
+
+    if (watchMode) {
+      console.log()
+      console.log('👀 Starting watch mode...')
+      await watchTheme()
+    }
+  } catch (error) {
+    console.error('❌ Theme build process failed:', error)
+    process.exit(1)
   }
-} catch (error) {
-  console.error('❌ Theme build process failed:', error)
-  process.exit(1)
 }

package/scripts/postinstall.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * @nextsparkjs/core postinstall hook
+ *
+ * Automatically syncs /app folder with core templates when the package is updated.
+ * Only runs in NextSpark projects (not in the monorepo or other contexts).
+ *
+ * Debug mode: Set NEXTSPARK_DEBUG=1 to see detailed logs
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve, isAbsolute } from 'path';
+
+const DEBUG = process.env.NEXTSPARK_DEBUG === '1';
+
+function debug(message) {
+  if (DEBUG) {
+    console.log(`  [DEBUG] ${message}`);
+  }
+}
+
+/**
+ * Find the project root by walking up from the current directory
+ * until we find a package.json that isn't inside node_modules
+ */
+function findProjectRoot() {
+  // When running postinstall, we're in node_modules/@nextsparkjs/core
+  // We need to find the project root (where the user's package.json is)
+  let current = process.cwd();
+
+  // If we're inside node_modules, walk up to find the project root
+  if (current.includes('node_modules')) {
+    // Go up until we're out of node_modules
+    const parts = current.split('node_modules');
+    current = parts[0].replace(/[/\\]$/, ''); // Remove trailing slash
+  }
+
+  return current;
+}
+
+/**
+ * Validate that the project root path is safe to use
+ */
+function validateProjectRoot(projectRoot) {
+  // Must be an absolute path
+  if (!isAbsolute(projectRoot)) {
+    debug(`Invalid path: not absolute - ${projectRoot}`);
+    return false;
+  }
+
+  // Must exist
+  if (!existsSync(projectRoot)) {
+    debug(`Invalid path: does not exist - ${projectRoot}`);
+    return false;
+  }
+
+  // Resolve to canonical path and verify it doesn't escape
+  const resolved = resolve(projectRoot);
+  if (resolved !== projectRoot && !projectRoot.startsWith(resolved)) {
+    debug(`Invalid path: resolution mismatch - ${projectRoot} vs ${resolved}`);
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Detect if we're in a NextSpark project (not the monorepo)
+ */
+function isNextSparkProject(projectRoot) {
+  // If we're in the monorepo, skip
+  const pnpmWorkspace = join(projectRoot, 'pnpm-workspace.yaml');
+  if (existsSync(pnpmWorkspace)) {
+    debug('Skipping: monorepo detected (pnpm-workspace.yaml exists)');
+    return false;
+  }
+
+  // Check for package.json with nextspark dependency
+  const pkgPath = join(projectRoot, 'package.json');
+  if (!existsSync(pkgPath)) {
+    debug('Skipping: no package.json found');
+    return false;
+  }
+
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    const hasNextSpark = !!(deps['@nextsparkjs/core'] || deps['@nextsparkjs/cli']);
+    if (!hasNextSpark) {
+      debug('Skipping: no NextSpark dependencies found');
+    }
+    return hasNextSpark;
+  } catch {
+    debug('Skipping: failed to parse package.json');
+    return false;
+  }
+}
+
+/**
+ * Check if the project has an /app folder (already initialized)
+ */
+function hasAppFolder(projectRoot) {
+  const hasApp = existsSync(join(projectRoot, 'app'));
+  if (!hasApp) {
+    debug('Skipping: no /app folder found (project not initialized)');
+  }
+  return hasApp;
+}
+
+/**
+ * Check if nextspark CLI is available
+ */
+function hasNextsparkCli(projectRoot) {
+  // Check in node_modules/.bin
+  const binPath = join(projectRoot, 'node_modules', '.bin', 'nextspark');
+  const hasCli = existsSync(binPath);
+  if (!hasCli) {
+    debug('Skipping: CLI not yet available (parallel install in progress)');
+  }
+  return hasCli;
+}
+
+// Main execution
+try {
+  const projectRoot = findProjectRoot();
+  debug(`Project root: ${projectRoot}`);
+
+  // Validate project root path
+  if (!validateProjectRoot(projectRoot)) {
+    debug('Skipping: invalid project root path');
+    process.exit(0);
+  }
+
+  // Only run in NextSpark projects with an existing /app folder
+  if (isNextSparkProject(projectRoot) && hasAppFolder(projectRoot)) {
+    console.log('\n  📦 @nextsparkjs/core updated - syncing /app folder...\n');
+
+    // Check if CLI is available
+    if (hasNextsparkCli(projectRoot)) {
+      try {
+        execSync('npx nextspark sync:app --force', {
+          stdio: 'inherit',
+          cwd: projectRoot
+        });
+      } catch (syncError) {
+        console.warn('\n  ⚠️  Auto-sync failed. Run manually: npx nextspark sync:app\n');
+        debug(`Sync error: ${syncError.message}`);
+      }
+    }
+    // If CLI not available, skip silently - this is expected during initial setup
+  }
+} catch (error) {
+  // Postinstall hooks should not break installations
+  // The user can always run the sync manually
+  if (DEBUG) {
+    console.warn('\n  [DEBUG] Postinstall error:', error.message);
+    if (error.stack) {
+      console.warn(error.stack);
+    }
+  }
+}

package/scripts/setup/postinstall.mjs

@@ -9,7 +9,6 @@
  * Generated files:
  * - tsconfig.json (from tsconfig.base.json + dynamic theme exclusions)
  * - core/lib/registries/*.ts (entity, theme, plugin registries)
- * - core/theme-styles.css (compiled theme CSS)
  * - public/theme/* (theme assets)
  *
  * Usage: node core/scripts/setup/postinstall.mjs
@@ -142,7 +141,6 @@ async function setup() {
     console.log('Generated files:')
     console.log('  • tsconfig.json')
     console.log('  • core/lib/registries/*.ts')
-    console.log('  • core/theme-styles.css')
     console.log('  • public/theme/*')
   }
 

package/scripts/test/cy.mjs

@@ -6,11 +6,20 @@
  * Uses NEXT_PUBLIC_ACTIVE_THEME to determine which theme's cypress.config.ts to use.
  *
  * Usage:
- *   pnpm cy:open  - Open Cypress UI
- *   pnpm cy:run   - Run tests headless
+ *   pnpm cy:open                              - Open Cypress UI
+ *   pnpm cy:run                               - Run tests headless
+ *   pnpm cy:run --spec "auth/login.cy.ts"     - Run specific spec (auto-resolves path)
+ *   pnpm cy:run --spec "/auth/login.cy.ts"    - Same with leading slash
+ *   pnpm cy:tags "@smoke"                     - Run tests filtered by tag
  *
- * The script looks for cypress.config.ts at:
- *   contents/themes/{ACTIVE_THEME}/tests/cypress.config.ts
+ * Spec Path Resolution:
+ *   The --spec argument is automatically resolved to the active theme's test directory.
+ *   Instead of: --spec "themes/default/tests/cypress/e2e/auth/login.cy.ts"
+ *   Just use:   --spec "auth/login.cy.ts"
+ *
+ * Supports both:
+ *   - Monorepo mode: themes/{ACTIVE_THEME}/tests/cypress.config.ts
+ *   - NPM mode: contents/themes/{ACTIVE_THEME}/tests/cypress.config.ts
  */
 
 import { spawn, execSync } from 'child_process'
@@ -19,9 +28,30 @@ import { resolve } from 'path'
 import 'dotenv/config'
 
 const theme = process.env.NEXT_PUBLIC_ACTIVE_THEME || 'default'
-const cmd = process.argv[2] || 'open'
+let cmd = process.argv[2] || 'open'
 const port = process.env.PORT || 5173
 
+// Handle 'tags' command - convert to 'run' with grepTags env
+let extraArgs = []
+if (cmd === 'tags') {
+  const tag = process.argv[3]
+  if (!tag) {
+    console.error('\x1b[31mError: Tag argument required\x1b[0m')
+    console.error('Usage: pnpm cy:tags "@smoke"')
+    process.exit(1)
+  }
+  cmd = 'run'
+  extraArgs = ['--env', `grepTags=${tag}`]
+  // Shift remaining args
+  process.argv.splice(3, 1)
+}
+
+// Detect monorepo vs NPM mode
+const monorepoPath = `themes/${theme}/tests/cypress.config.ts`
+const npmPath = `contents/themes/${theme}/tests/cypress.config.ts`
+const isMonorepo = existsSync(resolve(process.cwd(), monorepoPath))
+const isNpmMode = existsSync(resolve(process.cwd(), npmPath))
+
 // Handle 'e2e' command - full test suite with server
 if (cmd === 'e2e') {
   console.log(`\x1b[36m🧪 Running E2E tests for theme: ${theme}\x1b[0m`)
@@ -41,9 +71,67 @@ if (cmd === 'e2e') {
   process.exit(0)
 }
 
-const configPath = `contents/themes/${theme}/tests/cypress.config.ts`
+// Determine config path based on mode
+const configPath = isMonorepo ? monorepoPath : npmPath
 const absoluteConfigPath = resolve(process.cwd(), configPath)
-const allureResultsPath = resolve(process.cwd(), `contents/themes/${theme}/tests/cypress/allure-results`)
+const themesBase = isMonorepo ? 'themes' : 'contents/themes'
+const allureResultsPath = resolve(process.cwd(), `${themesBase}/${theme}/tests/cypress/allure-results`)
+
+// ============================================================================
+// SPEC PATH RESOLUTION
+// ============================================================================
+// Automatically resolve short spec paths to full theme paths
+// Example: "auth/login.cy.ts" -> "themes/default/tests/cypress/e2e/auth/login.cy.ts"
+
+/**
+ * Resolve a spec path to the full theme path
+ * @param {string} specPath - The spec path from --spec argument
+ * @returns {string} - The resolved full path
+ */
+function resolveSpecPath(specPath) {
+  // If path already contains the theme base, return as-is
+  if (specPath.includes(`${themesBase}/${theme}/tests/cypress/e2e/`)) {
+    return specPath
+  }
+
+  // If path starts with full theme path pattern, return as-is
+  if (specPath.startsWith('themes/') || specPath.startsWith('contents/themes/')) {
+    return specPath
+  }
+
+  // Remove leading slash if present
+  const cleanPath = specPath.startsWith('/') ? specPath.slice(1) : specPath
+
+  // Build the full path
+  const fullPath = `${themesBase}/${theme}/tests/cypress/e2e/${cleanPath}`
+
+  return fullPath
+}
+
+/**
+ * Process CLI args and resolve any --spec paths
+ * @param {string[]} args - Original CLI arguments
+ * @returns {string[]} - Processed arguments with resolved spec paths
+ */
+function processSpecArgs(args) {
+  const processed = [...args]
+
+  for (let i = 0; i < processed.length; i++) {
+    if (processed[i] === '--spec' && processed[i + 1]) {
+      const originalSpec = processed[i + 1]
+      const resolvedSpec = resolveSpecPath(originalSpec)
+
+      if (originalSpec !== resolvedSpec) {
+        console.log(`\x1b[33m📂 Spec path resolved:\x1b[0m`)
+        console.log(`   ${originalSpec} → ${resolvedSpec}\n`)
+      }
+
+      processed[i + 1] = resolvedSpec
+    }
+  }
+
+  return processed
+}
 
 // Validate config file exists
 if (!existsSync(absoluteConfigPath)) {
@@ -63,7 +151,9 @@ console.log(`\x1b[36mRunning Cypress for theme: ${theme}\x1b[0m`)
 console.log(`Config: ${configPath}\n`)
 
 // Build args array - include any additional CLI args passed
-const args = ['cypress', cmd, '--config-file', configPath, ...process.argv.slice(3)]
+// Process spec paths to resolve short paths to full theme paths
+const cliArgs = processSpecArgs([...extraArgs, ...process.argv.slice(3)])
+const args = ['cypress', cmd, '--config-file', configPath, ...cliArgs]
 
 const child = spawn('npx', args, {
   stdio: 'inherit',

package/scripts/test/jest-theme.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+/**
+ * Jest Theme Runner
+ *
+ * Cross-platform script to run Jest with theme-specific configuration.
+ * Uses NEXT_PUBLIC_ACTIVE_THEME to determine which theme's jest.config.cjs to use.
+ *
+ * Usage:
+ *   pnpm test:theme                    - Run all theme tests
+ *   pnpm test:theme -- --watch         - Run in watch mode
+ *   pnpm test:theme -- path/to/test    - Run specific test
+ *
+ * Supports both:
+ *   - Monorepo mode: themes/{ACTIVE_THEME}/tests/jest/jest.config.cjs
+ *   - NPM mode: contents/themes/{ACTIVE_THEME}/tests/jest/jest.config.cjs
+ */
+
+import { spawn } from 'child_process'
+import { existsSync } from 'fs'
+import { resolve } from 'path'
+import 'dotenv/config'
+
+const theme = process.env.NEXT_PUBLIC_ACTIVE_THEME || 'default'
+
+// Detect monorepo vs NPM mode
+const monorepoPath = `themes/${theme}/tests/jest/jest.config.cjs`
+const npmPath = `contents/themes/${theme}/tests/jest/jest.config.cjs`
+const isMonorepo = existsSync(resolve(process.cwd(), monorepoPath))
+const isNpmMode = existsSync(resolve(process.cwd(), npmPath))
+
+// Determine config path based on mode
+const configPath = isMonorepo ? monorepoPath : npmPath
+const absoluteConfigPath = resolve(process.cwd(), configPath)
+
+// Validate config file exists
+if (!existsSync(absoluteConfigPath)) {
+  console.error(`\x1b[31mError: Jest config not found for theme "${theme}"\x1b[0m`)
+  console.error(`Expected: ${configPath}`)
+  console.error(`\nMake sure the theme has a tests/jest/jest.config.cjs file.`)
+  process.exit(1)
+}
+
+console.log(`\x1b[36mRunning Jest for theme: ${theme}\x1b[0m`)
+console.log(`Config: ${configPath}\n`)
+
+// Build args array - include any additional CLI args passed
+const cliArgs = process.argv.slice(2)
+const args = ['--config', absoluteConfigPath, ...cliArgs]
+
+// Determine working directory
+// In monorepo: run from packages/core where jest is installed
+// In npm mode: run from project root
+const cwd = isMonorepo
+  ? resolve(process.cwd(), 'packages/core')
+  : process.cwd()
+
+const child = spawn('npx', ['jest', ...args], {
+  stdio: 'inherit',
+  cwd,
+  shell: process.platform === 'win32' // Only use shell on Windows
+})
+
+child.on('close', (code) => {
+  process.exit(code)
+})

package/scripts/utils/file-utils.mjs

@@ -35,21 +35,50 @@ export async function extractExportName(filePath, patterns) {
 /**
  * Extract HTTP methods from a Next.js route.ts file
  *
+ * Supports multiple export patterns:
+ * - export async function GET(...) { }
+ * - export const POST = handler
+ * - export { GET, POST }
+ *
  * @param {string} filePath - Path to the route.ts file
  * @returns {Promise<string[]>} Array of HTTP methods (defaults to ['GET'])
  */
 export async function extractHttpMethods(filePath) {
   try {
     const content = await readFile(filePath, 'utf8')
-    const methods = []
-    const httpMethodRegex = /export\s+async\s+function\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*\(/g
+    const methods = new Set()
+
+    // HTTP method names to search for
+    const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS']
+
+    // Pattern 1: export async function METHOD(...)
+    const funcRegex = /export\s+(?:async\s+)?function\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*\(/g
     let match
+    while ((match = funcRegex.exec(content)) !== null) {
+      methods.add(match[1])
+    }
 
-    while ((match = httpMethodRegex.exec(content)) !== null) {
-      methods.push(match[1])
+    // Pattern 2: export const METHOD = ...
+    const constRegex = /export\s+const\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*=/g
+    while ((match = constRegex.exec(content)) !== null) {
+      methods.add(match[1])
+    }
+
+    // Pattern 3: export { METHOD } or export { METHOD, ... }
+    // Match entire export { ... } block first, then extract methods
+    const namedExportRegex = /export\s*\{([^}]+)\}/g
+    while ((match = namedExportRegex.exec(content)) !== null) {
+      const exportList = match[1]
+      for (const method of HTTP_METHODS) {
+        // Match "METHOD" or "METHOD as something" but not "something as METHOD"
+        const methodPattern = new RegExp(`(?:^|,|\\s)${method}(?:\\s*,|\\s*}|\\s+as\\s|$)`)
+        if (methodPattern.test(exportList)) {
+          methods.add(method)
+        }
+      }
     }
 
-    return methods.length > 0 ? methods : ['GET']
+    return methods.size > 0 ? Array.from(methods) : ['GET']
   } catch {
     return ['GET']
   }