nex-app 0.1.0

package/README.md

@@ -0,0 +1,74 @@
+# nex-app
+
+Crie projetos NEX com interface interativa (CLI + Web UI).
+
+## 🚀 Uso
+
+```bash
+# Uso básico (detecção automática)
+npx nex-app
+
+# Forçar Web UI
+npx nex-app --web
+
+# Forçar CLI
+npx nex-app --no-browser
+```
+
+## ✨ Características
+
+- **Modo Híbrido**: CLI rápido ou Web UI visual
+- **Detecção Automática**: Escolhe o melhor modo automaticamente
+- **Templates**: Blank, Full Stack, API Only
+- **Integração Cursor**: Configuração automática
+- **Marketplace**: Seleção de agentes durante criação
+
+## 📋 Requisitos
+
+- Node.js >= 18.0.0
+- npm, pnpm ou yarn
+
+## 🏗️ Arquitetura
+
+Este pacote implementa a **Opção 3 (Híbrida)**:
+- CLI como padrão (rápido, confiável)
+- Web installer como opção (`--web`)
+- Detecção automática de ambiente
+
+## 📖 Documentação
+
+- [Arquitetura Completa](../docs/ARQUITETURA_NPX_WEB_INSTALLER_NEX.md)
+- [Implementação Detalhada](../docs/IMPLEMENTACAO_HIBRIDA_NPX.md)
+- [Brainstorm](../docs/BRAINSTORM_NPX_WEB_INSTALLER.md)
+
+## 🔧 Desenvolvimento
+
+```bash
+# Instalar dependências
+npm install
+
+# Testar localmente
+node cli/create.js
+
+# Testar modo web
+node cli/create.js --web
+```
+
+## 📝 Status
+
+🟡 **Em Desenvolvimento** - MVP funcional
+
+- [x] Estrutura base
+- [x] CLI entrypoint
+- [x] Servidor web
+- [x] UI básica
+- [x] Generator
+- [x] Templates básicos
+- [ ] Integração completa com Marketplace
+- [ ] Integração completa com Cursor
+- [ ] Testes
+- [ ] Publicação no npm
+
+## 📄 Licença
+
+PROPRIETARY - INOSX

package/cli/create.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+/**
+ * NEX App Creator - Entrypoint principal
+ * Suporta modo CLI e Web UI (híbrido)
+ */
+
+import { startServer } from '../server/index.js'
+import { openBrowser } from '../utils/browser.js'
+import { detectEnvironment } from '../utils/environment.js'
+import { runCLIFallback } from './fallback.js'
+import chalk from 'chalk'
+
+async function main() {
+  // Verificar flags especiais
+  const args = process.argv.slice(2)
+  
+  // --version ou -v
+  if (args.includes('--version') || args.includes('-v')) {
+    const pkg = await import('../package.json', { assert: { type: 'json' } })
+    console.log(pkg.default.version)
+    process.exit(0)
+  }
+  
+  // --help ou -h
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(chalk.blue('🚀 nex-app'))
+    console.log(chalk.gray('Create NEX projects with interactive installer\n'))
+    console.log('Usage:')
+    console.log('  npx nex-app              # Auto-detect mode')
+    console.log('  npx nex-app --web        # Force Web UI')
+    console.log('  npx nex-app --no-browser # Force CLI')
+    console.log('  npx nex-app --version    # Show version')
+    process.exit(0)
+  }
+  
+  // Validações
+  const nodeVersion = process.version
+  if (nodeVersion < 'v18.0.0') {
+    console.error(chalk.red('❌ Node.js >= 18.0.0 required'))
+    console.error(chalk.gray(`   Current: ${nodeVersion}`))
+    process.exit(1)
+  }
+
+  // Detectar modo de operação
+  const useWeb = args.includes('--web')
+  const forceCLI = args.includes('--no-browser')
+  
+  const env = detectEnvironment()
+  
+  // Decisão: Web UI ou CLI?
+  let shouldUseWeb = false
+  
+  if (forceCLI) {
+    shouldUseWeb = false
+    console.log(chalk.gray('ℹ️  Modo CLI forçado\n'))
+  } else if (useWeb) {
+    shouldUseWeb = true
+    console.log(chalk.blue('🌐 Modo Web UI forçado\n'))
+  } else {
+    // Detecção automática: usar web se ambiente suporta
+    shouldUseWeb = !env.isHeadless && !env.isCI && env.hasDisplay
+    if (shouldUseWeb) {
+      console.log(chalk.blue('🌐 Ambiente detectado: usando Web UI\n'))
+    } else {
+      console.log(chalk.gray('ℹ️  Ambiente headless/CI detectado: usando modo CLI\n'))
+    }
+  }
+
+  // Capturar diretório de trabalho inicial (onde o usuário executou o comando)
+  const initialCwd = process.cwd()
+
+  if (shouldUseWeb) {
+    // Modo Web UI
+    try {
+      const { port, server } = await startServer(initialCwd)
+      const url = `http://localhost:${port}`
+      
+      await openBrowser(url)
+      
+      console.log(chalk.green(`✅ Installer aberto em ${chalk.cyan(url)}`))
+      console.log(chalk.gray(`   Diretório de trabalho: ${chalk.cyan(initialCwd)}`))
+      console.log(chalk.gray('   Pressione Ctrl+C para cancelar\n'))
+      
+      // Aguardar finalização
+      process.on('SIGINT', () => {
+        console.log(chalk.yellow('\n\n⏹️  Cancelando...'))
+        server.close()
+        process.exit(0)
+      })
+      
+      // Timeout de segurança (10 minutos)
+      setTimeout(() => {
+        console.log(chalk.yellow('\n⏱️  Timeout: fechando servidor...'))
+        server.close()
+        process.exit(0)
+      }, 10 * 60 * 1000)
+      
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Erro ao iniciar servidor web: ${error.message}`))
+      console.log(chalk.yellow('\n🔄 Fallback para modo CLI...\n'))
+      await runCLIFallback(initialCwd)
+    }
+  } else {
+    // Modo CLI Fallback
+    await runCLIFallback(initialCwd)
+  }
+}
+
+main().catch((error) => {
+  console.error(chalk.red(`\n❌ Erro fatal: ${error.message}`))
+  if (error.stack) {
+    console.error(chalk.gray(error.stack))
+  }
+  process.exit(1)
+})

package/cli/fallback.js

@@ -0,0 +1,96 @@
+/**
+ * CLI Fallback - Modo interativo via terminal
+ */
+
+import inquirer from 'inquirer'
+import chalk from 'chalk'
+import path from 'path'
+import fs from 'fs-extra'
+import { generateProject } from '../generator/index.js'
+import { searchAgents } from '../lib/marketplace-client.js'
+
+export async function runCLIFallback(initialCwd = process.cwd()) {
+  console.log(chalk.blue('🚀 Create NEX App - Modo CLI\n'))
+  console.log(chalk.gray(`Diretório de trabalho: ${chalk.cyan(initialCwd)}\n`))
+
+  // Buscar agentes disponíveis
+  const availableAgents = await searchAgents({})
+
+  // Detectar nome do projeto (da pasta ou package.json)
+  let currentProjectName = path.basename(initialCwd)
+  try {
+    const packageJsonPath = path.join(initialCwd, 'package.json')
+    if (await fs.pathExists(packageJsonPath)) {
+      const packageJson = await fs.readJSON(packageJsonPath)
+      if (packageJson.name) {
+        currentProjectName = packageJson.name
+      }
+    }
+  } catch (error) {
+    // Ignore
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'template',
+      message: 'Template:',
+      choices: [
+        { name: 'Blank - Projeto vazio', value: 'blank' },
+        { name: 'Full Stack - Frontend + Backend', value: 'full-stack' },
+        { name: 'API Only - Apenas backend', value: 'api-only' }
+      ],
+      default: 'blank'
+    },
+    {
+      type: 'checkbox',
+      name: 'agents',
+      message: 'Agentes iniciais (opcional):',
+      choices: availableAgents.map(agent => ({
+        name: `${agent.icon} ${agent.name} - ${agent.tagline}`,
+        value: agent.agent_id
+      })),
+      default: []
+    },
+    {
+      type: 'confirm',
+      name: 'cursorIntegration',
+      message: 'Configurar integração com Cursor IDE?',
+      default: true
+    },
+    {
+      type: 'list',
+      name: 'packageManager',
+      message: 'Package Manager:',
+      choices: ['npm', 'pnpm', 'yarn'],
+      default: 'npm'
+    }
+  ])
+
+  console.log(chalk.blue('\n📦 Gerando projeto...\n'))
+
+  try {
+    const projectPath = await generateProject({
+      template: answers.template,
+      agents: answers.agents || [],
+      packageManager: answers.packageManager,
+      cursorIntegration: answers.cursorIntegration,
+      options: {},
+      targetDir: initialCwd
+    })
+
+    console.log(chalk.green(`\n✅ NEX inicializado em: ${chalk.cyan(projectPath)}\n`))
+    console.log(chalk.gray('Próximos passos:'))
+    console.log(chalk.cyan(`  ${answers.packageManager} install`))
+    console.log(chalk.cyan(`  ${answers.packageManager} start\n`))
+    console.log(chalk.gray('Para instalar agentes:'))
+    console.log(chalk.cyan(`  nex agent list --all`))
+    console.log(chalk.cyan(`  nex agent install <agent-id>\n`))
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Erro: ${error.message}\n`))
+    if (error.stack) {
+      console.error(chalk.gray(error.stack))
+    }
+    process.exit(1)
+  }
+}

package/generator/agent-installer.js

@@ -0,0 +1,33 @@
+/**
+ * Instalador de agentes
+ * TODO: Integrar com nex-installer service real
+ */
+
+import fs from 'fs-extra'
+import path from 'path'
+
+export async function installAgents(projectPath, agentIds) {
+  // Por enquanto, apenas criar estrutura
+  // TODO: Integrar com AgentInstaller real do NEX
+  
+  const agentsDir = path.join(projectPath, '.nex-core', 'agents')
+  await fs.ensureDir(agentsDir)
+  
+  // Criar arquivo de manifest dos agentes instalados
+  const manifest = {
+    agents: agentIds.map(id => ({
+      agent_id: id,
+      installed_at: new Date().toISOString()
+    }))
+  }
+  
+  await fs.writeJSON(
+    path.join(agentsDir, 'manifest.json'),
+    manifest,
+    { spaces: 2 }
+  )
+  
+  // TODO: Instalar agentes reais do registry
+  console.log(`📦 Agentes selecionados: ${agentIds.join(', ')}`)
+  console.log('   (Instalação real será implementada na próxima fase)')
+}

package/generator/cursor-integration.js

@@ -0,0 +1,202 @@
+/**
+ * Integração com Cursor IDE
+ * Segue o padrão BMAD: .cursor/rules/nex/{category}/agents/{agentId}.mdc
+ */
+
+import fs from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import yaml from 'yaml'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**
+ * Carregar configuração global do NEX CLI
+ */
+async function getGlobalConfig() {
+  const os = await import('os')
+  const configPath = process.platform === 'win32'
+    ? path.join(os.default.homedir(), 'AppData', 'Roaming', 'nex', 'config.json')
+    : path.join(os.default.homedir(), '.nex', 'config.json')
+  
+  try {
+    if (await fs.pathExists(configPath)) {
+      return await fs.readJSON(configPath)
+    }
+  } catch (error) {
+    // Ignore
+  }
+  
+  return {
+    user: {
+      name: 'Developer',
+      conversationLanguage: 'pt-br',
+      documentLanguage: 'pt-br'
+    },
+    cursor: {
+      enabled: true
+    }
+  }
+}
+
+export async function integrateCursor(projectPath, agents) {
+  if (!agents || agents.length === 0) {
+    // Ainda assim criar estrutura básica
+    await createBasicCursorStructure(projectPath)
+    return
+  }
+
+  const globalConfig = await getGlobalConfig()
+  const userConfig = globalConfig.user || {}
+
+  // 1. Criar nex/core/config.yaml (similar ao BMAD bmad/core/config.yaml)
+  const nexCoreDir = path.join(projectPath, 'nex', 'core')
+  await fs.ensureDir(nexCoreDir)
+  
+  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'
+  }
+  
+  const configPath = path.join(nexCoreDir, 'config.yaml')
+  if (!await fs.pathExists(configPath)) {
+    const configYamlContent = yaml.stringify(configYaml)
+    await fs.writeFile(configPath, configYamlContent, 'utf8')
+  }
+
+  // 2. Criar .cursor/rules/nex/ (seguindo padrão BMAD .cursor/rules/bmad/)
+  const cursorRulesDir = path.join(projectPath, '.cursor', 'rules', 'nex')
+  await fs.ensureDir(cursorRulesDir)
+
+  // 3. Criar index.mdc (similar ao BMAD index.mdc)
+  const indexContent = `---
+description: NEX Framework - Master Index
+globs:
+alwaysApply: true
+---
+
+# NEX Framework - Cursor Rules Index
+
+This is the master index for all NEX agents installed 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
+
+## Installed Agents
+
+${agents.length > 0 
+  ? agents.map(agentId => `- @nex/${agentId} - ${agentId}`).join('\n')
+  : 'No agents installed yet. Use: nex agent install <agent-id>'
+}
+
+## Quick Reference
+
+- All NEX rules are Manual type - reference them explicitly when needed
+- Agents provide persona-based assistance with specific expertise
+- Each agent includes an activation block for proper initialization
+
+## Configuration
+
+NEX rules are configured as Manual rules (alwaysApply: false) to give you control
+over when they're included in your context. Reference them explicitly when you need
+specific agent expertise.
+
+---
+
+**Project:** ${path.basename(projectPath)}
+**Created:** ${new Date().toISOString()}
+`
+
+  await fs.writeFile(
+    path.join(cursorRulesDir, 'index.mdc'),
+    indexContent,
+    'utf8'
+  )
+
+  console.log('🔗 Integração com Cursor configurada (padrão BMAD)')
+  console.log(`   Config: nex/core/config.yaml`)
+  console.log(`   Rules: .cursor/rules/nex/index.mdc`)
+  console.log(`   Agentes selecionados: ${agents.length}`)
+  console.log('   (Para instalar agentes reais, execute: nex agent install <agent-id>)')
+}
+
+/**
+ * Criar estrutura básica do Cursor mesmo sem agentes
+ */
+async function createBasicCursorStructure(projectPath) {
+  const globalConfig = await getGlobalConfig()
+  const userConfig = globalConfig.user || {}
+
+  // Criar nex/core/config.yaml
+  const nexCoreDir = path.join(projectPath, 'nex', 'core')
+  await fs.ensureDir(nexCoreDir)
+  
+  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'
+  }
+  
+  const configPath = path.join(nexCoreDir, 'config.yaml')
+  const configYamlContent = yaml.stringify(configYaml)
+  await fs.writeFile(configPath, configYamlContent, 'utf8')
+
+  // Criar .cursor/rules/nex/index.mdc básico
+  const cursorRulesDir = path.join(projectPath, '.cursor', 'rules', 'nex')
+  await fs.ensureDir(cursorRulesDir)
+
+  const indexContent = `---
+description: NEX Framework - Master Index
+globs:
+alwaysApply: true
+---
+
+# NEX Framework - Cursor Rules Index
+
+This is the master index for all NEX agents installed 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
+
+## Installed Agents
+
+No agents installed yet. Use: nex agent install <agent-id>
+
+## Quick Reference
+
+- All NEX rules are Manual type - reference them explicitly when needed
+- Agents provide persona-based assistance with specific expertise
+- Each agent includes an activation block for proper initialization
+
+---
+
+**Project:** ${path.basename(projectPath)}
+**Created:** ${new Date().toISOString()}
+`
+
+  await fs.writeFile(
+    path.join(cursorRulesDir, 'index.mdc'),
+    indexContent,
+    'utf8'
+  )
+}

package/generator/index.js

@@ -0,0 +1,141 @@
+/**
+ * Generator de projetos NEX
+ */
+
+import fs from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { renderTemplate } from './template-engine.js'
+import { installAgents } from './agent-installer.js'
+import { integrateCursor } from './cursor-integration.js'
+import { installDependencies } from './package-manager.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**
+ * Obter todos os arquivos de um template recursivamente
+ */
+async function getTemplateFiles(templatePath) {
+  const files = []
+  
+  async function walkDir(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true })
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name)
+      
+      if (entry.isDirectory()) {
+        await walkDir(fullPath)
+      } else {
+        files.push(fullPath)
+      }
+    }
+  }
+  
+  await walkDir(templatePath)
+  return files
+}
+
+export async function generateProject(config) {
+  const {
+    template,
+    agents = [],
+    packageManager = 'npm',
+    cursorIntegration = false,
+    options = {},
+    targetDir
+  } = config
+
+  // 1. Carregar template
+  const templatePath = path.join(__dirname, '../templates', template)
+  if (!await fs.pathExists(templatePath)) {
+    throw new Error(`Template "${template}" not found`)
+  }
+
+  // 2. Usar diretório atual (padrão BMAD/NEX - não cria nova pasta)
+  const projectPath = targetDir
+  
+  // Detectar nome do projeto (da pasta ou package.json existente)
+  let detectedProjectName = path.basename(projectPath)
+  try {
+    const packageJsonPath = path.join(projectPath, 'package.json')
+    if (await fs.pathExists(packageJsonPath)) {
+      const packageJson = await fs.readJSON(packageJsonPath)
+      if (packageJson.name) {
+        detectedProjectName = packageJson.name
+      }
+    }
+  } catch (error) {
+    // Ignore
+  }
+  
+  // Verificar se diretório está vazio ou pode ser inicializado
+  const files = await fs.readdir(projectPath).catch(() => [])
+  const importantFiles = files.filter(f => 
+    !f.startsWith('.') && 
+    f !== 'node_modules' && 
+    f !== 'package-lock.json' &&
+    f !== 'pnpm-lock.yaml' &&
+    f !== 'yarn.lock'
+  )
+  
+  if (importantFiles.length > 0) {
+    // Diretório não está vazio, mas podemos inicializar NEX nele (como nex init)
+    console.log(`⚠️  Diretório não está vazio. Inicializando NEX no diretório atual...`)
+  }
+
+  // 3. Processar arquivos do template
+  const templateFiles = await getTemplateFiles(templatePath)
+  
+  for (const file of templateFiles) {
+    const content = await fs.readFile(file, 'utf-8')
+    const relativePath = path.relative(templatePath, file)
+    const targetPath = path.join(projectPath, relativePath.replace('.tpl', ''))
+    
+    // Não sobrescrever arquivos existentes (exceto se for .nex-core, .cursor ou nex/)
+    const isNexFile = relativePath.includes('.nex-core') || 
+                     relativePath.includes('.cursor') || 
+                     relativePath.includes('nex/')
+    if (!isNexFile && await fs.pathExists(targetPath)) {
+      console.log(`⏭️  Pulando ${relativePath} (já existe)`)
+      continue
+    }
+    
+    const rendered = renderTemplate(content, {
+      projectName: detectedProjectName,
+      packageManager,
+      ...options
+    })
+    
+    await fs.ensureDir(path.dirname(targetPath))
+    await fs.writeFile(targetPath, rendered)
+  }
+
+  // 4. Criar estrutura .nex-core (sempre, padrão NEX)
+  const nexCoreDir = path.join(projectPath, '.nex-core')
+  await fs.ensureDir(path.join(nexCoreDir, 'agents'))
+  await fs.ensureDir(path.join(nexCoreDir, 'data'))
+  await fs.ensureDir(path.join(nexCoreDir, 'documents'))
+  
+  // Criar installed.json vazio (registry de agentes)
+  const installedJsonPath = path.join(nexCoreDir, 'agents', 'installed.json')
+  if (!await fs.pathExists(installedJsonPath)) {
+    await fs.writeJSON(installedJsonPath, {}, { spaces: 2 })
+  }
+
+  // 5. Instalar agentes (se selecionados)
+  if (agents.length > 0) {
+    await installAgents(projectPath, agents)
+  }
+
+  // 6. Integrar com Cursor (se habilitado)
+  if (cursorIntegration) {
+    await integrateCursor(projectPath, agents)
+  }
+
+  // 7. Instalar dependências
+  await installDependencies(projectPath, packageManager)
+
+  return projectPath
+}

package/generator/package-manager.js

@@ -0,0 +1,40 @@
+/**
+ * Instalador de dependências (npm/pnpm/yarn)
+ */
+
+import { exec } from 'child_process'
+import { promisify } from 'util'
+
+const execAsync = promisify(exec)
+
+export async function installDependencies(projectPath, packageManager) {
+  const commands = {
+    npm: 'npm install',
+    pnpm: 'pnpm install',
+    yarn: 'yarn install'
+  }
+  
+  const command = commands[packageManager]
+  if (!command) {
+    throw new Error(`Package manager "${packageManager}" não suportado`)
+  }
+  
+  console.log(`📦 Instalando dependências com ${packageManager}...`)
+  
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd: projectPath,
+      stdio: 'inherit'
+    })
+    
+    if (stderr && !stderr.includes('npm warn')) {
+      console.warn(stderr)
+    }
+    
+    console.log('✅ Dependências instaladas')
+  } catch (error) {
+    console.warn(`⚠️  Erro ao instalar dependências: ${error.message}`)
+    console.warn('   Você pode instalar manualmente depois com:')
+    console.warn(`   cd ${projectPath} && ${command}`)
+  }
+}