nuclie 1.0.0

package/dist/builder/server.js

@@ -0,0 +1,253 @@
+/**
+ * Builder Server - WebSocket + REST API
+ * Serves the Visual Builder UI and provides real-time config sync
+ */
+import http from 'http';
+import { WebSocketServer } from 'ws';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { watch } from 'fs';
+import { loadConfig, saveConfig } from '../config/index.js';
+import { analyzeProject, generateSuggestions } from '../ai/analyzer.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export async function startBuilderServer(config) {
+    const { port, root } = config;
+    // Create HTTP server
+    const server = http.createServer(async (req, res) => {
+        const url = req.url || '/';
+        // CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        // API Routes
+        if (url.startsWith('/api/')) {
+            await handleAPI(req, res, url, root);
+            return;
+        }
+        // Serve builder UI
+        await serveBuilderUI(req, res, url);
+    });
+    // Create WebSocket server
+    const wss = new WebSocketServer({ server });
+    const clients = new Set();
+    wss.on('connection', (ws) => {
+        clients.add(ws);
+        // log.debug('[builder] Client connected');
+        ws.on('close', () => {
+            clients.delete(ws);
+            // log.debug('[builder] Client disconnected');
+        });
+        ws.on('message', async (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                await handleWebSocketMessage(message, ws, root);
+            }
+            catch (error) {
+                console.error('[builder] WebSocket error:', error);
+            }
+        });
+    });
+    // Watch config file for changes
+    watchConfigFile(root, (config) => {
+        broadcast(clients, { type: 'config_update', config });
+    });
+    server.listen(port, () => {
+        console.log(`\n🎨 Visual Builder running at http://localhost:${port}\n`);
+    });
+    return server;
+}
+// ===== API Handlers =====
+async function handleAPI(req, res, url, root) {
+    const path = url.replace('/api', '');
+    try {
+        // GET /api/config
+        if (path === '/config' && req.method === 'GET') {
+            const config = await loadConfig(root);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(config));
+            return;
+        }
+        // POST /api/config
+        if (path === '/config' && req.method === 'POST') {
+            const body = await getBody(req);
+            const config = JSON.parse(body);
+            await saveConfig(root, config);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true }));
+            return;
+        }
+        // GET /api/suggestions
+        if (path === '/suggestions' && req.method === 'GET') {
+            const analysis = await analyzeProject(root);
+            const suggestions = await generateSuggestions(analysis);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(suggestions));
+            return;
+        }
+        // GET /api/plugins
+        if (path === '/plugins' && req.method === 'GET') {
+            const plugins = await getAvailablePlugins();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(plugins));
+            return;
+        }
+        // GET /api/metrics
+        if (path === '/metrics' && req.method === 'GET') {
+            const metrics = await getBuildMetrics(root);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(metrics));
+            return;
+        }
+        // GET /__open-in-editor
+        if (path.startsWith('/__open-in-editor') && req.method === 'GET') {
+            const urlObj = new URL(req.url || '', `http://${req.headers.host}`);
+            const file = urlObj.searchParams.get('file');
+            const line = parseInt(urlObj.searchParams.get('line') || '1');
+            const column = parseInt(urlObj.searchParams.get('column') || '1');
+            if (file) {
+                const launch = await import('launch-editor');
+                launch.default(file, `${line}:${column}`);
+                res.writeHead(200);
+                res.end('Opened in editor');
+            }
+            else {
+                res.writeHead(400);
+                res.end('Missing file parameter');
+            }
+            return;
+        }
+        // 404
+        res.writeHead(404);
+        res.end('Not found');
+    }
+    catch (error) {
+        console.error('[builder] API error:', error);
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: error.message }));
+    }
+}
+export function broadcastError(clients, error) {
+    const message = {
+        type: 'error',
+        error: {
+            message: error.message || String(error),
+            stack: error.stack,
+            filename: error.filename,
+            lineno: error.lineno,
+            colno: error.colno,
+            frame: error.frame
+        }
+    };
+    broadcast(clients, message);
+}
+// ===== Builder UI Server =====
+async function serveBuilderUI(req, res, url) {
+    let filePath;
+    if (url === '/' || url === '/index.html') {
+        filePath = path.join(process.cwd(), 'public', 'builder', 'index.html');
+    }
+    else if (url.startsWith('/builder/')) {
+        filePath = path.join(process.cwd(), 'public', url);
+    }
+    else {
+        filePath = path.join(process.cwd(), 'public', 'builder', url);
+    }
+    try {
+        const data = await fs.readFile(filePath);
+        const ext = path.extname(filePath);
+        const mimeTypes = {
+            '.html': 'text/html',
+            '.css': 'text/css',
+            '.js': 'application/javascript',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.svg': 'image/svg+xml'
+        };
+        const contentType = mimeTypes[ext] || 'application/octet-stream';
+        res.writeHead(200, { 'Content-Type': contentType });
+        res.end(data);
+    }
+    catch (error) {
+        // Serve index.html for SPA routes
+        try {
+            const indexPath = path.join(process.cwd(), 'public', 'builder', 'index.html');
+            const data = await fs.readFile(indexPath);
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(data);
+        }
+        catch {
+            res.writeHead(404);
+            res.end('Not found');
+        }
+    }
+}
+// ===== WebSocket Handlers =====
+async function handleWebSocketMessage(message, ws, root) {
+    switch (message.type) {
+        case 'get_config':
+            const config = await loadConfig(root);
+            ws.send(JSON.stringify({ type: 'config_update', config }));
+            break;
+        case 'save_config':
+            await saveConfig(root, message.config);
+            ws.send(JSON.stringify({ type: 'config_saved', success: true }));
+            break;
+    }
+}
+function broadcast(clients, message) {
+    const data = JSON.stringify(message);
+    clients.forEach(client => {
+        if (client.readyState === 1) { // OPEN
+            client.send(data);
+        }
+    });
+}
+// ===== File Watcher =====
+function watchConfigFile(root, onChange) {
+    const configPaths = [
+        path.join(root, 'nuclie.build.json'),
+        path.join(root, 'nuclie.build.ts')
+    ];
+    configPaths.forEach(configPath => {
+        watch(configPath, { persistent: false }, async () => {
+            try {
+                const config = await loadConfig(root);
+                onChange(config);
+            }
+            catch (error) {
+                console.error('[builder] Error watching config:', error);
+            }
+        });
+    });
+}
+// ===== Helper Functions =====
+function getBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+async function getAvailablePlugins() {
+    // In production, this would scan the plugins directory
+    return [
+        { name: 'sample-plugin-esm', version: '1.0.0', description: 'Sample plugin', installed: true },
+        { name: 'react-refresh', version: '2.0.0', description: 'React Fast Refresh', installed: true }
+    ];
+}
+async function getBuildMetrics(root) {
+    // In production, this would read actual build metrics
+    return {
+        buildTime: 0,
+        bundleSize: 0,
+        hmrUpdates: 0
+    };
+}

package/dist/cache/incremental.d.ts

@@ -0,0 +1,75 @@
+export interface FileMetadata {
+    path: string;
+    hash: string;
+    size: number;
+    mtime: number;
+}
+export interface BuildManifest {
+    version: string;
+    timestamp: number;
+    files: Record<string, FileMetadata>;
+    dependencies: Record<string, string>;
+    outputs: Record<string, string[]>;
+}
+/**
+ * Incremental Build Manager
+ * Tracks file changes and determines what needs to be rebuilt
+ */
+export declare class IncrementalBuildManager {
+    private root;
+    private cacheDir;
+    private manifestPath;
+    private currentManifest;
+    private previousManifest;
+    constructor(root: string);
+    initialize(): Promise<void>;
+    /**
+     * Compute hash for a file
+     */
+    private hashFile;
+    /**
+     * Get file metadata
+     */
+    private getFileMetadata;
+    /**
+     * Check if a file has changed since last build
+     */
+    hasFileChanged(filePath: string): Promise<boolean>;
+    /**
+     * Get list of changed files from a set of input files
+     */
+    getChangedFiles(inputFiles: string[]): Promise<{
+        changed: string[];
+        unchanged: string[];
+        new: string[];
+        deleted: string[];
+    }>;
+    /**
+     * Track a file in the current build
+     */
+    trackFile(filePath: string, dependencies?: string[]): Promise<void>;
+    /**
+     * Track output files for an input file
+     */
+    trackOutput(inputFile: string, outputFiles: string[]): void;
+    /**
+     * Get cached outputs for an input file (if unchanged)
+     */
+    getCachedOutputs(inputFile: string): Promise<string[] | null>;
+    /**
+     * Save the current manifest
+     */
+    save(): Promise<void>;
+    /**
+     * Get build statistics
+     */
+    getStats(): {
+        totalFiles: number;
+        changedFiles: number;
+        cacheHitRate: number;
+    };
+    /**
+     * Clear the incremental cache
+     */
+    clear(): Promise<void>;
+}

package/dist/cache/incremental.js

@@ -0,0 +1,200 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import { log } from '../utils/logger.js';
+/**
+ * Incremental Build Manager
+ * Tracks file changes and determines what needs to be rebuilt
+ */
+export class IncrementalBuildManager {
+    constructor(root) {
+        this.currentManifest = null;
+        this.previousManifest = null;
+        this.root = root;
+        this.cacheDir = path.join(root, '.nuclie', 'incremental');
+        this.manifestPath = path.join(this.cacheDir, 'build-manifest.json');
+    }
+    async initialize() {
+        await fs.mkdir(this.cacheDir, { recursive: true });
+        // Load previous manifest
+        try {
+            const data = await fs.readFile(this.manifestPath, 'utf-8');
+            this.previousManifest = JSON.parse(data);
+            log.debug('Loaded previous build manifest', {
+                category: 'cache',
+                files: Object.keys(this.previousManifest?.files || {}).length
+            });
+        }
+        catch (e) {
+            log.debug('No previous build manifest found', { category: 'cache' });
+        }
+        // Initialize current manifest
+        this.currentManifest = {
+            version: '1.0.0',
+            timestamp: Date.now(),
+            files: {},
+            dependencies: {},
+            outputs: {}
+        };
+    }
+    /**
+     * Compute hash for a file
+     */
+    async hashFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath);
+            return crypto.createHash('sha256').update(content).digest('hex');
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    /**
+     * Get file metadata
+     */
+    async getFileMetadata(filePath) {
+        try {
+            const stats = await fs.stat(filePath);
+            const hash = await this.hashFile(filePath);
+            return {
+                path: filePath,
+                hash,
+                size: stats.size,
+                mtime: stats.mtimeMs
+            };
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    /**
+     * Check if a file has changed since last build
+     */
+    async hasFileChanged(filePath) {
+        if (!this.previousManifest)
+            return true;
+        const previousMeta = this.previousManifest.files[filePath];
+        if (!previousMeta)
+            return true;
+        const currentMeta = await this.getFileMetadata(filePath);
+        if (!currentMeta)
+            return true;
+        // Quick check: mtime and size
+        if (currentMeta.mtime !== previousMeta.mtime ||
+            currentMeta.size !== previousMeta.size) {
+            // Verify with hash
+            return currentMeta.hash !== previousMeta.hash;
+        }
+        return false;
+    }
+    /**
+     * Get list of changed files from a set of input files
+     */
+    async getChangedFiles(inputFiles) {
+        const changed = [];
+        const unchanged = [];
+        const newFiles = [];
+        const previousFiles = this.previousManifest ?
+            new Set(Object.keys(this.previousManifest.files)) :
+            new Set();
+        for (const file of inputFiles) {
+            const hasChanged = await this.hasFileChanged(file);
+            const isNew = !previousFiles.has(file);
+            if (isNew) {
+                newFiles.push(file);
+                changed.push(file);
+            }
+            else if (hasChanged) {
+                changed.push(file);
+            }
+            else {
+                unchanged.push(file);
+            }
+            previousFiles.delete(file);
+        }
+        // Remaining files in previousFiles are deleted
+        const deleted = Array.from(previousFiles);
+        return { changed, unchanged, new: newFiles, deleted };
+    }
+    /**
+     * Track a file in the current build
+     */
+    async trackFile(filePath, dependencies) {
+        const metadata = await this.getFileMetadata(filePath);
+        if (!metadata || !this.currentManifest)
+            return;
+        this.currentManifest.files[filePath] = metadata;
+        // Track dependencies
+        if (dependencies && dependencies.length > 0) {
+            const depsHash = crypto.createHash('sha256')
+                .update(dependencies.sort().join('|'))
+                .digest('hex');
+            this.currentManifest.dependencies[filePath] = depsHash;
+        }
+    }
+    /**
+     * Track output files for an input file
+     */
+    trackOutput(inputFile, outputFiles) {
+        if (!this.currentManifest)
+            return;
+        this.currentManifest.outputs[inputFile] = outputFiles;
+    }
+    /**
+     * Get cached outputs for an input file (if unchanged)
+     */
+    async getCachedOutputs(inputFile) {
+        if (!this.previousManifest)
+            return null;
+        const hasChanged = await this.hasFileChanged(inputFile);
+        if (hasChanged)
+            return null;
+        return this.previousManifest.outputs[inputFile] || null;
+    }
+    /**
+     * Save the current manifest
+     */
+    async save() {
+        if (!this.currentManifest)
+            return;
+        await fs.writeFile(this.manifestPath, JSON.stringify(this.currentManifest, null, 2), 'utf-8');
+        log.info('Incremental build manifest saved', {
+            category: 'cache',
+            files: Object.keys(this.currentManifest.files).length
+        });
+    }
+    /**
+     * Get build statistics
+     */
+    getStats() {
+        if (!this.currentManifest || !this.previousManifest) {
+            return {
+                totalFiles: 0,
+                changedFiles: 0,
+                cacheHitRate: 0
+            };
+        }
+        const totalFiles = Object.keys(this.currentManifest.files).length;
+        const previousTotal = Object.keys(this.previousManifest.files).length;
+        const changedFiles = totalFiles - previousTotal;
+        const cacheHitRate = previousTotal > 0 ?
+            ((previousTotal - changedFiles) / previousTotal) * 100 : 0;
+        return {
+            totalFiles,
+            changedFiles,
+            cacheHitRate
+        };
+    }
+    /**
+     * Clear the incremental cache
+     */
+    async clear() {
+        try {
+            await fs.rm(this.cacheDir, { recursive: true, force: true });
+            log.info('Incremental cache cleared', { category: 'cache' });
+        }
+        catch (e) {
+            log.warn('Failed to clear incremental cache', { category: 'cache', error: e });
+        }
+    }
+}

package/dist/cache/index.d.ts

@@ -0,0 +1,17 @@
+export interface CacheEntry {
+    key: string;
+    outDir: string;
+    files: string[];
+    created: number;
+}
+export declare class DiskCache {
+    dir: string;
+    constructor(base: string);
+    ensure(): Promise<void>;
+    keyFromFiles(paths: string[]): Promise<string>;
+    has(key: string): Promise<boolean>;
+    get(key: string): Promise<CacheEntry | null>;
+    put(entry: CacheEntry): Promise<void>;
+    putFiles(key: string, files: string[]): Promise<void>;
+    restoreFiles(key: string, targetOutDir: string): Promise<boolean>;
+}