nuclie 1.0.0

package/dist/ai/analyzer.js

@@ -0,0 +1,202 @@
+/**
+ * AI Analyzer - Project analysis and optimization suggestions
+ * Simple rule-based system (can be upgraded to LLM later)
+ */
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Analyze project structure and detect framework
+ */
+export async function analyzeProject(root) {
+    const analysis = {
+        framework: 'unknown',
+        typescript: false,
+        packageManager: 'npm',
+        dependencies: [],
+        fileCount: 0,
+        totalSize: 0,
+        entryPoints: []
+    };
+    try {
+        // Check for package.json
+        const packagePath = path.join(root, 'package.json');
+        try {
+            const packageData = await fs.readFile(packagePath, 'utf-8');
+            const pkg = JSON.parse(packageData);
+            // Detect framework
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            analysis.dependencies = Object.keys(deps);
+            if (deps['react'] || deps['react-dom']) {
+                analysis.framework = 'react';
+            }
+            else if (deps['vue']) {
+                analysis.framework = 'vue';
+            }
+            else if (deps['svelte']) {
+                analysis.framework = 'svelte';
+            }
+            else {
+                analysis.framework = 'vanilla';
+            }
+            // Detect TypeScript
+            analysis.typescript = !!(deps['typescript'] || deps['@types/node']);
+        }
+        catch (error) {
+            // No package.json
+        }
+        // Detect package manager
+        try {
+            await fs.access(path.join(root, 'pnpm-lock.yaml'));
+            analysis.packageManager = 'pnpm';
+        }
+        catch {
+            try {
+                await fs.access(path.join(root, 'yarn.lock'));
+                analysis.packageManager = 'yarn';
+            }
+            catch {
+                analysis.packageManager = 'npm';
+            }
+        }
+        // Count files in src/
+        try {
+            const srcPath = path.join(root, 'src');
+            const files = await getFiles(srcPath);
+            analysis.fileCount = files.length;
+            analysis.totalSize = await getTotalSize(files);
+            // Find entry points
+            const entryFiles = files.filter(f => f.includes('main.') || f.includes('index.') || f.includes('app.'));
+            analysis.entryPoints = entryFiles.map(f => path.relative(root, f));
+        }
+        catch (error) {
+            // No src directory
+        }
+    }
+    catch (error) {
+        console.error('[ai] Analysis error:', error);
+    }
+    return analysis;
+}
+/**
+ * Generate optimization suggestions based on project analysis
+ */
+export async function generateSuggestions(analysis) {
+    const suggestions = [];
+    // Performance suggestions
+    if (analysis.fileCount > 100) {
+        suggestions.push({
+            type: 'performance',
+            icon: '⚡',
+            title: 'Enable Code Splitting',
+            description: 'Your project has ' + analysis.fileCount + ' files. Code splitting can reduce initial bundle size by up to 40%.',
+            action: 'Enable',
+            priority: 9
+        });
+    }
+    if (analysis.fileCount > 50) {
+        suggestions.push({
+            type: 'performance',
+            icon: '🚀',
+            title: 'Use Native Worker',
+            description: 'Switch to Rust native worker for ~20x faster plugin execution. Recommended for projects with 50+ files.',
+            action: 'Enable',
+            priority: 8
+        });
+    }
+    // Framework-specific suggestions
+    if (analysis.framework === 'react') {
+        suggestions.push({
+            type: 'dx',
+            icon: '⚛️',
+            title: 'React Fast Refresh',
+            description: 'Enable React Fast Refresh for instant component updates without losing state.',
+            action: 'Enable',
+            priority: 7
+        });
+    }
+    if (analysis.framework === 'vue') {
+        suggestions.push({
+            type: 'dx',
+            icon: '💚',
+            title: 'Vue SFC Plugin',
+            description: 'Install Vue Single File Component plugin for better development experience.',
+            action: 'Install',
+            priority: 7
+        });
+    }
+    // TypeScript suggestions
+    if (analysis.typescript) {
+        suggestions.push({
+            type: 'best-practice',
+            icon: '📘',
+            title: 'TypeScript Config',
+            description: 'Use nuclie.config.ts instead of JSON for type-safe configuration with IntelliSense.',
+            action: 'Convert',
+            priority: 6
+        });
+    }
+    // Development suggestions
+    suggestions.push({
+        type: 'best-practice',
+        icon: '🗺️',
+        title: 'Source Maps',
+        description: 'Enable source maps in development mode for better debugging experience.',
+        action: 'Enable',
+        priority: 5
+    });
+    suggestions.push({
+        type: 'dx',
+        icon: '🔥',
+        title: 'Hot Module Replacement',
+        description: 'HMR allows you to see changes instantly without full page reload.',
+        action: 'Enable',
+        priority: 7
+    });
+    // Security suggestions
+    suggestions.push({
+        type: 'security',
+        icon: '🔒',
+        title: 'Plugin Verification',
+        description: 'Ensure all plugins are signed and verified before production deployment.',
+        action: 'Review',
+        priority: 8
+    });
+    // Sort by priority (highest first)
+    return suggestions.sort((a, b) => b.priority - a.priority);
+}
+// ===== Helper Functions =====
+async function getFiles(dir) {
+    const files = [];
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                    const subFiles = await getFiles(fullPath);
+                    files.push(...subFiles);
+                }
+            }
+            else {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch (error) {
+        // Directory doesn't exist or not accessible
+    }
+    return files;
+}
+async function getTotalSize(files) {
+    let total = 0;
+    for (const file of files) {
+        try {
+            const stats = await fs.stat(file);
+            total += stats.size;
+        }
+        catch (error) {
+            // File not accessible
+        }
+    }
+    return total;
+}

package/dist/ai/chat/cli.d.ts

@@ -0,0 +1,3 @@
+export declare class ChatCLI {
+    static start(root: string): Promise<void>;
+}

package/dist/ai/chat/cli.js

@@ -0,0 +1,38 @@
+import { AIClient } from '../client.js';
+import { Analyzer } from '../optimizer/analyzer.js';
+import { log } from '../../utils/logger.js';
+import { createInterface } from 'readline';
+export class ChatCLI {
+    static async start(root) {
+        const client = new AIClient({ provider: 'local' }, root);
+        await client.init();
+        const analyzer = new Analyzer(root);
+        const profile = await analyzer.analyze();
+        console.log('\n🤖 Nuclie AI Chat');
+        console.log('Type "exit" to quit.\n');
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const systemPrompt = `You are an expert build tool assistant. 
+        Project Context: Framework=${profile.framework}, Language=${profile.language}.
+        Answer questions about configuration, errors, and best practices.`;
+        const ask = () => {
+            rl.question('You: ', async (input) => {
+                if (input.toLowerCase() === 'exit') {
+                    rl.close();
+                    return;
+                }
+                try {
+                    const response = await client.complete(input, systemPrompt);
+                    console.log(`\nAI: ${response}\n`);
+                }
+                catch (e) {
+                    log.error('Chat failed', { error: e });
+                }
+                ask();
+            });
+        };
+        ask();
+    }
+}

package/dist/ai/client.d.ts

@@ -0,0 +1,17 @@
+export interface AIConfig {
+    provider: 'openai' | 'groq' | 'anthropic' | 'local';
+    apiKey?: string;
+    model?: string;
+    localEndpoint?: string;
+}
+export declare class AIClient {
+    private config;
+    private cacheDir;
+    constructor(config: AIConfig, rootDir: string);
+    init(): Promise<void>;
+    complete(prompt: string, systemPrompt?: string): Promise<string>;
+    private getCacheKey;
+    private getFromCache;
+    private saveToCache;
+    private mockLocalInference;
+}

package/dist/ai/client.js

@@ -0,0 +1,68 @@
+import { log } from '../utils/logger.js';
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+export class AIClient {
+    constructor(config, rootDir) {
+        this.config = config;
+        this.cacheDir = path.join(rootDir, '.nuclie', 'ai-cache');
+    }
+    async init() {
+        await fs.mkdir(this.cacheDir, { recursive: true });
+    }
+    async complete(prompt, systemPrompt) {
+        const cacheKey = this.getCacheKey(prompt, systemPrompt);
+        const cached = await this.getFromCache(cacheKey);
+        if (cached) {
+            log.debug('AI Cache hit', { category: 'ai' });
+            return cached;
+        }
+        log.info('Querying AI Model...', { category: 'ai' });
+        let response = '';
+        try {
+            if (this.config.provider === 'local') {
+                response = await this.mockLocalInference(prompt);
+            }
+            else {
+                // Placeholder for real API calls
+                // await this.callProvider(prompt, systemPrompt);
+                response = `[Mock AI Response] Analysis of: ${prompt.substring(0, 50)}...`;
+            }
+            await this.saveToCache(cacheKey, response);
+            return response;
+        }
+        catch (e) {
+            log.error('AI Request failed', { error: e });
+            throw e;
+        }
+    }
+    getCacheKey(prompt, system) {
+        const hash = crypto.createHash('sha256');
+        hash.update(prompt);
+        if (system)
+            hash.update(system);
+        hash.update(this.config.model || 'default');
+        return hash.digest('hex');
+    }
+    async getFromCache(key) {
+        try {
+            return await fs.readFile(path.join(this.cacheDir, key), 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveToCache(key, content) {
+        try {
+            await fs.writeFile(path.join(this.cacheDir, key), content);
+        }
+        catch (e) {
+            // Ignore cache write errors
+        }
+    }
+    async mockLocalInference(prompt) {
+        // Simulate latency
+        await new Promise(r => setTimeout(r, 500));
+        return "Local AI: I see you're trying to build something cool. Here is a suggestion...";
+    }
+}

package/dist/ai/cloud/api.d.ts

@@ -0,0 +1,28 @@
+import { AnonymizedLearning } from './telemetry.js';
+import { AIConfig } from '../config.js';
+export interface CloudResponse {
+    success: boolean;
+    newPatterns: number;
+    improvedAccuracy: string;
+    modelVersion: string;
+    message?: string;
+}
+export interface GlobalPattern {
+    errorSignature: string;
+    fixSignature: string;
+    successRate: number;
+    usageCount: number;
+    framework: string;
+    fix: any;
+}
+export declare class CloudAPI {
+    private config;
+    private baseUrl;
+    private apiKey;
+    private userId;
+    constructor(config: AIConfig);
+    private getOrCreateUserId;
+    uploadLearnings(learnings: AnonymizedLearning[]): Promise<CloudResponse>;
+    downloadPatterns(limit?: number): Promise<GlobalPattern[]>;
+    checkHealth(): Promise<boolean>;
+}

package/dist/ai/cloud/api.js

@@ -0,0 +1,118 @@
+import { log } from '../../utils/logger.js';
+export class CloudAPI {
+    constructor(config) {
+        this.config = config;
+        // Production API endpoint
+        this.baseUrl = process.env.NUCLIE_CLOUD_API || 'https://api.nuclie.build';
+        this.apiKey = config.apiKey || process.env.NUCLIE_API_KEY || '';
+        this.userId = this.getOrCreateUserId();
+    }
+    getOrCreateUserId() {
+        // Generate anonymous user ID (stored locally)
+        const fs = require('fs');
+        const path = require('path');
+        const configPath = path.join(process.env.HOME || process.env.USERPROFILE || '', '.nuclie', 'user.json');
+        try {
+            if (fs.existsSync(configPath)) {
+                const data = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                return data.userId;
+            }
+        }
+        catch (e) {
+            // Ignore
+        }
+        // Create new anonymous ID
+        const userId = 'anon-' + Math.random().toString(36).substring(2, 15);
+        try {
+            const dir = path.dirname(configPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(configPath, JSON.stringify({ userId, createdAt: Date.now() }));
+        }
+        catch (e) {
+            log.warn('Could not save user ID', { category: 'ai' });
+        }
+        return userId;
+    }
+    async uploadLearnings(learnings) {
+        if (!this.config.enabled || this.config.provider === 'local') {
+            return {
+                success: false,
+                newPatterns: 0,
+                improvedAccuracy: '0%',
+                modelVersion: 'local',
+                message: 'Cloud sync disabled (local mode)'
+            };
+        }
+        try {
+            const response = await fetch(`${this.baseUrl}/api/v1/learnings`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'X-User-Id': this.userId
+                },
+                body: JSON.stringify({
+                    userId: this.userId,
+                    sessionId: `session-${Date.now()}`,
+                    learnings
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`API error: ${response.status}`);
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                newPatterns: data.newPatterns || 0,
+                improvedAccuracy: data.improvedAccuracy || '0%',
+                modelVersion: data.modelVersion || 'v1.0.0'
+            };
+        }
+        catch (error) {
+            log.error('Failed to upload learnings', { error, category: 'ai' });
+            return {
+                success: false,
+                newPatterns: 0,
+                improvedAccuracy: '0%',
+                modelVersion: 'error',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    async downloadPatterns(limit = 10000) {
+        if (!this.config.enabled || this.config.provider === 'local') {
+            return [];
+        }
+        try {
+            const response = await fetch(`${this.baseUrl}/api/v1/patterns?limit=${limit}`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'X-User-Id': this.userId
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`API error: ${response.status}`);
+            }
+            const data = await response.json();
+            return data.patterns || [];
+        }
+        catch (error) {
+            log.error('Failed to download patterns', { error, category: 'ai' });
+            return [];
+        }
+    }
+    async checkHealth() {
+        try {
+            const response = await fetch(`${this.baseUrl}/health`, {
+                method: 'GET',
+                headers: { 'X-User-Id': this.userId }
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/ai/cloud/modelSync.d.ts

@@ -0,0 +1,18 @@
+import { CloudAPI } from './api.js';
+import { FixStore } from '../local/fixStore.js';
+import { AIConfig } from '../config.js';
+export declare class ModelSync {
+    private store;
+    private api;
+    private config;
+    constructor(store: FixStore, api: CloudAPI, config: AIConfig);
+    sync(): Promise<{
+        synced: number;
+        merged: number;
+        conflicts: number;
+    }>;
+    contribute(): Promise<{
+        uploaded: number;
+        success: boolean;
+    }>;
+}

package/dist/ai/cloud/modelSync.js

@@ -0,0 +1,104 @@
+import { log } from '../../utils/logger.js';
+export class ModelSync {
+    constructor(store, api, config) {
+        this.store = store;
+        this.api = api;
+        this.config = config;
+    }
+    async sync() {
+        if (!this.config.enabled || this.config.provider === 'local') {
+            log.info('Cloud sync disabled (local mode)', { category: 'ai' });
+            return { synced: 0, merged: 0, conflicts: 0 };
+        }
+        log.info('Syncing with global learning network...', { category: 'ai' });
+        try {
+            // 1. Check API health
+            const healthy = await this.api.checkHealth();
+            if (!healthy) {
+                log.error('Cloud API is unavailable', { category: 'ai' });
+                return { synced: 0, merged: 0, conflicts: 0 };
+            }
+            // 2. Download global patterns
+            const globalPatterns = await this.api.downloadPatterns();
+            if (globalPatterns.length === 0) {
+                log.info('No new patterns available', { category: 'ai' });
+                return { synced: 0, merged: 0, conflicts: 0 };
+            }
+            // 3. Merge with local patterns
+            let merged = 0;
+            let conflicts = 0;
+            for (const pattern of globalPatterns) {
+                try {
+                    // Check if we already have this error
+                    const localFixes = this.store.findFixes(pattern.errorSignature);
+                    if (localFixes.length === 0) {
+                        // New pattern - add it
+                        this.store.saveError({
+                            id: pattern.errorSignature,
+                            signature: pattern.errorSignature,
+                            type: 'unknown',
+                            context: { framework: pattern.framework, configHash: 'unknown' },
+                            timestamp: Date.now()
+                        });
+                        const fixId = this.store.saveFix(pattern.errorSignature, pattern.fix);
+                        // Simulate success based on global success rate
+                        const successCount = Math.floor(pattern.usageCount * pattern.successRate);
+                        const failCount = pattern.usageCount - successCount;
+                        for (let i = 0; i < successCount; i++) {
+                            this.store.recordOutcome(fixId, true);
+                        }
+                        for (let i = 0; i < failCount; i++) {
+                            this.store.recordOutcome(fixId, false);
+                        }
+                        merged++;
+                    }
+                    else {
+                        // Conflict: we have local data
+                        // Strategy: Global wins if success rate > local
+                        conflicts++;
+                        // TODO: Implement conflict resolution
+                    }
+                }
+                catch (e) {
+                    log.warn('Failed to merge pattern', { error: e, category: 'ai' });
+                }
+            }
+            log.success(`Synced ${globalPatterns.length} patterns (${merged} merged, ${conflicts} conflicts)`, { category: 'ai' });
+            return {
+                synced: globalPatterns.length,
+                merged,
+                conflicts
+            };
+        }
+        catch (error) {
+            log.error('Sync failed', { error, category: 'ai' });
+            return { synced: 0, merged: 0, conflicts: 0 };
+        }
+    }
+    async contribute() {
+        if (!this.config.enabled || this.config.provider === 'local') {
+            log.info('Cloud contributions disabled (local mode)', { category: 'ai' });
+            return { uploaded: 0, success: false };
+        }
+        log.info('Contributing local patterns to global network...', { category: 'ai' });
+        try {
+            // Get local stats
+            const stats = this.store.getStats();
+            if (stats.successfulFixes === 0) {
+                log.info('No successful fixes to contribute', { category: 'ai' });
+                return { uploaded: 0, success: true };
+            }
+            // TODO: Extract and anonymize local learnings
+            // For now, just report intent
+            log.success(`Ready to contribute ${stats.successfulFixes} successful fixes`, { category: 'ai' });
+            return {
+                uploaded: 0, // Will be implemented when backend is ready
+                success: true
+            };
+        }
+        catch (error) {
+            log.error('Contribution failed', { error, category: 'ai' });
+            return { uploaded: 0, success: false };
+        }
+    }
+}

package/dist/ai/cloud/telemetry.d.ts

@@ -0,0 +1,14 @@
+import { LearnedError } from '../core/errorMemory.js';
+import { FixAction } from '../healer/fixer.js';
+export interface AnonymizedLearning {
+    errorSignature: string;
+    fixSignature: string;
+    success: boolean;
+    durationMs: number;
+    projectSize: number;
+    framework: string;
+    anonymized: true;
+}
+export declare class TelemetryCollector {
+    static anonymize(error: LearnedError, fix: FixAction, success: boolean, durationMs: number, projectSize: number): AnonymizedLearning;
+}

package/dist/ai/cloud/telemetry.js

@@ -0,0 +1,23 @@
+import crypto from 'crypto';
+export class TelemetryCollector {
+    static anonymize(error, fix, success, durationMs, projectSize) {
+        // Hash everything - NO source code, NO file contents, NO config values
+        const errorSignature = crypto
+            .createHash('sha256')
+            .update(error.signature + JSON.stringify(error.context))
+            .digest('hex');
+        const fixSignature = crypto
+            .createHash('sha256')
+            .update(JSON.stringify(fix))
+            .digest('hex');
+        return {
+            errorSignature,
+            fixSignature,
+            success,
+            durationMs,
+            projectSize,
+            framework: error.context.framework || 'unknown',
+            anonymized: true
+        };
+    }
+}

package/dist/ai/config.d.ts

@@ -0,0 +1,14 @@
+export interface AIConfig {
+    enabled: boolean;
+    provider: 'local' | 'openai' | 'anthropic' | 'ollama';
+    apiKey?: string;
+    endpoint?: string;
+    modelName?: string;
+    maxTokens: number;
+    privacy: {
+        sendSourceSnippets: boolean;
+        allowRemoteTelemetry: boolean;
+    };
+    localModelPath?: string;
+}
+export declare const DEFAULT_AI_CONFIG: AIConfig;

package/dist/ai/config.js

@@ -0,0 +1,9 @@
+export const DEFAULT_AI_CONFIG = {
+    enabled: true,
+    provider: 'local',
+    maxTokens: 50000, // Daily limit
+    privacy: {
+        sendSourceSnippets: false,
+        allowRemoteTelemetry: false
+    }
+};

package/dist/ai/core/errorMemory.d.ts

@@ -0,0 +1,14 @@
+export interface LearnedError {
+    id: string;
+    type: 'missingDep' | 'syntax' | 'config' | 'unknown';
+    signature: string;
+    context: {
+        framework: string;
+        configHash: string;
+        snippet?: string;
+    };
+    timestamp: number;
+}
+export declare class ErrorMemory {
+    static normalize(rawError: string, context?: any): LearnedError;
+}