@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/clients/ws-client.js

@@ -0,0 +1,93 @@
+import { logger } from '../utils';
+/**
+ * WebSocket Client for streaming communication
+ */
+export class WebSocketClient {
+    url;
+    ws = null;
+    options;
+    reconnectAttempts = 0;
+    messageHandlers = new Set();
+    errorHandlers = new Set();
+    closeHandlers = new Set();
+    constructor(url, options = {}) {
+        this.url = url;
+        this.options = {
+            reconnect: options.reconnect ?? true,
+            reconnectInterval: options.reconnectInterval ?? 3000,
+            maxReconnectAttempts: options.maxReconnectAttempts ?? 5,
+        };
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.url);
+                this.ws.onopen = () => {
+                    logger.info(`WebSocket connected to ${this.url}`);
+                    this.reconnectAttempts = 0;
+                    resolve();
+                };
+                this.ws.onmessage = event => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        this.messageHandlers.forEach(handler => handler(data));
+                    }
+                    catch (error) {
+                        logger.error('Failed to parse WebSocket message', error);
+                    }
+                };
+                this.ws.onerror = event => {
+                    logger.error('WebSocket error', event);
+                    this.errorHandlers.forEach(handler => handler(event));
+                    reject(event);
+                };
+                this.ws.onclose = () => {
+                    logger.warn(`WebSocket disconnected from ${this.url}`);
+                    this.closeHandlers.forEach(handler => handler());
+                    // Auto-reconnect
+                    if (this.options.reconnect &&
+                        this.reconnectAttempts < this.options.maxReconnectAttempts) {
+                        this.reconnectAttempts++;
+                        logger.info(`Attempting to reconnect (${this.reconnectAttempts}/${this.options.maxReconnectAttempts})...`);
+                        setTimeout(() => {
+                            this.connect().catch(() => {
+                                // Ignore, will retry or give up
+                            });
+                        }, this.options.reconnectInterval);
+                    }
+                };
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    send(data) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket is not connected');
+        }
+        this.ws.send(JSON.stringify(data));
+    }
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+        return () => this.messageHandlers.delete(handler);
+    }
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        return () => this.errorHandlers.delete(handler);
+    }
+    onClose(handler) {
+        this.closeHandlers.add(handler);
+        return () => this.closeHandlers.delete(handler);
+    }
+    close() {
+        if (this.ws) {
+            this.options.reconnect = false; // Prevent auto-reconnect
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    isConnected() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    }
+}

package/dist/src/commands/alias.js

@@ -0,0 +1,91 @@
+/**
+ * Alias Command — L2
+ *
+ * Create, list, and remove command aliases stored in ~/.nimbus/aliases.json.
+ *
+ * Usage:
+ *   nimbus alias deploy=run --auto-approve "deploy staging"
+ *   nimbus alias list
+ *   nimbus alias remove deploy
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { ui } from '../wizard/ui';
+const ALIASES_FILE = path.join(os.homedir(), '.nimbus', 'aliases.json');
+function loadAliases() {
+    try {
+        return JSON.parse(fs.readFileSync(ALIASES_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveAliases(aliases) {
+    const dir = path.dirname(ALIASES_FILE);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(ALIASES_FILE, JSON.stringify(aliases, null, 2), 'utf-8');
+}
+/**
+ * Resolve the first arg as an alias if one exists.
+ * Returns the original args unchanged if no alias matches.
+ */
+export function resolveAlias(args) {
+    if (!args.length)
+        return args;
+    const aliases = loadAliases();
+    const expanded = aliases[args[0]];
+    if (!expanded)
+        return args;
+    // Split the alias value on spaces and prepend to remaining args
+    return [...expanded.split(' '), ...args.slice(1)];
+}
+/**
+ * Alias command handler.
+ */
+export async function aliasCommand(subcommand, args) {
+    const aliases = loadAliases();
+    if (subcommand === 'list' || (!subcommand && args.length === 0)) {
+        ui.header('Command Aliases');
+        const entries = Object.entries(aliases);
+        if (entries.length === 0) {
+            ui.info('No aliases defined. Create one: nimbus alias <name>=<command>');
+            return;
+        }
+        for (const [name, cmd] of entries) {
+            ui.print(`  ${ui.color(name, 'green')} = ${cmd}`);
+        }
+        return;
+    }
+    if (subcommand === 'remove' || subcommand === 'rm') {
+        const name = args[0];
+        if (!name) {
+            ui.error('Usage: nimbus alias remove <name>');
+            process.exit(1);
+        }
+        if (!(name in aliases)) {
+            ui.warning(`Alias "${name}" not found`);
+            return;
+        }
+        delete aliases[name];
+        saveAliases(aliases);
+        ui.success(`Removed alias: ${name}`);
+        return;
+    }
+    // Create alias: subcommand is "<name>=<rest>" or subcommand is the name and args hold the expansion
+    const raw = subcommand + (args.length ? ' ' + args.join(' ') : '');
+    const eqIdx = raw.indexOf('=');
+    if (eqIdx === -1) {
+        ui.error('Usage: nimbus alias <name>=<command>  or  nimbus alias list  or  nimbus alias remove <name>');
+        process.exit(1);
+    }
+    const name = raw.slice(0, eqIdx).trim();
+    const cmd = raw.slice(eqIdx + 1).trim();
+    if (!name || !cmd) {
+        ui.error('Alias name and command must not be empty');
+        process.exit(1);
+    }
+    aliases[name] = cmd;
+    saveAliases(aliases);
+    ui.success(`Alias set: ${ui.color(name, 'green')} = ${cmd}`);
+}

package/dist/src/commands/analyze/index.js

@@ -0,0 +1,313 @@
+/**
+ * Analyze Command
+ * Codebase analysis and refactoring suggestions
+ */
+import { ui } from '../../wizard/ui';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Parse analyze options
+ */
+export function parseAnalyzeOptions(args) {
+    const options = {
+        type: 'all',
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--type' && args[i + 1]) {
+            options.type = args[++i];
+        }
+        else if (arg === '--path' && args[i + 1]) {
+            options.path = args[++i];
+        }
+        else if (arg === '--json') {
+            options.json = true;
+        }
+        else if (arg === '--security') {
+            // Shortcut for --type security
+            options.type = 'security';
+        }
+        else if (arg === '--compliance' && args[i + 1]) {
+            // Set compliance standard (soc2, hipaa, pci)
+            options.type = 'security';
+            options.compliance = args[++i];
+        }
+        else if (!arg.startsWith('-') && !options.path) {
+            options.path = arg;
+        }
+    }
+    return options;
+}
+/**
+ * Get files to analyze
+ */
+function getFilesToAnalyze(basePath, extensions) {
+    const files = [];
+    function walk(dir) {
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                // Skip node_modules, .git, etc.
+                if (entry.isDirectory()) {
+                    if (!['node_modules', '.git', 'dist', 'build', 'coverage'].includes(entry.name)) {
+                        walk(fullPath);
+                    }
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name);
+                    if (extensions.includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore permission errors
+        }
+    }
+    walk(basePath);
+    return files;
+}
+/**
+ * Analyze a single file for potential improvements
+ */
+function analyzeFile(filePath, type) {
+    const suggestions = [];
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const relativePath = path.relative(process.cwd(), filePath);
+        // Simple pattern-based analysis
+        lines.forEach((line, index) => {
+            const lineNum = index + 1;
+            // Complexity: Long lines
+            if (type === 'all' || type === 'refactor') {
+                if (line.length > 120) {
+                    suggestions.push({
+                        file: relativePath,
+                        line: lineNum,
+                        type: 'style',
+                        severity: 'info',
+                        explanation: `Line exceeds 120 characters (${line.length}). Consider breaking it up.`,
+                    });
+                }
+                // Nested callbacks (callback hell indicator)
+                const nestedCallbacks = (line.match(/\)\s*=>\s*\{/g) || []).length;
+                if (nestedCallbacks >= 2) {
+                    suggestions.push({
+                        file: relativePath,
+                        line: lineNum,
+                        type: 'complexity',
+                        severity: 'warning',
+                        explanation: 'Multiple nested arrow functions detected. Consider extracting to named functions.',
+                    });
+                }
+                // TODO/FIXME comments
+                if (/\/\/\s*(TODO|FIXME|HACK|XXX)/i.test(line)) {
+                    suggestions.push({
+                        file: relativePath,
+                        line: lineNum,
+                        type: 'style',
+                        severity: 'info',
+                        explanation: 'TODO/FIXME comment found. Consider addressing or tracking this.',
+                    });
+                }
+            }
+            // Security checks
+            if (type === 'all' || type === 'security') {
+                // Hardcoded secrets patterns (variable names or quoted strings)
+                if (/\b(?:password|secret|api[_-]?key|token)\b\s*[:=]/i.test(line)) {
+                    suggestions.push({
+                        file: relativePath,
+                        line: lineNum,
+                        type: 'security',
+                        severity: 'error',
+                        explanation: 'Potential hardcoded credential detected. Use environment variables instead.',
+                    });
+                }
+                // eval() usage
+                if (/\beval\s*\(/.test(line)) {
+                    suggestions.push({
+                        file: relativePath,
+                        line: lineNum,
+                        type: 'security',
+                        severity: 'error',
+                        explanation: 'eval() usage detected. This can lead to code injection vulnerabilities.',
+                    });
+                }
+                // SQL injection potential
+                if (/\$\{.*\}.*(?:SELECT|INSERT|UPDATE|DELETE|FROM|WHERE)/i.test(line)) {
+                    suggestions.push({
+                        file: relativePath,
+                        line: lineNum,
+                        type: 'security',
+                        severity: 'warning',
+                        explanation: 'Potential SQL injection. Use parameterized queries instead of string interpolation.',
+                    });
+                }
+            }
+            // Documentation checks
+            if (type === 'all' || type === 'docs') {
+                // Functions without JSDoc
+                if (/^(?:export\s+)?(?:async\s+)?function\s+\w+/.test(line)) {
+                    const prevLine = index > 0 ? lines[index - 1] : '';
+                    if (!/\*\/\s*$/.test(prevLine)) {
+                        suggestions.push({
+                            file: relativePath,
+                            line: lineNum,
+                            type: 'style',
+                            severity: 'info',
+                            explanation: 'Function lacks JSDoc documentation.',
+                        });
+                    }
+                }
+            }
+        });
+        // File-level checks
+        if (type === 'all' || type === 'refactor') {
+            // Large file
+            if (lines.length > 500) {
+                suggestions.push({
+                    file: relativePath,
+                    line: 1,
+                    type: 'complexity',
+                    severity: 'warning',
+                    explanation: `File has ${lines.length} lines. Consider splitting into smaller modules.`,
+                });
+            }
+        }
+    }
+    catch {
+        // Skip files we can't read
+    }
+    return suggestions;
+}
+/**
+ * Display severity with color
+ */
+function formatSeverity(severity) {
+    switch (severity) {
+        case 'error':
+            return ui.color('ERROR', 'red');
+        case 'warning':
+            return ui.color('WARN', 'yellow');
+        case 'info':
+        default:
+            return ui.color('INFO', 'blue');
+    }
+}
+/**
+ * Analyze command
+ */
+export async function analyzeCommand(options) {
+    const targetPath = options.path || process.cwd();
+    if (!fs.existsSync(targetPath)) {
+        ui.error(`Path not found: ${targetPath}`);
+        return;
+    }
+    ui.header('Nimbus Analyze', targetPath);
+    ui.startSpinner({ message: 'Analyzing codebase...' });
+    // Get files to analyze
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs'];
+    const files = getFilesToAnalyze(targetPath, extensions);
+    if (files.length === 0) {
+        ui.stopSpinnerSuccess('No files found to analyze');
+        return;
+    }
+    // Analyze files
+    const allSuggestions = [];
+    for (const file of files) {
+        const suggestions = analyzeFile(file, options.type);
+        allSuggestions.push(...suggestions);
+    }
+    ui.stopSpinnerSuccess(`Analyzed ${files.length} files`);
+    // Track analysis completion
+    try {
+        const { trackEvent } = await import('../../telemetry');
+        trackEvent('analysis_completed', {
+            filesAnalyzed: files.length,
+            suggestionsCount: allSuggestions.length,
+        });
+    }
+    catch {
+        /* telemetry failure is non-critical */
+    }
+    // Build analysis result
+    const byType = {};
+    const bySeverity = {};
+    for (const s of allSuggestions) {
+        byType[s.type] = (byType[s.type] || 0) + 1;
+        bySeverity[s.severity] = (bySeverity[s.severity] || 0) + 1;
+    }
+    const analysis = {
+        path: targetPath,
+        analyzedAt: new Date().toISOString(),
+        summary: {
+            filesAnalyzed: files.length,
+            suggestionsCount: allSuggestions.length,
+            byType,
+            bySeverity,
+        },
+        suggestions: allSuggestions,
+    };
+    if (options.json) {
+        console.log(JSON.stringify(analysis, null, 2));
+        return;
+    }
+    // Display results
+    ui.newLine();
+    ui.section('Summary');
+    ui.print(`  Files analyzed:    ${analysis.summary.filesAnalyzed}`);
+    ui.print(`  Total suggestions: ${analysis.summary.suggestionsCount}`);
+    if (analysis.summary.suggestionsCount > 0) {
+        ui.newLine();
+        ui.print('  By severity:');
+        if (bySeverity.error) {
+            ui.print(`    ${ui.color('Errors:', 'red')}   ${bySeverity.error}`);
+        }
+        if (bySeverity.warning) {
+            ui.print(`    ${ui.color('Warnings:', 'yellow')} ${bySeverity.warning}`);
+        }
+        if (bySeverity.info) {
+            ui.print(`    ${ui.color('Info:', 'blue')}     ${bySeverity.info}`);
+        }
+        ui.newLine();
+        ui.print('  By type:');
+        for (const [type, count] of Object.entries(byType)) {
+            ui.print(`    ${type}: ${count}`);
+        }
+    }
+    // Show top suggestions
+    if (allSuggestions.length > 0) {
+        ui.section('Suggestions');
+        // Sort by severity (error > warning > info)
+        const sorted = allSuggestions.sort((a, b) => {
+            const order = { error: 0, warning: 1, info: 2 };
+            return order[a.severity] - order[b.severity];
+        });
+        // Show top 20
+        const toShow = sorted.slice(0, 20);
+        for (const suggestion of toShow) {
+            ui.newLine();
+            ui.print(`  ${formatSeverity(suggestion.severity)} ${suggestion.file}:${suggestion.line}`);
+            ui.print(`    ${ui.dim(suggestion.type)}: ${suggestion.explanation}`);
+            if (suggestion.diff) {
+                ui.sideBySideDiff({
+                    original: suggestion.original || '',
+                    modified: suggestion.suggested || '',
+                });
+            }
+        }
+        if (allSuggestions.length > 20) {
+            ui.newLine();
+            ui.dim(`  ... and ${allSuggestions.length - 20} more suggestions`);
+            ui.dim(`  Use --json for full output`);
+        }
+    }
+    else {
+        ui.newLine();
+        ui.success('No issues found!');
+    }
+    ui.newLine();
+}