@ornexus/neocortex 3.8.0

package/install.js

@@ -0,0 +1,453 @@
+#!/usr/bin/env node
+
+/**
+ * Neocortex - Cross-Platform Multi-Target Installer
+ * Interactive platform selection with @clack/prompts + OS detection + shell dispatch
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const {
+    intro, outro, multiselect, confirm, spinner, cancel, isCancel, note, log
+} = require('@clack/prompts');
+const color = require('picocolors');
+
+const SCRIPT_DIR = __dirname;
+const args = process.argv.slice(2);
+
+// Read version from package.json
+const pkg = JSON.parse(fs.readFileSync(path.join(SCRIPT_DIR, 'package.json'), 'utf8'));
+const VERSION = pkg.version;
+
+// ═══════════════════════════════════════════════════════════════════
+// PLATFORM DEFINITIONS
+// ═══════════════════════════════════════════════════════════════════
+
+const PLATFORMS = [
+    { name: 'Claude Code CLI', key: 'claude-code', tier: 1, default: true, detect: 'claude', label: 'Tier 1 - Full Pipeline' },
+    { name: 'Cursor IDE', key: 'cursor', tier: 2, default: false, detect: 'cursor', label: 'Tier 2 - CLI Pipeline' },
+    { name: 'VS Code / GitHub Copilot', key: 'vscode', tier: 3, default: false, detect: 'code', label: 'Tier 3 - Agent-Directed' },
+    { name: 'Gemini CLI', key: 'gemini-cli', tier: 2, default: false, detect: 'gemini', label: 'Tier 2 - CLI Pipeline' },
+    { name: 'OpenAI Codex CLI', key: 'codex', tier: 2, default: false, detect: 'codex', label: 'Tier 2 - CLI Pipeline' },
+    { name: 'Google Antigravity', key: 'antigravity', tier: 3, default: false, detect: 'agy', label: 'Tier 3 - Agent-Directed', experimental: true },
+];
+
+// ═══════════════════════════════════════════════════════════════════
+// PLATFORM DETECTION
+// ═══════════════════════════════════════════════════════════════════
+
+function detectPlatform(command) {
+    const { execSync } = require('child_process');
+    try {
+        execSync(`which ${command} 2>/dev/null || where ${command} 2>NUL`, { stdio: 'pipe' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function detectInstalledPlatforms() {
+    const detected = {};
+    for (const p of PLATFORMS) {
+        detected[p.key] = detectPlatform(p.detect);
+    }
+    return detected;
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// ARGUMENT HANDLING
+// ═══════════════════════════════════════════════════════════════════
+
+function parseTargetsArg() {
+    for (const arg of args) {
+        if (arg.startsWith('--targets=')) {
+            return arg.replace('--targets=', '').split(',').map(t => t.trim()).filter(Boolean);
+        }
+    }
+    return null;
+}
+
+function isAutoYes() {
+    return args.includes('-y') || args.includes('--yes') || args.includes('-Yes');
+}
+
+function isHelp() {
+    return args.includes('-h') || args.includes('--help') || args.includes('-Help');
+}
+
+function isDebug() {
+    return args.includes('-d') || args.includes('--debug') || args.includes('-Debug');
+}
+
+/**
+ * Declarative flag mapping: Unix CLI flags -> PowerShell parameters.
+ * To add a new flag, just add an entry here. No switch/case to update.
+ */
+const FLAG_MAP_WIN32 = {
+    // Auto-confirm mode
+    '-y': '-Yes',
+    '--yes': '-Yes',
+    // Debug output
+    '-d': '-Debug',
+    '--debug': '-Debug',
+    // Skip project directory creation
+    '-s': '-SkipProject',
+    '--skip-project': '-SkipProject',
+    // Force project directory creation
+    '--create-project': '-CreateProject',
+    // Suppress non-essential output
+    '-q': '-Quiet',
+    '--quiet': '-Quiet',
+    // Suppress ASCII banner
+    '--no-banner': '-NoBanner',
+    // Show help text
+    '-h': '-Help',
+    '--help': '-Help',
+    // Remove legacy artifacts from ~/.claude/
+    '--cleanup-legacy': '-CleanupLegacy',
+    // Local mode (copy IP for development)
+    '--local': '-Local',
+    // Server URL override
+    // --server-url=<url> is passed through as-is (handled by shell scripts)
+};
+
+function mapArgs(platform, originalArgs) {
+    const filtered = originalArgs.filter(a => !a.startsWith('--targets='));
+    if (platform === 'win32') {
+        return filtered.map(arg => FLAG_MAP_WIN32[arg] || arg);
+    }
+    return filtered;
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// SCRIPT EXECUTION
+// ═══════════════════════════════════════════════════════════════════
+
+function checkScript(scriptPath) {
+    if (!fs.existsSync(scriptPath)) {
+        log.error(`Script nao encontrado: ${scriptPath}`);
+        process.exit(1);
+    }
+}
+
+function runWindows(selectedTargets) {
+    const scriptPath = path.join(SCRIPT_DIR, 'install.ps1');
+    checkScript(scriptPath);
+
+    const mappedArgs = mapArgs('win32', args);
+    if (selectedTargets) {
+        mappedArgs.push('-Targets', selectedTargets.join(','));
+    }
+
+    const shells = ['pwsh', 'powershell'];
+
+    function tryShell(index) {
+        if (index >= shells.length) {
+            log.error('PowerShell nao encontrado.');
+            log.info('Instale o PowerShell Core: https://aka.ms/powershell');
+            process.exit(1);
+        }
+
+        const shell = shells[index];
+        const psArgs = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', scriptPath, ...mappedArgs];
+
+        const child = spawn(shell, psArgs, { stdio: 'inherit', shell: false });
+
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT') tryShell(index + 1);
+            else {
+                log.error(`Falha ao executar ${shell}: ${err.message}`);
+                process.exit(1);
+            }
+        });
+
+        child.on('exit', (code) => process.exit(code || 0));
+    }
+
+    tryShell(0);
+}
+
+function runUnix(selectedTargets) {
+    const scriptPath = path.join(SCRIPT_DIR, 'install.sh');
+    checkScript(scriptPath);
+
+    try { fs.chmodSync(scriptPath, '755'); } catch { }
+
+    const filteredArgs = mapArgs('unix', args);
+    if (selectedTargets) {
+        filteredArgs.push(`--targets=${selectedTargets.join(',')}`);
+    }
+
+    const child = spawn('bash', [scriptPath, ...filteredArgs], { stdio: 'inherit', shell: false });
+
+    child.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+            const shChild = spawn('sh', [scriptPath, ...filteredArgs], { stdio: 'inherit', shell: false });
+            shChild.on('error', (e) => { log.error(`Shell nao encontrado: ${e.message}`); process.exit(1); });
+            shChild.on('exit', (code) => process.exit(code || 0));
+        } else {
+            log.error(`Falha ao executar instalador: ${err.message}`);
+            process.exit(1);
+        }
+    });
+
+    child.on('exit', (code) => process.exit(code || 0));
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// HELP
+// ═══════════════════════════════════════════════════════════════════
+
+function showHelp() {
+    console.log('');
+    console.log(color.bold(`  Neocortex Installer v${VERSION}`));
+    console.log(color.dim('  Epic & Story Development Orchestrator'));
+    console.log('');
+    console.log(`  ${color.dim('Uso:')} npx @ornexus/neocortex ${color.dim('[opcoes]')}`);
+    console.log('');
+    console.log(color.dim('  Opcoes:'));
+    console.log(`    ${color.cyan('-y, --yes')}                 Modo automatico (Claude Code only)`);
+    console.log(`    ${color.cyan('--targets=<lista>')}         Plataformas separadas por virgula`);
+    console.log(`    ${color.cyan('--create-project')}          Instalar estrutura no projeto`);
+    console.log(`    ${color.cyan('-s, --skip-project')}        Nao perguntar sobre projeto`);
+    console.log(`    ${color.cyan('-q, --quiet')}               Modo silencioso`);
+    console.log(`    ${color.cyan('--cleanup-legacy')}          Remover artefatos legados de ~/.claude/`);
+    console.log(`    ${color.cyan('--local')}                   Modo local (copia IP para desenvolvimento)`);
+    console.log(`    ${color.cyan('--server-url=<url>')}        URL do server Neocortex`);
+    console.log(`    ${color.cyan('-d, --debug')}               Modo debug`);
+    console.log(`    ${color.cyan('-h, --help')}                Mostra esta ajuda`);
+    console.log('');
+    console.log(color.dim('  Plataformas:'));
+    for (const p of PLATFORMS) {
+        const tag = p.experimental ? color.red(' [experimental]') : '';
+        console.log(`    ${color.cyan(p.key.padEnd(20))} ${p.name} ${color.dim(`(${p.label})`)}${tag}`);
+    }
+    console.log('');
+    console.log(color.dim('  Exemplos:'));
+    console.log(`    npx @ornexus/neocortex                              ${color.dim('# Selecao interativa')}`);
+    console.log(`    npx @ornexus/neocortex --yes                        ${color.dim('# Claude Code (auto)')}`);
+    console.log(`    npx @ornexus/neocortex --targets=claude-code,cursor`);
+    console.log('');
+    process.exit(0);
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// INTERACTIVE WIZARD
+// ═══════════════════════════════════════════════════════════════════
+
+async function interactiveWizard() {
+    // Detect installed platforms
+    const s = spinner();
+    s.start('Detectando plataformas instaladas...');
+    const detected = detectInstalledPlatforms();
+    const detectedNames = PLATFORMS.filter(p => detected[p.key]).map(p => p.name);
+    s.stop(
+        detectedNames.length > 0
+            ? `${detectedNames.length} plataforma(s) detectada(s): ${color.dim(detectedNames.join(', '))}`
+            : 'Nenhuma plataforma detectada automaticamente'
+    );
+
+    // Platform selection
+    const options = PLATFORMS.map(p => {
+        const hints = [];
+        if (detected[p.key]) hints.push('detectado');
+        if (p.experimental) hints.push('experimental');
+        hints.push(p.label);
+
+        return {
+            value: p.key,
+            label: p.name,
+            hint: hints.join(' | '),
+        };
+    });
+
+    const selectedPlatforms = await multiselect({
+        message: 'Selecione as plataformas de destino:',
+        options,
+        initialValues: PLATFORMS.filter(p => p.default).map(p => p.key),
+        required: true,
+    });
+
+    if (isCancel(selectedPlatforms)) {
+        cancel('Instalacao cancelada.');
+        process.exit(0);
+    }
+
+    // Show selection summary
+    const selectedNames = selectedPlatforms.map(key => {
+        const p = PLATFORMS.find(pl => pl.key === key);
+        return p.name;
+    });
+    log.info(`Plataformas: ${color.bold(selectedNames.join(', '))}`);
+
+    // Ask about project-level installation
+    let createProject = false;
+    if (!args.includes('-s') && !args.includes('--skip-project')) {
+        const projectInstall = await confirm({
+            message: 'Instalar estrutura completa no diretorio atual do projeto?',
+            initialValue: false,
+        });
+
+        if (isCancel(projectInstall)) {
+            cancel('Instalacao cancelada.');
+            process.exit(0);
+        }
+
+        createProject = projectInstall;
+    }
+
+    return { selectedPlatforms, createProject };
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// ASCII BANNER
+// ═══════════════════════════════════════════════════════════════════
+
+function showAsciiBanner() {
+    const g = (n) => `\x1b[38;5;${n}m`;
+    const r = '\x1b[0m';
+
+    // True color gradient matching neocortex-cli theme (#00B4FF → #7DD3FC → #0070A8)
+    const tc = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+    const lines = [
+        { text: '  ███╗   ██╗███████╗ ██████╗  ██████╗ ██████╗ ██████╗ ████████╗███████╗██╗  ██╗', esc: tc(0,180,255) },
+        { text: '  ████╗  ██║██╔════╝██╔═══██╗██╔════╝██╔═══██╗██╔══██╗╚══██╔══╝██╔════╝╚██╗██╔╝', esc: tc(48,191,254) },
+        { text: '  ██╔██╗ ██║█████╗  ██║   ██║██║     ██║   ██║██████╔╝   ██║   █████╗   ╚███╔╝', esc: tc(95,204,253) },
+        { text: '  ██║╚██╗██║██╔══╝  ██║   ██║██║     ██║   ██║██╔══██╗   ██║   ██╔══╝   ██╔██╗', esc: tc(102,192,236) },
+        { text: '  ██║ ╚████║███████╗╚██████╔╝╚██████╗╚██████╔╝██║  ██║   ██║   ███████╗██╔╝ ██╗', esc: tc(56,154,204) },
+        { text: '  ╚═╝  ╚═══╝╚══════╝ ╚═════╝  ╚═════╝ ╚═════╝ ╚═╝  ╚═╝   ╚═╝   ╚══════╝╚═╝  ╚═╝', esc: tc(0,112,168) },
+        { text: '', esc: '' },
+        { text: '  ──────────────────────────────────────────────────────────────────────────────────', esc: g(236) },
+        { text: `  Development Orchestrator | OrNexus Team                                v${VERSION}`, esc: g(243) },
+    ];
+
+    console.log('');
+    for (const line of lines) {
+        if (line.text === '') { console.log(''); continue; }
+        console.log(`${line.esc}${line.text}${r}`);
+    }
+    console.log('');
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// MAIN
+// ═══════════════════════════════════════════════════════════════════
+
+async function main() {
+    const platform = os.platform();
+
+    // Debug info
+    if (isDebug()) {
+        console.log(color.dim(`  [debug] Platform: ${platform} | Node: ${process.version} | Dir: ${SCRIPT_DIR}`));
+        console.log(color.dim(`  [debug] Args: ${args.join(' ') || '(none)'}`));
+        console.log('');
+    }
+
+    // Help
+    if (isHelp()) {
+        showHelp();
+        return;
+    }
+
+    // Determine selected targets
+    let selectedTargets = null;
+    let createProject = false;
+
+    // Priority 1: --targets= argument
+    const targetsArg = parseTargetsArg();
+    if (targetsArg) {
+        const validKeys = PLATFORMS.map(p => p.key);
+        const invalid = targetsArg.filter(t => !validKeys.includes(t));
+        if (invalid.length > 0) {
+            console.log('');
+            log.error(`Plataformas invalidas: ${color.bold(invalid.join(', '))}`);
+            log.info(`Validas: ${validKeys.join(', ')}`);
+            process.exit(1);
+        }
+        selectedTargets = targetsArg;
+
+        // In non-interactive mode with explicit targets, still check for project flag
+        if (args.includes('--create-project')) createProject = true;
+    }
+    // Priority 2: --yes flag = Claude Code only (backward compat)
+    else if (isAutoYes()) {
+        selectedTargets = ['claude-code'];
+        createProject = true;
+    }
+    // Priority 3: Interactive selection (if TTY)
+    else if (process.stdin.isTTY && process.stdout.isTTY) {
+        showAsciiBanner();
+        intro(color.bgWhite(color.black(` Neocortex v${VERSION} `)));
+
+        const result = await interactiveWizard();
+        selectedTargets = result.selectedPlatforms;
+        createProject = result.createProject;
+
+        if (selectedTargets.length === 0) {
+            cancel('Nenhuma plataforma selecionada.');
+            process.exit(0);
+        }
+    }
+    // Priority 4: Non-interactive, no flags = Claude Code only
+    else {
+        selectedTargets = ['claude-code'];
+    }
+
+    // ── Remote Mode Detection (Epic 43) ─────────────────────────────
+    // Detect if running as end-user (no core/ directory = npm install)
+    // vs developer (core/ exists = git clone)
+    const hasCore = fs.existsSync(path.join(SCRIPT_DIR, 'core'));
+    const hasLocalFlag = args.includes('--local');
+    const configPath = path.join(os.homedir(), '.neocortex', 'config.json');
+    const hasConfig = fs.existsSync(configPath);
+
+    if (!hasCore && !hasLocalFlag) {
+        // End-user mode: no local IP assets available
+        if (!hasConfig) {
+            // No config = not activated yet
+            log.info('');
+            log.info(color.cyan('Remote Mode Detected'));
+            log.info(color.dim('No local assets found (end-user installation).'));
+            log.info(color.dim('Content will be served by the IP Protection Server.'));
+            log.info('');
+            log.info(color.yellow('To activate your license:'));
+            log.info(color.bold('  neocortex activate NX-PRO-xxx'));
+            log.info('');
+            log.info(color.dim('Tip: Use --local to force local mode (requires core/ directory).'));
+            log.info('');
+        } else {
+            // Has config = already activated
+            try {
+                const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                if (cfg.mode === 'remote') {
+                    log.info(color.dim(`Remote mode active (server: ${cfg.serverUrl || 'default'})`));
+                }
+            } catch { /* ignore corrupted config */ }
+        }
+    }
+
+    // Dispatch to platform-specific installer
+    if (createProject) {
+        args.push('--create-project');
+    } else if (!args.includes('-s') && !args.includes('--skip-project')) {
+        args.push('--skip-project');
+    }
+
+    // Suppress shell banner when JS wizard already showed it (avoid duplicate)
+    if (process.stdin.isTTY && process.stdout.isTTY && !args.includes('-q') && !args.includes('--quiet')) {
+        args.push('--no-banner');
+    }
+
+    if (platform === 'win32') {
+        runWindows(selectedTargets);
+    } else {
+        runUnix(selectedTargets);
+    }
+}
+
+main().catch(err => {
+    log.error(err.message);
+    process.exit(1);
+});