nex-framework-cli 1.0.19 → 1.0.21

package/cli/nex-cli.js

@@ -28,7 +28,7 @@ program.configureHelp({
 program
   .name('nex')
   .description('NEX Framework - Framework completo de agentes AI')
-      .version('1.0.18', '-v, --version', 'Mostra a versão')
+      .version('1.0.20', '-v, --version', 'Mostra a versão')
   .addHelpText('before', chalk.bold.cyan(`
 ╔════════════════════════════════════════════════════════════════╗
 ║              NEX Framework - CLI v1.0.9                        ║
@@ -64,12 +64,26 @@ Exemplos:
     console.log(chalk.blue('🚀 Inicializando projeto NEX...'))
     console.log()
     
+    // Detectar nome do projeto atual (da pasta ou package.json)
+    let currentProjectName = path.basename(process.cwd())
+    try {
+      const packageJsonPath = path.join(process.cwd(), 'package.json')
+      if (await fs.pathExists(packageJsonPath)) {
+        const packageJson = await fs.readJSON(packageJsonPath)
+        if (packageJson.name) {
+          currentProjectName = packageJson.name
+        }
+      }
+    } catch (error) {
+      // Ignore errors
+    }
+    
     const answers = await inquirer.prompt([
       {
         type: 'input',
         name: 'projectName',
         message: 'Nome do projeto:',
-        default: options.name || 'nex-project',
+        default: options.name || currentProjectName,
         when: !options.name
       },
       {
@@ -85,10 +99,10 @@ Exemplos:
     const projectName = options.name || answers.projectName
     const template = options.template || answers.template
 
-    // Criar estrutura do projeto (sem config, usa global)
-    await createProjectStructure(projectName, template)
+    // Criar estrutura do projeto no diretório atual (não criar nova pasta)
+    await createProjectStructure(projectName, template, true)
     
-    console.log(chalk.green(`\n✅ Projeto ${projectName} criado com sucesso!`))
+    console.log(chalk.green(`\n✅ Projeto ${projectName} inicializado com sucesso!`))
     console.log()
   })
 
@@ -351,7 +365,7 @@ configCmd
   .description('Reconfigura o NEX CLI (nome, idiomas, integração Cursor)')
   .action(async () => {
     const { runSetup } = await import('../scripts/postinstall.js')
-    await runSetup()
+    await runSetup(true) // Force reconfiguration
   })
 
 configCmd
@@ -376,8 +390,8 @@ configCmd
   })
 
 // Funções auxiliares
-async function createProjectStructure(projectName, template) {
-  const projectDir = path.join(process.cwd(), projectName)
+async function createProjectStructure(projectName, template, useCurrentDir = false) {
+  const projectDir = useCurrentDir ? process.cwd() : path.join(process.cwd(), projectName)
   await fs.ensureDir(projectDir)
 
   // Criar estrutura básica

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nex-framework-cli",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "NEX CLI - Command-line interface for NEX Framework and Agent Marketplace",
   "type": "module",
   "main": "cli/nex-cli.js",

package/scripts/postinstall.js

@@ -27,20 +27,30 @@ export function getGlobalConfigPath() {
   }
 }
 
-export async function runSetup() {
+export async function runSetup(force = false) {
   // Check if config already exists
   const configPath = getGlobalConfigPath()
   const configDir = path.dirname(configPath)
   
-  if (await fs.pathExists(configPath)) {
+  if (!force && await fs.pathExists(configPath)) {
     try {
       const existingConfig = await fs.readJSON(configPath)
-      // If config exists and is valid, skip setup
+      // If config exists and is valid, ask if user wants to reconfigure
       if (existingConfig.user && existingConfig.user.name) {
-        console.log(chalk.green('\n✅ NEX CLI já está configurado!'))
-        console.log(chalk.gray(`   Config: ${configPath}`))
-        console.log(chalk.gray(`   Para reconfigurar, delete o arquivo ou execute: nex config reset\n`))
-        return
+        const { overwrite } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'overwrite',
+            message: 'NEX CLI já está configurado. Deseja reconfigurar?',
+            default: false
+          }
+        ])
+        
+        if (!overwrite) {
+          console.log(chalk.green('\n✅ Configuração mantida.'))
+          console.log(chalk.gray(`   Config: ${configPath}\n`))
+          return
+        }
       }
     } catch (error) {
       // Config file exists but is invalid, continue with setup
@@ -106,7 +116,7 @@ export async function runSetup() {
       enabled: answers.cursorIntegration
     },
     installedAt: new Date().toISOString(),
-    version: '1.0.18'
+    version: '1.0.20'
   }
   
   // Save config
@@ -152,7 +162,7 @@ if (!isCI && !skipSetup && isInteractive) {
       enabled: false
     },
     installedAt: new Date().toISOString(),
-    version: '1.0.18'
+    version: '1.0.20'
   }
   
   fs.ensureDir(configDir)

package/src/services/nex-marketplace/NEXMarketplace.js

@@ -1021,99 +1021,103 @@ export default class NEXMarketplace {
   }
 
   /**
-   * Integrate BMAD agent with Cursor
+   * Integrate BMAD agent with Cursor (following BMAD pattern)
+   * Creates .mdc files in .cursor/rules/nex/ similar to BMAD
    */
   async integrateWithCursor(agentId, manifest, sourcePath) {
     try {
-      const rulesFile = manifest.bmad?.rules_file
-      if (!rulesFile) {
-        return // No rules file specified
+      // Get global config for user info
+      const globalConfig = this.getGlobalConfig()
+      const userConfig = globalConfig.user || {}
+      
+      // Create NEX core config directory (similar to BMAD)
+      const nexCoreDir = path.join(this.projectRoot, 'nex', 'core')
+      await fs.ensureDir(nexCoreDir)
+      
+      // Create config.yaml (similar to BMAD)
+      const configYaml = {
+        user_name: userConfig.name || 'Developer',
+        communication_language: userConfig.conversationLanguage || 'pt-br',
+        document_output_language: userConfig.documentLanguage || 'pt-br',
+        output_folder: '{project-root}/docs'
       }
       
-      // Path to .cursorrules file in agent directory
-      let agentRulesPath = path.join(sourcePath, rulesFile)
-      
-      // Check if rules file exists
-      if (!await fs.pathExists(agentRulesPath)) {
-        // Try alternative locations
-        const alternativePaths = [
-          path.join(sourcePath, '..', rulesFile), // Parent directory
-          path.join(this.registryPath, manifest.category || 'bmad', agentId, rulesFile), // Registry root
-          path.join(this.registryPath, 'bmad', agentId, rulesFile) // BMAD category
-        ]
-        
-        let foundPath = null
-        for (const altPath of alternativePaths) {
-          if (await fs.pathExists(altPath)) {
-            foundPath = altPath
-            break
-          }
+      const configPath = path.join(nexCoreDir, 'config.yaml')
+      if (!await fs.pathExists(configPath)) {
+        const configYamlContent = yaml.stringify(configYaml)
+        await fs.writeFile(configPath, configYamlContent, 'utf8')
+      }
+      
+      // Create .cursor/rules/nex directory structure (following BMAD pattern)
+      const cursorRulesDir = path.join(this.projectRoot, '.cursor', 'rules', 'nex')
+      const agentCategory = manifest.category || 'bmad'
+      const agentRulesDir = path.join(cursorRulesDir, agentCategory, 'agents')
+      await fs.ensureDir(agentRulesDir)
+      
+      // Check if agent has a README.md or similar file to convert to .mdc
+      let agentContent = ''
+      const possibleAgentFiles = [
+        path.join(sourcePath, 'README.md'),
+        path.join(sourcePath, `${agentId}.md`),
+        path.join(sourcePath, 'agent.md')
+      ]
+      
+      let agentFile = null
+      for (const filePath of possibleAgentFiles) {
+        if (await fs.pathExists(filePath)) {
+          agentFile = filePath
+          agentContent = await fs.readFile(filePath, 'utf8')
+          break
         }
-        
-        if (!foundPath) {
-          // Create a basic .cursorrules file from manifest
-          const trigger = manifest.bmad?.activation_trigger || `@${agentId}`
-          const basicRules = `# ${manifest.name}
-# ${manifest.tagline || manifest.description?.substring(0, 100)}
+      }
+      
+      // If no agent file found, create one from manifest
+      if (!agentFile) {
+        const trigger = manifest.bmad?.activation_trigger || `@${agentId}`
+        agentContent = `# ${manifest.name}
+
+${manifest.tagline || manifest.description || ''}
+
+## Activation
+
+Use \`${trigger}\` in Cursor to activate this agent.
+
+## Description
+
+${manifest.long_description || manifest.description || 'NEX Agent'}
 
-# Activation: ${trigger}
+## Usage
 
-# ${manifest.name} - ${manifest.description || 'BMAD Expert Agent'}
+\`\`\`
+${trigger} <command>
+\`\`\`
 
-# Usage in Cursor:
-# ${trigger} <command>
+## Examples
 
-# Example:
-# ${trigger} analyze-page https://example.com
+${trigger} analyze-page https://example.com
 `
-          
-          // Write basic rules file to agent directory
-          await fs.writeFile(agentRulesPath, basicRules, 'utf8')
-          console.log(chalk.cyan(`\n📝 Created basic Cursor rules file: ${rulesFile}`))
-        } else {
-          agentRulesPath = foundPath
-        }
-      }
-      
-      // Create .cursorrules directory in project (for storing individual agent rules)
-      const cursorRulesDir = path.join(this.projectRoot, '.cursorrules')
-      await fs.ensureDir(cursorRulesDir)
-      
-      // Copy rules file to .cursorrules directory
-      const targetRulesPath = path.join(cursorRulesDir, rulesFile)
-      await fs.copy(agentRulesPath, targetRulesPath)
-      
-      // Update main .cursorrules file (in project root)
-      const mainCursorRulesPath = path.join(this.projectRoot, '.cursorrules')
-      const importLine = `import .cursorrules/${rulesFile}`
-      const commentLine = `# ${manifest.name} - ${manifest.tagline || manifest.description?.substring(0, 50)}`
-      const trigger = manifest.bmad?.activation_trigger || `@${agentId}`
-      const agentComment = `# Use: ${trigger} <command>`
-      
-      let cursorRulesContent = ''
-      if (await fs.pathExists(mainCursorRulesPath)) {
-        cursorRulesContent = await fs.readFile(mainCursorRulesPath, 'utf8')
       }
       
-      // Check if already imported
-      if (cursorRulesContent.includes(importLine) || cursorRulesContent.includes(rulesFile)) {
-        // Already integrated, skip
-        return
-      }
+      // Convert to .mdc format (similar to BMAD)
+      const mdcContent = `---
+description: ${manifest.name} - ${manifest.tagline || manifest.description?.substring(0, 100) || 'NEX Agent'}
+globs: 
+alwaysApply: false
+---
+
+${agentContent}`
       
-      // Add import to .cursorrules
-      const newContent = cursorRulesContent + 
-        (cursorRulesContent ? '\n\n' : '') +
-        commentLine + '\n' +
-        agentComment + '\n' +
-        importLine + '\n'
+      // Write .mdc file
+      const mdcPath = path.join(agentRulesDir, `${agentId}.mdc`)
+      await fs.writeFile(mdcPath, mdcContent, 'utf8')
       
-      await fs.writeFile(mainCursorRulesPath, newContent, 'utf8')
+      // Update index.mdc (similar to BMAD index)
+      await this.updateNexIndex(agentId, manifest, agentCategory)
       
+      const agentTrigger = manifest.bmad?.activation_trigger || `@${agentId}`
       console.log(chalk.green(`\n✅ Cursor integration complete!`))
-      console.log(chalk.gray(`   Added ${rulesFile} to .cursorrules`))
-      const trigger = manifest.bmad?.activation_trigger || `@${agentId}`
-      console.log(chalk.gray(`   Use: ${trigger} <command> in Cursor\n`))
+      console.log(chalk.gray(`   Agent installed in: .cursor/rules/nex/${agentCategory}/agents/${agentId}.mdc`))
+      console.log(chalk.gray(`   Use: ${agentTrigger} or @nex/${agentCategory}/agents/${agentId} in Cursor\n`))
       
     } catch (error) {
       console.log(chalk.yellow(`\n⚠️  Cursor integration failed: ${error.message}`))
@@ -1121,6 +1125,76 @@ export default class NEXMarketplace {
     }
   }
 
+  /**
+   * Update NEX index.mdc file (similar to BMAD index)
+   */
+  async updateNexIndex(agentId, manifest, category) {
+    const indexPath = path.join(this.projectRoot, '.cursor', 'rules', 'nex', 'index.mdc')
+    const indexDir = path.dirname(indexPath)
+    await fs.ensureDir(indexDir)
+    
+    let indexContent = ''
+    if (await fs.pathExists(indexPath)) {
+      indexContent = await fs.readFile(indexPath, 'utf8')
+    } else {
+      // Create initial index
+      indexContent = `---
+description: NEX Framework - Master Index
+globs:
+alwaysApply: true
+---
+
+# NEX Framework - Cursor Rules Index
+
+This is the master index for all NEX agents available in your project.
+
+## Installation Complete!
+
+NEX rules have been installed to: \`.cursor/rules/nex/\`
+
+**Note:** NEX does not modify your \`.cursorrules\` file. You manage that separately.
+
+## How to Use
+
+- Reference specific agents: @nex/{category}/agents/{agent-name}
+- Reference this index: @nex/index
+
+## Available Agents
+
+`
+    }
+    
+    // Check if agent is already listed
+    const agentRef = `@nex/${category}/agents/${agentId}`
+    if (indexContent.includes(agentRef)) {
+      return // Already listed
+    }
+    
+    // Add agent to index
+    const categorySection = `### ${category.toUpperCase()}\n\n**Agents:**\n`
+    if (!indexContent.includes(categorySection)) {
+      indexContent += categorySection
+    }
+    
+    const agentEntry = `- ${agentRef} - ${manifest.name}\n`
+    if (!indexContent.includes(agentEntry)) {
+      // Find the category section and add agent
+      const categoryIndex = indexContent.indexOf(`### ${category.toUpperCase()}`)
+      if (categoryIndex !== -1) {
+        const agentsIndex = indexContent.indexOf('**Agents:**', categoryIndex)
+        if (agentsIndex !== -1) {
+          const insertIndex = indexContent.indexOf('\n', agentsIndex) + 1
+          indexContent = indexContent.slice(0, insertIndex) + agentEntry + indexContent.slice(insertIndex)
+        }
+      } else {
+        // Category doesn't exist, add it
+        indexContent += `### ${category.toUpperCase()}\n\n**Agents:**\n${agentEntry}\n\n`
+      }
+    }
+    
+    await fs.writeFile(indexPath, indexContent, 'utf8')
+  }
+
   /**
    * Get latest version of agent
    */