create-fluxstack 1.4.1 → 1.5.0

package/core/plugins/dependency-manager.ts

@@ -136,6 +136,8 @@ export class PluginDependencyManager {
 
   /**
    * Instalar dependências de plugins
+   * NOVA ESTRATÉGIA: Instala no node_modules local do plugin primeiro,
+   * com fallback para o projeto principal
    */
   async installPluginDependencies(resolutions: DependencyResolution[]): Promise<void> {
     if (!this.config.autoInstall) {
@@ -143,44 +145,109 @@ export class PluginDependencyManager {
       return
     }
 
-    const toInstall: PluginDependency[] = []
-    const conflicts: DependencyConflict[] = []
-
-    // Coletar todas as dependências e conflitos
+    // Instalar dependências para cada plugin individualmente
     for (const resolution of resolutions) {
-      toInstall.push(...resolution.dependencies)
-      conflicts.push(...resolution.conflicts)
-    }
+      if (resolution.dependencies.length === 0) continue
+
+      const pluginPath = this.findPluginDirectory(resolution.plugin)
+      if (!pluginPath) {
+        this.logger?.warn(`Não foi possível encontrar diretório do plugin '${resolution.plugin}'`)
+        continue
+      }
 
-    // Resolver conflitos primeiro
-    if (conflicts.length > 0) {
-      await this.resolveConflicts(conflicts)
+      this.logger?.debug(`📦 Instalando dependências localmente para plugin '${resolution.plugin}'`, {
+        plugin: resolution.plugin,
+        path: pluginPath,
+        dependencies: resolution.dependencies.length
+      })
+
+      try {
+        // Instalar APENAS no node_modules local do plugin
+        await this.installPluginDependenciesLocally(pluginPath, resolution.dependencies)
+
+        this.logger?.debug(`✅ Dependências do plugin '${resolution.plugin}' instaladas localmente`)
+      } catch (error) {
+        this.logger?.error(`❌ Erro ao instalar dependências do plugin '${resolution.plugin}'`, { error })
+        // Continuar com outros plugins
+      }
     }
+  }
+
+  /**
+   * Instalar dependências no diretório local do plugin
+   */
+  private async installPluginDependenciesLocally(pluginPath: string, dependencies: PluginDependency[]): Promise<void> {
+    if (dependencies.length === 0) return
+
+    const regularDeps = dependencies.filter(d => d.type === 'dependency')
+    const peerDeps = dependencies.filter(d => d.type === 'peerDependency' && !d.optional)
+
+    const allDeps = [...regularDeps, ...peerDeps]
+    if (allDeps.length === 0) return
 
-    // Filtrar dependências que já estão instaladas
-    const needsInstallation = toInstall.filter(dep => {
-      const installed = this.installedDependencies.get(dep.name)
-      return !installed || !this.isVersionCompatible(installed, dep.version)
+    // Verificar quais dependências já estão instaladas localmente
+    const toInstall = allDeps.filter(dep => {
+      const depPath = join(pluginPath, 'node_modules', dep.name, 'package.json')
+      if (!existsSync(depPath)) {
+        return true // Precisa instalar
+      }
+
+      try {
+        const installedPkg = JSON.parse(readFileSync(depPath, 'utf-8'))
+        const installedVersion = installedPkg.version
+
+        // Verificar se a versão é compatível
+        if (!this.isVersionCompatible(installedVersion, dep.version)) {
+          this.logger?.debug(`📦 Dependência '${dep.name}' está desatualizada (${installedVersion} → ${dep.version})`)
+          return true // Precisa atualizar
+        }
+
+        return false // Já está instalado corretamente
+      } catch (error) {
+        return true // Erro ao ler, melhor reinstalar
+      }
     })
 
-    if (needsInstallation.length === 0) {
-      this.logger?.debug('Todas as dependências de plugins já estão instaladas')
+    if (toInstall.length === 0) {
+      this.logger?.debug(`✅ Todas as dependências do plugin já estão instaladas`)
       return
     }
 
-    this.logger?.debug(`Instalando ${needsInstallation.length} dependências de plugins`, {
-      dependencies: needsInstallation.map(d => `${d.name}@${d.version}`)
-    })
+    const packages = toInstall.map(d => `${d.name}@${d.version}`).join(' ')
+    const command = this.getInstallCommand(packages, false)
+
+    this.logger?.debug(`🔧 Instalando ${toInstall.length} dependência(s): ${command}`, { cwd: pluginPath })
 
     try {
-      await this.installDependencies(needsInstallation)
-      this.logger?.debug('Dependências de plugins instaladas com sucesso')
+      execSync(command, {
+        cwd: pluginPath,
+        stdio: 'inherit'
+      })
+      this.logger?.debug(`✅ Pacotes instalados localmente em ${pluginPath}`)
     } catch (error) {
-      this.logger?.error('Erro ao instalar dependências de plugins', { error })
+      this.logger?.error(`❌ Falha ao instalar dependências localmente`, { error, pluginPath })
       throw error
     }
   }
 
+  /**
+   * Encontrar diretório de um plugin pelo nome
+   */
+  private findPluginDirectory(pluginName: string): string | null {
+    const possiblePaths = [
+      `plugins/${pluginName}`,
+      `core/plugins/built-in/${pluginName}`
+    ]
+
+    for (const path of possiblePaths) {
+      if (existsSync(path)) {
+        return resolve(path)
+      }
+    }
+
+    return null
+  }
+
   /**
    * Detectar conflitos de versão
    */

package/core/plugins/index.ts

@@ -54,6 +54,10 @@ export {
 } from './manager'
 export type { PluginManagerConfig } from './manager'
 
+// Module resolver for plugins
+export { PluginModuleResolver } from './module-resolver'
+export type { ModuleResolverConfig } from './module-resolver'
+
 // Plugin executor
 export {
     PluginExecutor,

package/core/plugins/manager.ts

@@ -19,7 +19,7 @@ import type {
 
 type Plugin = FluxStack.Plugin
 import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger/index"
+import type { Logger } from "../utils/logger"
 import { PluginRegistry } from "./registry"
 import { createPluginUtils } from "./config"
 import { FluxStackError } from "../utils/errors"
@@ -422,6 +422,7 @@ export class PluginManager extends EventEmitter {
       // Try to use auto-generated registry for external plugins (if available from build)
       let externalResults: any[] = []
       try {
+        // @ts-expect-error - auto-registry is generated during build, may not exist in dev
         const autoRegistryModule = await import('./auto-registry')
         if (autoRegistryModule.discoveredPlugins && autoRegistryModule.registerDiscoveredPlugins) {
           this.logger.debug('🚀 Using auto-generated external plugins registry')
@@ -432,7 +433,7 @@ export class PluginManager extends EventEmitter {
           }))
         }
       } catch (error) {
-        this.logger.debug('Auto-generated external plugins registry not found, falling back to discovery', { error: error.message })
+        this.logger.debug('Auto-generated external plugins registry not found, falling back to discovery', { error: (error as Error).message })
 
         // Fallback to runtime discovery for external plugins
         this.logger.debug('Discovering external plugins in directory: plugins')

package/core/plugins/module-resolver.ts

@@ -0,0 +1,216 @@
+/**
+ * Module Resolver para Plugins
+ * Implementa resolução em cascata: plugin local → projeto principal
+ */
+
+import { existsSync } from 'fs'
+import { join, resolve } from 'path'
+import type { Logger } from '../utils/logger'
+
+export interface ModuleResolverConfig {
+  projectRoot: string
+  logger?: Logger
+}
+
+export class PluginModuleResolver {
+  private config: ModuleResolverConfig
+  private logger?: Logger
+  private resolveCache: Map<string, string> = new Map()
+
+  constructor(config: ModuleResolverConfig) {
+    this.config = config
+    this.logger = config.logger
+  }
+
+  /**
+   * Resolve um módulo com estratégia em cascata:
+   * 1. node_modules local do plugin
+   * 2. node_modules do projeto principal
+   */
+  resolveModule(moduleName: string, pluginPath: string): string | null {
+    const cacheKey = `${pluginPath}::${moduleName}`
+
+    // Verificar cache
+    if (this.resolveCache.has(cacheKey)) {
+      return this.resolveCache.get(cacheKey)!
+    }
+
+    this.logger?.debug(`Resolvendo módulo '${moduleName}' para plugin em '${pluginPath}'`)
+
+    // 1. Tentar no node_modules local do plugin
+    const localPath = this.tryResolveLocal(moduleName, pluginPath)
+    if (localPath) {
+      this.logger?.debug(`✅ Módulo '${moduleName}' encontrado localmente: ${localPath}`)
+      this.resolveCache.set(cacheKey, localPath)
+      return localPath
+    }
+
+    // 2. Tentar no node_modules do projeto principal
+    const projectPath = this.tryResolveProject(moduleName)
+    if (projectPath) {
+      this.logger?.debug(`✅ Módulo '${moduleName}' encontrado no projeto: ${projectPath}`)
+      this.resolveCache.set(cacheKey, projectPath)
+      return projectPath
+    }
+
+    this.logger?.warn(`❌ Módulo '${moduleName}' não encontrado em nenhum contexto`)
+    return null
+  }
+
+  /**
+   * Tenta resolver no node_modules local do plugin
+   */
+  private tryResolveLocal(moduleName: string, pluginPath: string): string | null {
+    const pluginDir = resolve(pluginPath)
+    const localNodeModules = join(pluginDir, 'node_modules', moduleName)
+
+    if (existsSync(localNodeModules)) {
+      // Verificar se tem package.json para pegar o entry point
+      const packageJsonPath = join(localNodeModules, 'package.json')
+      if (existsSync(packageJsonPath)) {
+        try {
+          const pkg = require(packageJsonPath)
+          const entry = pkg.module || pkg.main || 'index.js'
+          const entryPath = join(localNodeModules, entry)
+
+          if (existsSync(entryPath)) {
+            return entryPath
+          }
+        } catch (error) {
+          this.logger?.debug(`Erro ao ler package.json de '${moduleName}'`, { error })
+        }
+      }
+
+      // Fallback: tentar index.js/index.ts
+      const indexJs = join(localNodeModules, 'index.js')
+      const indexTs = join(localNodeModules, 'index.ts')
+
+      if (existsSync(indexJs)) return indexJs
+      if (existsSync(indexTs)) return indexTs
+
+      return localNodeModules
+    }
+
+    return null
+  }
+
+  /**
+   * Tenta resolver no node_modules do projeto principal
+   */
+  private tryResolveProject(moduleName: string): string | null {
+    const projectNodeModules = join(this.config.projectRoot, 'node_modules', moduleName)
+
+    if (existsSync(projectNodeModules)) {
+      // Verificar se tem package.json para pegar o entry point
+      const packageJsonPath = join(projectNodeModules, 'package.json')
+      if (existsSync(packageJsonPath)) {
+        try {
+          const pkg = require(packageJsonPath)
+          const entry = pkg.module || pkg.main || 'index.js'
+          const entryPath = join(projectNodeModules, entry)
+
+          if (existsSync(entryPath)) {
+            return entryPath
+          }
+        } catch (error) {
+          this.logger?.debug(`Erro ao ler package.json de '${moduleName}'`, { error })
+        }
+      }
+
+      // Fallback: tentar index.js/index.ts
+      const indexJs = join(projectNodeModules, 'index.js')
+      const indexTs = join(projectNodeModules, 'index.ts')
+
+      if (existsSync(indexJs)) return indexJs
+      if (existsSync(indexTs)) return indexTs
+
+      return projectNodeModules
+    }
+
+    return null
+  }
+
+  /**
+   * Resolve sub-paths (ex: @noble/curves/ed25519)
+   */
+  resolveSubpath(moduleName: string, subpath: string, pluginPath: string): string | null {
+    const fullModule = `${moduleName}/${subpath}`
+    const cacheKey = `${pluginPath}::${fullModule}`
+
+    // Verificar cache
+    if (this.resolveCache.has(cacheKey)) {
+      return this.resolveCache.get(cacheKey)!
+    }
+
+    this.logger?.debug(`Resolvendo subpath '${fullModule}' para plugin em '${pluginPath}'`)
+
+    // 1. Tentar no node_modules local do plugin
+    const pluginDir = resolve(pluginPath)
+    const localPath = join(pluginDir, 'node_modules', fullModule)
+
+    if (this.existsWithExtension(localPath)) {
+      const resolvedLocal = this.findFileWithExtension(localPath)
+      if (resolvedLocal) {
+        this.logger?.debug(`✅ Subpath '${fullModule}' encontrado localmente: ${resolvedLocal}`)
+        this.resolveCache.set(cacheKey, resolvedLocal)
+        return resolvedLocal
+      }
+    }
+
+    // 2. Tentar no node_modules do projeto principal
+    const projectPath = join(this.config.projectRoot, 'node_modules', fullModule)
+
+    if (this.existsWithExtension(projectPath)) {
+      const resolvedProject = this.findFileWithExtension(projectPath)
+      if (resolvedProject) {
+        this.logger?.debug(`✅ Subpath '${fullModule}' encontrado no projeto: ${resolvedProject}`)
+        this.resolveCache.set(cacheKey, resolvedProject)
+        return resolvedProject
+      }
+    }
+
+    this.logger?.warn(`❌ Subpath '${fullModule}' não encontrado em nenhum contexto`)
+    return null
+  }
+
+  /**
+   * Verifica se arquivo existe com alguma extensão comum
+   */
+  private existsWithExtension(basePath: string): boolean {
+    const extensions = ['', '.js', '.ts', '.mjs', '.cjs', '.jsx', '.tsx', '/index.js', '/index.ts']
+    return extensions.some(ext => existsSync(basePath + ext))
+  }
+
+  /**
+   * Encontra arquivo com extensão
+   */
+  private findFileWithExtension(basePath: string): string | null {
+    const extensions = ['', '.js', '.ts', '.mjs', '.cjs', '.jsx', '.tsx', '/index.js', '/index.ts']
+
+    for (const ext of extensions) {
+      const fullPath = basePath + ext
+      if (existsSync(fullPath)) {
+        return fullPath
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Limpar cache
+   */
+  clearCache(): void {
+    this.resolveCache.clear()
+  }
+
+  /**
+   * Obter estatísticas
+   */
+  getStats() {
+    return {
+      cachedModules: this.resolveCache.size,
+      projectRoot: this.config.projectRoot
+    }
+  }
+}

package/core/plugins/registry.ts

@@ -2,7 +2,7 @@ import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOption
 
 type FluxStackPlugin = FluxStack.Plugin
 import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger/index"
+import type { Logger } from "../utils/logger"
 import { FluxStackError } from "../utils/errors"
 import { PluginDependencyManager } from "./dependency-manager"
 import { readdir, readFile } from "fs/promises"
@@ -262,6 +262,33 @@ export class PluginRegistry {
       if (existsSync(manifestPath)) {
         const manifestContent = await readFile(manifestPath, 'utf-8')
         manifest = JSON.parse(manifestContent)
+      } else {
+        // Try package.json for npm plugins
+        const packagePath = join(pluginPath, 'package.json')
+        if (existsSync(packagePath)) {
+          try {
+            const packageContent = await readFile(packagePath, 'utf-8')
+            const packageJson = JSON.parse(packageContent)
+
+            if (packageJson.fluxstack) {
+              manifest = {
+                name: packageJson.name,
+                version: packageJson.version,
+                description: packageJson.description || '',
+                author: packageJson.author || '',
+                license: packageJson.license || '',
+                homepage: packageJson.homepage,
+                repository: packageJson.repository,
+                keywords: packageJson.keywords || [],
+                dependencies: packageJson.dependencies || {},
+                peerDependencies: packageJson.peerDependencies,
+                fluxstack: packageJson.fluxstack
+              }
+            }
+          } catch (error) {
+            this.logger?.warn(`Failed to parse package.json in '${pluginPath}'`, { error })
+          }
+        }
       }
 
       // Try to import the plugin

package/core/utils/logger/index.ts

@@ -23,6 +23,10 @@ export { clearColorCache } from './colors'
 export { clearCallerCache } from './stack-trace'
 export { clearLoggerCache } from './winston-logger'
 
+// Export Logger type from winston
+import type winston from 'winston'
+export type Logger = winston.Logger
+
 // Re-export banner utilities for custom banners
 export { displayStartupBanner, type StartupInfo } from './startup-banner'