@nextsparkjs/core 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/bin/doctor/checks/imports.ts

@@ -0,0 +1,203 @@
+/**
+ * Imports Health Check
+ *
+ * Verifies that core imports are accessible and not broken.
+ */
+
+import fs from 'fs-extra'
+import path from 'path'
+import type { HealthCheckResult } from '../index.js'
+
+/**
+ * Core NextSpark imports that should be accessible
+ */
+const CORE_IMPORTS = [
+  '@nextsparkjs/core',
+]
+
+/**
+ * Common patterns that indicate broken imports in source files
+ */
+const BROKEN_IMPORT_PATTERNS = [
+  // Non-existent local imports
+  /from ['"]\.\.?\/.+['"]/g,
+]
+
+/**
+ * Check if @nextsparkjs/core is accessible
+ */
+async function checkCorePackage(cwd: string): Promise<{ accessible: boolean; reason?: string }> {
+  const nodeModulesPath = path.join(cwd, 'node_modules', '@nextsparkjs', 'core')
+
+  // Check if the package exists in node_modules
+  if (!await fs.pathExists(nodeModulesPath)) {
+    return { accessible: false, reason: '@nextsparkjs/core not found in node_modules' }
+  }
+
+  // Check if package.json exists
+  const packageJsonPath = path.join(nodeModulesPath, 'package.json')
+  if (!await fs.pathExists(packageJsonPath)) {
+    return { accessible: false, reason: '@nextsparkjs/core package.json not found' }
+  }
+
+  // Check if main entry point exists
+  try {
+    const packageJson = await fs.readJson(packageJsonPath)
+    const mainEntry = packageJson.main || packageJson.module || './dist/index.js'
+    const mainPath = path.join(nodeModulesPath, mainEntry)
+
+    if (!await fs.pathExists(mainPath)) {
+      return { accessible: false, reason: '@nextsparkjs/core entry point not found' }
+    }
+  } catch {
+    return { accessible: false, reason: 'Failed to read @nextsparkjs/core package.json' }
+  }
+
+  return { accessible: true }
+}
+
+/**
+ * Scan source files for potentially broken imports
+ */
+async function scanForBrokenImports(cwd: string): Promise<string[]> {
+  const brokenImports: string[] = []
+
+  // Common source directories to scan
+  const srcDirs = ['src', 'app', 'pages', 'components', 'lib']
+  const existingDirs: string[] = []
+
+  for (const dir of srcDirs) {
+    const dirPath = path.join(cwd, dir)
+    if (await fs.pathExists(dirPath)) {
+      existingDirs.push(dirPath)
+    }
+  }
+
+  // Scan each directory for .ts/.tsx files (limited to prevent performance issues)
+  const maxFilesToScan = 50
+  let filesScanned = 0
+
+  for (const dir of existingDirs) {
+    if (filesScanned >= maxFilesToScan) break
+
+    try {
+      const files = await fs.readdir(dir, { withFileTypes: true })
+
+      for (const file of files) {
+        if (filesScanned >= maxFilesToScan) break
+
+        if (file.isFile() && (file.name.endsWith('.ts') || file.name.endsWith('.tsx'))) {
+          const filePath = path.join(dir, file.name)
+          try {
+            const content = await fs.readFile(filePath, 'utf-8')
+
+            // Check for imports from non-existent paths
+            const importMatches = content.match(/from ['"](@?[^'"]+)['"]/g)
+            if (importMatches) {
+              for (const match of importMatches) {
+                const importPath = match.replace(/from ['"]/g, '').replace(/['"]/g, '')
+
+                // Only check local imports
+                if (importPath.startsWith('.')) {
+                  const absoluteImportPath = path.resolve(path.dirname(filePath), importPath)
+
+                  // Check for .ts, .tsx, .js, .jsx extensions and index files
+                  const possiblePaths = [
+                    absoluteImportPath,
+                    `${absoluteImportPath}.ts`,
+                    `${absoluteImportPath}.tsx`,
+                    `${absoluteImportPath}.js`,
+                    `${absoluteImportPath}.jsx`,
+                    path.join(absoluteImportPath, 'index.ts'),
+                    path.join(absoluteImportPath, 'index.tsx'),
+                    path.join(absoluteImportPath, 'index.js'),
+                  ]
+
+                  const exists = await Promise.any(
+                    possiblePaths.map(async p => {
+                      if (await fs.pathExists(p)) return true
+                      throw new Error('Not found')
+                    })
+                  ).catch(() => false)
+
+                  if (!exists) {
+                    brokenImports.push(`${file.name}: ${importPath}`)
+                  }
+                }
+              }
+            }
+
+            filesScanned++
+          } catch {
+            // Skip files that can't be read
+          }
+        }
+      }
+    } catch {
+      // Skip directories that can't be read
+    }
+  }
+
+  return brokenImports
+}
+
+/**
+ * Check for broken imports in the project
+ */
+export async function checkImports(): Promise<HealthCheckResult> {
+  const cwd = process.cwd()
+
+  // Check if @nextsparkjs/core is accessible
+  const coreCheck = await checkCorePackage(cwd)
+
+  if (!coreCheck.accessible) {
+    // Only warn if package.json lists it as a dependency
+    const packageJsonPath = path.join(cwd, 'package.json')
+    let hasCoreDep = false
+
+    if (await fs.pathExists(packageJsonPath)) {
+      try {
+        const packageJson = await fs.readJson(packageJsonPath)
+        hasCoreDep = !!(packageJson.dependencies?.['@nextsparkjs/core'] ||
+                       packageJson.devDependencies?.['@nextsparkjs/core'])
+      } catch {
+        // Ignore
+      }
+    }
+
+    if (hasCoreDep) {
+      return {
+        name: 'Imports',
+        status: 'fail',
+        message: coreCheck.reason || '@nextsparkjs/core not accessible',
+        fix: 'Run: pnpm install',
+      }
+    }
+  }
+
+  // Scan for broken local imports (quick check)
+  try {
+    const brokenImports = await scanForBrokenImports(cwd)
+
+    if (brokenImports.length > 0) {
+      const displayImports = brokenImports.slice(0, 3).join(', ')
+      const remaining = brokenImports.length > 3 ? ` (+${brokenImports.length - 3} more)` : ''
+
+      return {
+        name: 'Imports',
+        status: 'warn',
+        message: `Potentially broken imports: ${displayImports}${remaining}`,
+        fix: 'Check the import paths in the mentioned files',
+      }
+    }
+  } catch {
+    // If scanning fails, we still consider it a pass
+    // since it might be a permissions issue
+  }
+
+  return {
+    name: 'Imports',
+    status: 'pass',
+    message: 'No broken imports found',
+  }
+}

package/dist/bin/doctor/index.ts

@@ -0,0 +1,151 @@
+/**
+ * NextSpark Health Check Command (Doctor)
+ *
+ * Runs a comprehensive health check on a NextSpark project
+ * to identify configuration issues, missing dependencies,
+ * and other potential problems.
+ *
+ * Usage:
+ *   npx nextspark doctor
+ */
+
+import chalk from 'chalk'
+import { checkDependencies } from './checks/dependencies.js'
+import { checkConfigs } from './checks/config.js'
+import { checkDatabase } from './checks/database.js'
+import { checkImports } from './checks/imports.js'
+
+/**
+ * Result of a health check
+ */
+export interface HealthCheckResult {
+  /** Name of the check */
+  name: string
+  /** Status of the check */
+  status: 'pass' | 'warn' | 'fail'
+  /** Human-readable message */
+  message: string
+  /** Suggested fix for warnings/failures */
+  fix?: string
+}
+
+/**
+ * Status icons for display
+ */
+const STATUS_ICONS = {
+  pass: chalk.green('\u2713'),
+  warn: chalk.yellow('\u26A0'),
+  fail: chalk.red('\u2717'),
+} as const
+
+/**
+ * Format a health check result for console output
+ */
+function formatResult(result: HealthCheckResult): string {
+  const icon = STATUS_ICONS[result.status]
+  const nameColor = result.status === 'fail' ? chalk.red : result.status === 'warn' ? chalk.yellow : chalk.white
+  const name = nameColor(result.name.padEnd(18))
+  const message = chalk.gray(result.message)
+
+  let output = `${icon} ${name} ${message}`
+
+  // Add fix suggestion on a new line for warnings and failures
+  if (result.fix && result.status !== 'pass') {
+    output += `\n${' '.repeat(22)}${chalk.cyan('\u2192')} ${chalk.cyan(result.fix)}`
+  }
+
+  return output
+}
+
+/**
+ * Display the health check header
+ */
+function showHeader(): void {
+  console.log('')
+  console.log(chalk.cyan('\uD83E\uDE7A NextSpark Health Check'))
+  console.log('')
+}
+
+/**
+ * Display the health check summary
+ */
+function showSummary(results: HealthCheckResult[]): void {
+  const passed = results.filter(r => r.status === 'pass').length
+  const warnings = results.filter(r => r.status === 'warn').length
+  const failed = results.filter(r => r.status === 'fail').length
+
+  console.log('')
+  console.log(chalk.gray('-'.repeat(50)))
+
+  const summary = [
+    chalk.green(`${passed} passed`),
+    warnings > 0 ? chalk.yellow(`${warnings} warning${warnings > 1 ? 's' : ''}`) : null,
+    failed > 0 ? chalk.red(`${failed} failed`) : null,
+  ].filter(Boolean).join(', ')
+
+  console.log(`Summary: ${summary}`)
+  console.log('')
+
+  // Exit code based on results
+  if (failed > 0) {
+    process.exitCode = 1
+  }
+}
+
+/**
+ * Run all health checks and return the results
+ */
+export async function runHealthCheck(): Promise<HealthCheckResult[]> {
+  const results: HealthCheckResult[] = []
+
+  // Run checks in sequence
+  const checks = [
+    { name: 'Dependencies', fn: checkDependencies },
+    { name: 'Configuration', fn: checkConfigs },
+    { name: 'Database', fn: checkDatabase },
+    { name: 'Imports', fn: checkImports },
+  ]
+
+  for (const check of checks) {
+    try {
+      const result = await check.fn()
+      results.push(result)
+    } catch (error) {
+      results.push({
+        name: check.name,
+        status: 'fail',
+        message: error instanceof Error ? error.message : 'Unknown error occurred',
+        fix: 'Check the error message and try again',
+      })
+    }
+  }
+
+  return results
+}
+
+/**
+ * Run the health check command with formatted output
+ */
+export async function runDoctorCommand(): Promise<void> {
+  showHeader()
+
+  const results = await runHealthCheck()
+
+  // Display each result
+  for (const result of results) {
+    console.log(formatResult(result))
+  }
+
+  showSummary(results)
+}
+
+// Run if executed directly
+const isDirectExecution = process.argv[1]?.includes('doctor') ||
+                          process.argv.includes('doctor')
+
+if (isDirectExecution && typeof require !== 'undefined') {
+  runDoctorCommand().catch((error: Error) => {
+    console.error(chalk.red('An unexpected error occurred:'), error.message)
+    process.exit(1)
+  })
+}