nex-framework-cli 1.0.1

package/registry/planning/arx/manifest.yaml

@@ -0,0 +1,98 @@
+# NEX Agent Manifest
+id: arx
+name: "ARX - Architecture Expert"
+tagline: "System Architecture & Technical Design"
+icon: "🏗️"
+type: planning
+category: planning
+subcategory: OPX
+
+version: 1.0.0
+semantic_version:
+  major: 1
+  minor: 0
+  patch: 0
+
+author:
+  name: INOSX
+  email: contact@inosx.com
+  github: INOSX
+  organization: INOSX
+
+description: |
+  Expert em arquitetura de sistemas e design técnico.
+  Projeta soluções escaláveis e manuteníveis.
+
+long_description: |
+  ARX é o arquiteto especialista do NEX Framework.
+  Cria designs de arquitetura completos, diagramas, decisões técnicas
+  e documentação de infraestrutura baseada em requisitos e PRDs.
+
+tags:
+  - architecture
+  - system-design
+  - technical-design
+  - infrastructure
+  - scalability
+  - patterns
+
+compatibility:
+  nex_version: ">=1.0.0"
+  node_version: ">=18.0.0"
+  os: ["windows", "macos", "linux"]
+
+dependencies:
+  agents:
+    - pmx  # Recebe PRDs
+  tools:
+    - supabase
+    - ai-provider
+  optional_agents:
+    - dvx
+
+capabilities:
+  - Architecture design
+  - System diagrams generation
+  - Technology stack recommendation
+  - Database schema design
+  - API design
+  - Infrastructure planning
+  - Scalability analysis
+  - Security architecture
+
+commands:
+  - trigger: design
+    description: Criar design de arquitetura completo
+  - trigger: diagram
+    description: Gerar diagramas técnicos
+  - trigger: stack
+    description: Recomendar tech stack
+
+installation:
+  size_mb: 2.5
+  install_time_minutes: 1
+  complexity: simple
+
+pricing:
+  model: free
+  price: 0
+  license: PROPRIETARY
+
+stats:
+  installs: 0
+  stars: 0
+  rating: 0
+  last_updated: "2026-01-09"
+
+links:
+  repository: https://github.com/INOSX/nex-agents
+  documentation: https://docs.inosx.com/nex/agents/arx
+  homepage: https://inosx.com/nex
+
+metadata:
+  is_official: true
+  is_verified: true
+  maturity: stable
+  support_level: full
+  language: javascript
+  framework: NEX

package/registry/planning/pmx/manifest.yaml

@@ -0,0 +1,96 @@
+# NEX Agent Manifest
+id: pmx
+name: "PMX - Product Management Expert"
+tagline: "Strategic Product Planning & PRD Generation"
+icon: "📊"
+type: planning
+category: planning
+subcategory: FLX
+
+version: 1.0.0
+semantic_version:
+  major: 1
+  minor: 0
+  patch: 0
+
+author:
+  name: INOSX
+  email: contact@inosx.com
+  github: INOSX
+  organization: INOSX
+
+description: |
+  Expert em gestão de produto e criação de Product Requirements Documents (PRDs).
+  Transforma análises em estratégias de produto executáveis.
+
+long_description: |
+  PMX é o especialista em Product Management do NEX Framework.
+  Trabalha em conjunto com ANX para transformar análises de requisitos
+  em PRDs completos, roadmaps e estratégias de produto.
+
+tags:
+  - product-management
+  - prd
+  - strategy
+  - planning
+  - roadmap
+  - product-strategy
+
+compatibility:
+  nex_version: ">=1.0.0"
+  node_version: ">=18.0.0"
+  os: ["windows", "macos", "linux"]
+
+dependencies:
+  agents:
+    - anx  # Recebe input do Analysis Expert
+  tools:
+    - supabase
+    - ai-provider
+  optional_agents:
+    - arx
+
+capabilities:
+  - PRD generation
+  - Product strategy definition
+  - Roadmap creation
+  - Feature prioritization
+  - Success metrics definition
+  - Go-to-market planning
+
+commands:
+  - trigger: create-prd
+    description: Gerar PRD completo
+  - trigger: create-roadmap
+    description: Criar roadmap de produto
+  - trigger: prioritize
+    description: Priorizar features
+
+installation:
+  size_mb: 2.3
+  install_time_minutes: 1
+  complexity: simple
+
+pricing:
+  model: free
+  price: 0
+  license: PROPRIETARY
+
+stats:
+  installs: 0
+  stars: 0
+  rating: 0
+  last_updated: "2026-01-09"
+
+links:
+  repository: https://github.com/INOSX/nex-agents
+  documentation: https://docs.inosx.com/nex/agents/pmx
+  homepage: https://inosx.com/nex
+
+metadata:
+  is_official: true
+  is_verified: true
+  maturity: stable
+  support_level: full
+  language: javascript
+  framework: NEX

package/src/services/nex-installer/agentLoader.js

@@ -0,0 +1,108 @@
+/**
+ * Agent Loader - Carrega agentes instalados
+ */
+import fs from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export default class AgentLoader {
+  constructor() {
+    this.agentsDir = path.join(process.cwd(), '.nex-core', 'agents')
+    this.loadedAgents = new Map()
+  }
+
+  /**
+   * Carrega agente instalado
+   */
+  async loadAgent(agentId) {
+    if (this.loadedAgents.has(agentId)) {
+      return this.loadedAgents.get(agentId)
+    }
+
+    const agentDir = path.join(this.agentsDir, agentId)
+    
+    if (!await fs.pathExists(agentDir)) {
+      throw new Error(`Agente ${agentId} não encontrado`)
+    }
+
+    // Ler manifest
+    const manifestPath = path.join(agentDir, 'manifest.json')
+    const manifest = await fs.readJSON(manifestPath)
+
+    // Encontrar arquivo principal
+    const mainFile = await this.findMainFile(agentDir)
+    
+    // Carregar módulo
+    const agentModule = await import(mainFile)
+    const AgentClass = agentModule.default || agentModule[manifest.name]
+
+    if (!AgentClass) {
+      throw new Error(`Classe do agente não encontrada em ${mainFile}`)
+    }
+
+    const agent = new AgentClass()
+
+    // Armazenar em cache
+    this.loadedAgents.set(agentId, {
+      agent,
+      manifest,
+      path: agentDir
+    })
+
+    return {
+      agent,
+      manifest,
+      path: agentDir
+    }
+  }
+
+  /**
+   * Encontra arquivo principal do agente
+   */
+  async findMainFile(agentDir) {
+    const possibleFiles = ['agent.js', 'index.js', 'main.js', `${path.basename(agentDir)}.js`]
+    
+    for (const file of possibleFiles) {
+      const filePath = path.join(agentDir, file)
+      if (await fs.pathExists(filePath)) {
+        return filePath
+      }
+    }
+
+    throw new Error('Arquivo principal do agente não encontrado')
+  }
+
+  /**
+   * Lista agentes disponíveis para carregar
+   */
+  async listAvailable() {
+    if (!await fs.pathExists(this.agentsDir)) {
+      return []
+    }
+
+    const dirs = await fs.readdir(this.agentsDir)
+    const agents = []
+
+    for (const dir of dirs) {
+      const agentDir = path.join(this.agentsDir, dir)
+      const stat = await fs.stat(agentDir)
+      
+      if (stat.isDirectory()) {
+        const manifestPath = path.join(agentDir, 'manifest.json')
+        if (await fs.pathExists(manifestPath)) {
+          const manifest = await fs.readJSON(manifestPath)
+          agents.push({
+            id: dir,
+            ...manifest
+          })
+        }
+      }
+    }
+
+    return agents
+  }
+}
+

package/src/services/nex-installer/agentValidator.js

@@ -0,0 +1,93 @@
+/**
+ * Agent Validator - Valida agentes antes da instalação
+ */
+export default class AgentValidator {
+  /**
+   * Valida estrutura do agente
+   */
+  async validate(agentData) {
+    const errors = []
+
+    // Validar campos obrigatórios
+    if (!agentData.id) {
+      errors.push('ID do agente é obrigatório')
+    }
+
+    if (!agentData.version) {
+      errors.push('Versão do agente é obrigatória')
+    }
+
+    if (!agentData.name) {
+      errors.push('Nome do agente é obrigatório')
+    }
+
+    // Validar formato do ID
+    if (agentData.id && !/^[a-z0-9-_]+$/i.test(agentData.id)) {
+      errors.push('ID do agente contém caracteres inválidos')
+    }
+
+    // Validar versão (semver)
+    if (agentData.version && !this.isValidVersion(agentData.version)) {
+      errors.push('Versão inválida (deve seguir semver)')
+    }
+
+    // Validar arquivos
+    if (!agentData.files || Object.keys(agentData.files).length === 0) {
+      errors.push('Agente deve conter pelo menos um arquivo')
+    }
+
+    // Validar que há um arquivo principal
+    const hasMainFile = Object.keys(agentData.files || {}).some(f => 
+      f.includes('agent.js') || f.includes('index.js') || f.includes('main.js')
+    )
+    if (!hasMainFile) {
+      errors.push('Agente deve conter arquivo principal (agent.js, index.js ou main.js)')
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    }
+  }
+
+  /**
+   * Valida versão semver
+   */
+  isValidVersion(version) {
+    if (version === 'latest') return true
+    return /^\d+\.\d+\.\d+(-.+)?$/.test(version)
+  }
+
+  /**
+   * Valida dependências
+   */
+  validateDependencies(dependencies) {
+    const errors = []
+
+    if (!Array.isArray(dependencies)) {
+      errors.push('Dependências devem ser um array')
+      return { valid: false, errors }
+    }
+
+    for (const dep of dependencies) {
+      if (typeof dep === 'string') {
+        if (!/^[a-z0-9-_]+(@.+)?$/i.test(dep)) {
+          errors.push(`Dependência inválida: ${dep}`)
+        }
+      } else if (typeof dep === 'object') {
+        if (!dep.id) {
+          errors.push('Dependência deve ter ID')
+        }
+        if (dep.version && !this.isValidVersion(dep.version)) {
+          errors.push(`Versão de dependência inválida: ${dep.version}`)
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    }
+  }
+}
+

package/src/services/nex-installer/dependencyResolver.js

@@ -0,0 +1,59 @@
+/**
+ * Dependency Resolver - Resolve dependências de agentes
+ */
+import Registry from './registry.js'
+
+export default class DependencyResolver {
+  constructor() {
+    this.registry = new Registry()
+  }
+
+  /**
+   * Resolve dependências
+   */
+  async resolve(dependencies) {
+    const resolved = []
+    const missing = []
+
+    for (const dep of dependencies) {
+      const depId = typeof dep === 'string' ? dep.split('@')[0] : dep.id
+      const installed = await this.registry.isInstalled(depId)
+
+      if (installed) {
+        resolved.push({
+          id: depId,
+          installed: true,
+          version: installed.version
+        })
+      } else {
+        missing.push(depId)
+      }
+    }
+
+    return {
+      resolved,
+      missing,
+      allResolved: missing.length === 0
+    }
+  }
+
+  /**
+   * Instala dependências faltando
+   */
+  async installMissing(missing, installer) {
+    const results = []
+
+    for (const depId of missing) {
+      try {
+        console.log(`[DependencyResolver] 📦 Instalando dependência: ${depId}`)
+        const result = await installer.installFromURL(`nex://install?agentId=${depId}`)
+        results.push({ id: depId, success: true, result })
+      } catch (error) {
+        results.push({ id: depId, success: false, error: error.message })
+      }
+    }
+
+    return results
+  }
+}
+

package/src/services/nex-installer/installer.js

@@ -0,0 +1,226 @@
+/**
+ * NEX Agent Installer - Sistema de instalação de agentes
+ * Suporta protocolo nex://install?agentId=xxx&version=1.0.0
+ */
+import fs from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import AgentValidator from './agentValidator.js'
+import DependencyResolver from './dependencyResolver.js'
+import AgentLoader from './agentLoader.js'
+import Registry from './registry.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export default class AgentInstaller {
+  constructor() {
+    this.agentsDir = path.join(process.cwd(), '.nex-core', 'agents')
+    this.validator = new AgentValidator()
+    this.dependencyResolver = new DependencyResolver()
+    this.loader = new AgentLoader()
+    this.registry = new Registry()
+  }
+
+  /**
+   * Instala agente a partir de URL nex://
+   */
+  async installFromURL(nexURL) {
+    console.log('[Installer] 📦 Instalando agente de:', nexURL)
+    
+    try {
+      // Parsear URL nex://
+      const params = this.parseNexURL(nexURL)
+      const { agentId, version } = params
+
+      if (!agentId) {
+        throw new Error('agentId é obrigatório na URL')
+      }
+
+      // Baixar agente da NEX Store
+      const agentData = await this.downloadAgent(agentId, version)
+
+      // Instalar agente
+      return await this.installAgent(agentData, agentId, version)
+    } catch (error) {
+      console.error('[Installer] ❌ Erro ao instalar agente:', error)
+      throw error
+    }
+  }
+
+  /**
+   * Instala agente a partir de dados
+   */
+  async installAgent(agentData, agentId, version = 'latest') {
+    console.log(`[Installer] 📦 Instalando agente: ${agentId}@${version}`)
+
+    // Validar agente
+    const validation = await this.validator.validate(agentData)
+    if (!validation.valid) {
+      throw new Error(`Agente inválido: ${validation.errors.join(', ')}`)
+    }
+
+    // Resolver dependências
+    const dependencies = await this.dependencyResolver.resolve(agentData.dependencies || [])
+    if (dependencies.missing.length > 0) {
+      console.warn(`[Installer] ⚠️ Dependências faltando: ${dependencies.missing.join(', ')}`)
+    }
+
+    // Criar diretório do agente
+    const agentDir = path.join(this.agentsDir, agentId)
+    await fs.ensureDir(agentDir)
+
+    // Salvar arquivos do agente
+    await this.saveAgentFiles(agentDir, agentData)
+
+    // Registrar agente
+    await this.registry.register({
+      id: agentId,
+      version: version,
+      installedAt: new Date().toISOString(),
+      path: agentDir,
+      dependencies: agentData.dependencies || [],
+      metadata: agentData.metadata || {}
+    })
+
+    console.log(`[Installer] ✅ Agente ${agentId} instalado com sucesso!`)
+    
+    return {
+      success: true,
+      agentId,
+      version,
+      path: agentDir
+    }
+  }
+
+  /**
+   * Remove agente
+   */
+  async uninstallAgent(agentId) {
+    console.log(`[Installer] 🗑️ Removendo agente: ${agentId}`)
+
+    const agentDir = path.join(this.agentsDir, agentId)
+    
+    if (!await fs.pathExists(agentDir)) {
+      throw new Error(`Agente ${agentId} não encontrado`)
+    }
+
+    // Remover diretório
+    await fs.remove(agentDir)
+
+    // Remover do registro
+    await this.registry.unregister(agentId)
+
+    console.log(`[Installer] ✅ Agente ${agentId} removido com sucesso!`)
+    
+    return {
+      success: true,
+      agentId
+    }
+  }
+
+  /**
+   * Atualiza agente
+   */
+  async updateAgent(agentId, newVersion) {
+    console.log(`[Installer] 🔄 Atualizando agente: ${agentId} para ${newVersion}`)
+
+    // Baixar nova versão
+    const agentData = await this.downloadAgent(agentId, newVersion)
+
+    // Remover versão antiga
+    await this.uninstallAgent(agentId)
+
+    // Instalar nova versão
+    return await this.installAgent(agentData, agentId, newVersion)
+  }
+
+  /**
+   * Parseia URL nex://
+   */
+  parseNexURL(url) {
+    if (!url.startsWith('nex://')) {
+      throw new Error('URL deve começar com nex://')
+    }
+
+    const urlObj = new URL(url.replace('nex://', 'http://'))
+    const params = {}
+
+    for (const [key, value] of urlObj.searchParams.entries()) {
+      params[key] = value
+    }
+
+    // agentId pode estar no path ou query
+    if (urlObj.pathname && urlObj.pathname !== '/') {
+      params.agentId = urlObj.pathname.replace('/', '')
+    }
+
+    return params
+  }
+
+  /**
+   * Baixa agente da NEX Store
+   */
+  async downloadAgent(agentId, version) {
+    console.log(`[Installer] 📥 Baixando agente: ${agentId}@${version}`)
+
+    // TODO: Implementar download real da NEX Store API
+    // Por enquanto, retorna estrutura mock
+    return {
+      id: agentId,
+      version: version,
+      name: agentId,
+      description: `Agente ${agentId}`,
+      category: 'general',
+      dependencies: [],
+      files: {
+        'agent.js': `export default class ${agentId}Agent {
+  constructor() {
+    this.name = '${agentId}'
+  }
+  
+  async execute() {
+    return { success: true }
+  }
+}`
+      },
+      metadata: {
+        author: 'NEX Community',
+        license: 'PROPRIETARY'
+      }
+    }
+  }
+
+  /**
+   * Salva arquivos do agente
+   */
+  async saveAgentFiles(agentDir, agentData) {
+    if (agentData.files) {
+      for (const [filePath, content] of Object.entries(agentData.files)) {
+        const fullPath = path.join(agentDir, filePath)
+        await fs.ensureDir(path.dirname(fullPath))
+        await fs.writeFile(fullPath, content, 'utf-8')
+      }
+    }
+
+    // Salvar manifest
+    const manifest = {
+      id: agentData.id,
+      version: agentData.version,
+      name: agentData.name,
+      description: agentData.description,
+      category: agentData.category,
+      dependencies: agentData.dependencies || [],
+      metadata: agentData.metadata || {}
+    }
+    await fs.writeJSON(path.join(agentDir, 'manifest.json'), manifest, { spaces: 2 })
+  }
+
+  /**
+   * Lista agentes instalados
+   */
+  async listInstalled() {
+    return await this.registry.list()
+  }
+}
+