nuclie 1.0.0

package/dist/ai/core/errorMemory.js

@@ -0,0 +1,36 @@
+import crypto from 'crypto';
+export class ErrorMemory {
+    static normalize(rawError, context = {}) {
+        // 1. Strip volatile data (timestamps, absolute paths, line numbers)
+        // We want the "shape" of the error, not the specific instance
+        const cleanError = rawError
+            .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z/g, '<TIMESTAMP>')
+            .replace(/\/[\w\-\.]+(\/[\w\-\.]+)+/g, '<PATH>') // Unix paths
+            .replace(/[A-Z]:\\[\w\-\.]+(\\[\w\-\.]+)+/g, '<PATH>') // Windows paths
+            .replace(/\(\d+,\d+\)/g, '(<LINE>,<COL>)')
+            .replace(/line \d+/g, 'line <LINE>');
+        // 2. Generate Signature
+        const signature = crypto.createHash('sha256').update(cleanError).digest('hex');
+        // 3. Generate ID (Signature + Context helps, but for now ID = Signature for deduplication)
+        const id = signature;
+        // 4. Determine Type (Simple heuristic, can be expanded)
+        let type = 'unknown';
+        if (rawError.includes('Module not found') || rawError.includes('Cannot find module'))
+            type = 'missingDep';
+        else if (rawError.includes('SyntaxError') || rawError.includes('expected'))
+            type = 'syntax';
+        else if (rawError.includes('config') || rawError.includes('json'))
+            type = 'config';
+        return {
+            id,
+            type,
+            signature,
+            context: {
+                framework: context.framework || 'unknown',
+                configHash: context.configHash || 'unknown',
+                snippet: context.snippet
+            },
+            timestamp: Date.now()
+        };
+    }
+}

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

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

package/dist/ai/dashboard/cli.js

@@ -0,0 +1,32 @@
+import { Telemetry } from '../telemetry.js';
+import { log } from '../../utils/logger.js';
+export class DashboardCLI {
+    static async show(root) {
+        const sessions = await Telemetry.getSessions(root, 10);
+        if (sessions.length === 0) {
+            log.info('No build history found.', { category: 'ai' });
+            return;
+        }
+        console.log('\n📊 Build History (Last 10)\n');
+        // Header
+        console.log('ID'.padEnd(10) +
+            'Date'.padEnd(25) +
+            'Duration'.padEnd(15) +
+            'Status'.padEnd(10) +
+            'Modules');
+        console.log('-'.repeat(70));
+        // Rows
+        for (const s of sessions) {
+            const date = new Date(s.timestamp).toLocaleString();
+            const duration = (s.duration / 1000).toFixed(2) + 's';
+            const status = s.success ? '✅ PASS' : '❌ FAIL';
+            const modules = s.metrics?.modules?.toString() || '-';
+            console.log(s.id.substring(0, 8).padEnd(10) +
+                date.padEnd(25) +
+                duration.padEnd(15) +
+                status.padEnd(10) +
+                modules);
+        }
+        console.log('');
+    }
+}

package/dist/ai/healer/applier.d.ts

@@ -0,0 +1,9 @@
+import { FixAction } from './fixer.js';
+export declare class FixApplier {
+    private root;
+    private store;
+    constructor(root: string);
+    apply(fix: FixAction, fixId?: string): Promise<boolean>;
+    private backup;
+    rollback(filePath: string): Promise<void>;
+}

package/dist/ai/healer/applier.js

@@ -0,0 +1,74 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { log } from '../../utils/logger.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { FixStore } from '../local/fixStore.js';
+const execAsync = promisify(exec);
+export class FixApplier {
+    constructor(root) {
+        this.root = root;
+        this.store = new FixStore(root);
+    }
+    async apply(fix, fixId) {
+        log.info(`Applying fix: ${fix.description}`, { category: 'ai' });
+        // 1. Backup
+        const backupFiles = [];
+        if (fix.type === 'FILE_EDIT' && fix.file) {
+            const filePath = path.join(this.root, fix.file);
+            await this.backup(filePath);
+            backupFiles.push(filePath);
+        }
+        try {
+            // 2. Apply
+            let success = false;
+            if (fix.type === 'SHELL_COMMAND' && fix.command) {
+                await execAsync(fix.command, { cwd: this.root });
+                success = true; // Command ran without error
+            }
+            else if (fix.type === 'FILE_EDIT' && fix.file && fix.diff) {
+                // TODO: Real patch application. For now, we assume success if we could write
+                log.warn('File edit application not fully implemented yet', { category: 'ai' });
+                success = false;
+            }
+            // 3. Verify (Optional: could run build here)
+            // For Phase 1, we assume if the command/edit succeeded, the fix is "applied". 
+            // Real verification happens on the NEXT build.
+            if (success && fixId) {
+                this.store.recordOutcome(fixId, true);
+            }
+            return success;
+        }
+        catch (e) {
+            log.error('Failed to apply fix', { error: e });
+            // 4. Rollback
+            for (const file of backupFiles) {
+                await this.rollback(file);
+            }
+            if (fixId) {
+                this.store.recordOutcome(fixId, false);
+            }
+            return false;
+        }
+    }
+    async backup(filePath) {
+        try {
+            const content = await fs.readFile(filePath);
+            await fs.writeFile(`${filePath}.bak`, content);
+        }
+        catch (e) {
+            // Ignore if file doesn't exist
+        }
+    }
+    async rollback(filePath) {
+        try {
+            const bakPath = `${filePath}.bak`;
+            await fs.copyFile(bakPath, filePath);
+            await fs.unlink(bakPath);
+            log.info(`Rolled back ${path.basename(filePath)}`, { category: 'ai' });
+        }
+        catch (e) {
+            log.error('Rollback failed', { error: e });
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare class HealerCLI {
+    static handle(error: Error): Promise<void>;
+}

package/dist/ai/healer/cli.js

@@ -0,0 +1,57 @@
+import { ErrorParser } from './parser.js';
+import { FixGenerator } from './fixer.js';
+import { LLMFixer } from './llm.js';
+import { DEFAULT_AI_CONFIG } from '../config.js';
+import { log } from '../../utils/logger.js';
+import { createInterface } from 'readline';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class HealerCLI {
+    static async handle(error) {
+        const parsed = ErrorParser.parse(error.message);
+        log.error(`Build Failed: ${parsed.message}`, { category: 'ai' });
+        // 1. Static Pattern Fixes
+        let fixes = FixGenerator.generate(parsed);
+        // 2. LLM Fallback
+        if (fixes.length === 0 || fixes[0].confidence < 0.7) {
+            log.info('No high-confidence local fix. Consulting AI...', { category: 'ai' });
+            const llm = new LLMFixer(DEFAULT_AI_CONFIG);
+            const aiFixes = await llm.fix(parsed);
+            fixes = [...fixes, ...aiFixes];
+        }
+        if (fixes.length === 0)
+            return;
+        console.log('\n🤖 AI Self-Healer Suggestions:');
+        fixes.forEach((fix, i) => {
+            log.info(`${i + 1}. [${Math.round(fix.confidence * 100)}%] ${fix.description}`, { category: 'ai' });
+            if (fix.command)
+                log.info(`   Command: ${fix.command}`, { category: 'ai' });
+        });
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const answer = await new Promise(resolve => {
+            rl.question('\nApply fix? (number/n): ', resolve);
+        });
+        rl.close();
+        const choice = parseInt(answer);
+        if (!isNaN(choice) && choice > 0 && choice <= fixes.length) {
+            const fix = fixes[choice - 1];
+            if (fix.type === 'SHELL_COMMAND' && fix.command) {
+                log.info(`Executing: ${fix.command}`, { category: 'ai' });
+                try {
+                    await execAsync(fix.command);
+                    log.success('Fix applied! Try running build again.', { category: 'ai' });
+                }
+                catch (e) {
+                    log.error('Failed to apply fix', { error: e });
+                }
+            }
+            else {
+                log.info('Please apply this fix manually.', { category: 'ai' });
+            }
+        }
+    }
+}

package/dist/ai/healer/collector.d.ts

@@ -0,0 +1,16 @@
+export interface BuildError {
+    type: 'MISSING_DEPENDENCY' | 'SYNTAX_ERROR' | 'CONFIG_ERROR' | 'RUNTIME_ERROR' | 'UNKNOWN';
+    message: string;
+    file?: string;
+    line?: number;
+    column?: number;
+    raw: string;
+    context?: any;
+}
+export declare class ErrorCollector {
+    private errors;
+    collect(rawError: any): BuildError;
+    getErrors(): BuildError[];
+    private normalize;
+    private extractPackageName;
+}

package/dist/ai/healer/collector.js

@@ -0,0 +1,41 @@
+export class ErrorCollector {
+    constructor() {
+        this.errors = [];
+    }
+    collect(rawError) {
+        const error = this.normalize(rawError);
+        this.errors.push(error);
+        return error;
+    }
+    getErrors() {
+        return this.errors;
+    }
+    normalize(raw) {
+        const message = raw.message || raw.toString();
+        // Simple heuristic normalization
+        if (message.includes('Module not found') || message.includes('Cannot find module')) {
+            return {
+                type: 'MISSING_DEPENDENCY',
+                message,
+                raw: message,
+                context: { package: this.extractPackageName(message) }
+            };
+        }
+        if (message.includes('SyntaxError') || message.includes('expected')) {
+            return {
+                type: 'SYNTAX_ERROR',
+                message,
+                raw: message
+            };
+        }
+        return {
+            type: 'UNKNOWN',
+            message,
+            raw: message
+        };
+    }
+    extractPackageName(msg) {
+        const match = msg.match(/Cannot find module '([^']+)'/) || msg.match(/Can't resolve '([^']+)'/);
+        return match ? match[1] : undefined;
+    }
+}

package/dist/ai/healer/fixer.d.ts

@@ -0,0 +1,12 @@
+import { ParsedError } from './parser.js';
+export interface FixAction {
+    type: 'SHELL_COMMAND' | 'FILE_EDIT' | 'MANUAL_INSTRUCTION';
+    description: string;
+    command?: string;
+    file?: string;
+    diff?: string;
+    confidence: number;
+}
+export declare class FixGenerator {
+    static generate(error: ParsedError): FixAction[];
+}

package/dist/ai/healer/fixer.js

@@ -0,0 +1,40 @@
+import { CommonPatterns } from '../patterns/common.js';
+export class FixGenerator {
+    static generate(error) {
+        const fixes = [];
+        // 1. Check Pattern Library
+        for (const pattern of CommonPatterns) {
+            const match = error.originalError.match(pattern.regex);
+            if (match) {
+                fixes.push(pattern.generator(match));
+            }
+        }
+        if (fixes.length > 0)
+            return fixes;
+        // 2. Fallback to Heuristics (Legacy)
+        if (error.type === 'MISSING_DEPENDENCY' && error.context.package) {
+            const pkg = error.context.package;
+            fixes.push({
+                type: 'SHELL_COMMAND',
+                description: `Install missing dependency: ${pkg}`,
+                command: `npm install ${pkg}`, // TODO: Detect package manager
+                confidence: 0.95
+            });
+        }
+        if (error.type === 'SYNTAX_ERROR' && error.context.file) {
+            fixes.push({
+                type: 'MANUAL_INSTRUCTION',
+                description: `Check syntax in ${error.context.file} at line ${error.context.line}`,
+                confidence: 0.8
+            });
+        }
+        if (error.type === 'UNKNOWN') {
+            fixes.push({
+                type: 'MANUAL_INSTRUCTION',
+                description: 'Ask AI for help (LLM analysis required)',
+                confidence: 0.5
+            });
+        }
+        return fixes;
+    }
+}

package/dist/ai/healer/llm.d.ts

@@ -0,0 +1,9 @@
+import { ParsedError } from './parser.js';
+import { FixAction } from './fixer.js';
+import { AIConfig } from '../config.js';
+export declare class LLMFixer {
+    private config;
+    private ollama;
+    constructor(config: AIConfig);
+    fix(error: ParsedError): Promise<FixAction[]>;
+}

package/dist/ai/healer/llm.js

@@ -0,0 +1,20 @@
+import { OllamaProvider } from '../llm/ollama.js';
+export class LLMFixer {
+    constructor(config) {
+        this.config = config;
+        this.ollama = new OllamaProvider(config);
+    }
+    async fix(error) {
+        if (!this.config.enabled)
+            return [];
+        if (this.config.provider === 'ollama') {
+            return await this.ollama.suggestFix(error);
+        }
+        // Generic fallback for other cloud providers
+        return [{
+                type: 'MANUAL_INSTRUCTION',
+                description: `Cloud provider ${this.config.provider} not yet fully implemented.`,
+                confidence: 0.1
+            }];
+    }
+}

package/dist/ai/healer/parser.d.ts

@@ -0,0 +1,16 @@
+export type ErrorType = 'MISSING_DEPENDENCY' | 'SYNTAX_ERROR' | 'CONFIG_ERROR' | 'UNKNOWN';
+export interface ParsedError {
+    type: ErrorType;
+    message: string;
+    context: {
+        package?: string;
+        file?: string;
+        line?: number;
+        column?: number;
+        snippet?: string;
+    };
+    originalError: string;
+}
+export declare class ErrorParser {
+    static parse(error: string): ParsedError;
+}

package/dist/ai/healer/parser.js

@@ -0,0 +1,67 @@
+export class ErrorParser {
+    static parse(error) {
+        // 1. Missing Dependency
+        // "Module not found: Error: Can't resolve 'react'"
+        // "Error: Cannot find module 'react'"
+        const missingDepMatch = error.match(/Can't resolve '(@?[\w-]+(?:\/[\w-]+)*)'/i) ||
+            error.match(/Cannot find module '(@?[\w-]+(?:\/[\w-]+)*)'/i);
+        if (missingDepMatch) {
+            return {
+                type: 'MISSING_DEPENDENCY',
+                message: `Missing dependency: ${missingDepMatch[1]}`,
+                context: { package: missingDepMatch[1] },
+                originalError: error
+            };
+        }
+        // 2. Syntax Error
+        // "SyntaxError: Unexpected token (10:5)"
+        // "file.ts(10,5): error TS1005: ')' expected."
+        const syntaxMatch = error.match(/(.*?)\((\d+),(\d+)\): error TS/);
+        if (syntaxMatch) {
+            return {
+                type: 'SYNTAX_ERROR',
+                message: 'Syntax Error',
+                context: {
+                    file: syntaxMatch[1],
+                    line: parseInt(syntaxMatch[2]),
+                    column: parseInt(syntaxMatch[3])
+                },
+                originalError: error
+            };
+        }
+        // 3. React Version Mismatch
+        if (error.includes('Invalid hook call') || error.includes('more than one copy of React')) {
+            return {
+                type: 'CONFIG_ERROR',
+                message: 'React Version Mismatch',
+                context: { snippet: 'Multiple React versions detected' },
+                originalError: error
+            };
+        }
+        // 4. Missing Loader
+        const loaderMatch = error.match(/You may need an appropriate loader to handle this file type/);
+        if (loaderMatch) {
+            return {
+                type: 'CONFIG_ERROR',
+                message: 'Missing Loader',
+                context: { snippet: 'File type not supported by current config' },
+                originalError: error
+            };
+        }
+        // 5. Config Error (Generic heuristic)
+        if (error.toLowerCase().includes('config') || error.toLowerCase().includes('json')) {
+            return {
+                type: 'CONFIG_ERROR',
+                message: 'Configuration Error',
+                context: {},
+                originalError: error
+            };
+        }
+        return {
+            type: 'UNKNOWN',
+            message: 'Unknown Build Error',
+            context: {},
+            originalError: error
+        };
+    }
+}

package/dist/ai/learning/evolver.d.ts

@@ -0,0 +1,8 @@
+import { FixStore } from '../local/fixStore.js';
+import { FixAction } from '../healer/fixer.js';
+export declare class Evolver {
+    private store;
+    constructor(store: FixStore);
+    getBestFix(errorId: string): FixAction | null;
+    evolve(errorId: string, failedFix: FixAction): Promise<void>;
+}

package/dist/ai/learning/evolver.js

@@ -0,0 +1,24 @@
+export class Evolver {
+    constructor(store) {
+        this.store = store;
+    }
+    getBestFix(errorId) {
+        const fixes = this.store.findFixes(errorId);
+        if (fixes.length === 0)
+            return null;
+        // Simple A/B testing logic:
+        // 90% time pick best fix
+        // 10% time pick random fix (exploration)
+        if (Math.random() > 0.1) {
+            return fixes[0];
+        }
+        else {
+            const randomIndex = Math.floor(Math.random() * fixes.length);
+            return fixes[randomIndex];
+        }
+    }
+    async evolve(errorId, failedFix) {
+        // If a fix failed, we might want to trigger LLM to generate a variant
+        // For Phase 2, we just record the failure (handled by FixStore)
+    }
+}

package/dist/ai/llm/fixGenerator.d.ts

@@ -0,0 +1,9 @@
+import { LearnedError } from '../core/errorMemory.js';
+import { ProjectProfile } from '../schema.js';
+import { FixAction } from '../healer/fixer.js';
+import { AIConfig } from '../config.js';
+export declare class LLMFixGenerator {
+    private config;
+    constructor(config: AIConfig);
+    generateFix(error: LearnedError, profile: ProjectProfile): Promise<FixAction[]>;
+}

package/dist/ai/llm/fixGenerator.js

@@ -0,0 +1,21 @@
+export class LLMFixGenerator {
+    constructor(config) {
+        this.config = config;
+    }
+    async generateFix(error, profile) {
+        if (!this.config.enabled || this.config.provider === 'local') {
+            // Local fallback: return empty or generic suggestion
+            return [{
+                    type: 'MANUAL_INSTRUCTION',
+                    description: 'Complex error detected. Please check online documentation or enable Cloud AI.',
+                    confidence: 0.1
+                }];
+        }
+        // TODO: Implement Cloud Provider Call
+        // Prompt:
+        // Error: ${error.signature}
+        // Context: ${JSON.stringify(error.context)}
+        // Framework: ${profile.framework}
+        return [];
+    }
+}

package/dist/ai/llm/ollama.d.ts

@@ -0,0 +1,10 @@
+import { AIConfig } from '../config.js';
+import { FixAction } from '../healer/fixer.js';
+import { ParsedError } from '../healer/parser.js';
+export declare class OllamaProvider {
+    private endpoint;
+    private model;
+    constructor(config: AIConfig);
+    suggestFix(error: ParsedError): Promise<FixAction[]>;
+    private generatePrompt;
+}

package/dist/ai/llm/ollama.js

@@ -0,0 +1,56 @@
+export class OllamaProvider {
+    constructor(config) {
+        this.endpoint = config.endpoint || 'http://localhost:11434/api/generate';
+        this.model = config.modelName || 'codellama';
+    }
+    async suggestFix(error) {
+        const prompt = this.generatePrompt(error);
+        try {
+            const response = await fetch(this.endpoint, {
+                method: 'POST',
+                body: JSON.stringify({
+                    model: this.model,
+                    prompt: prompt,
+                    stream: false,
+                    format: 'json'
+                }),
+                headers: { 'Content-Type': 'application/json' }
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama error: ${response.statusText}`);
+            }
+            const data = await response.json();
+            const result = JSON.parse(data.response);
+            return result.fixes.map((f) => ({
+                ...f,
+                confidence: f.confidence || 0.8
+            }));
+        }
+        catch (e) {
+            console.error('Failed to get fix from Ollama:', e);
+            return [];
+        }
+    }
+    generatePrompt(error) {
+        return `You are an AI build engineer for the Nuclie build tool.
+Analyze the following build error and suggest a fix in JSON format.
+
+Error Message: ${error.message}
+Error Type: ${error.type}
+Context: ${JSON.stringify(error.context)}
+
+The response MUST be a JSON object with a "fixes" array:
+{
+  "fixes": [
+    {
+      "type": "SHELL_COMMAND" | "FILE_EDIT" | "MANUAL_INSTRUCTION",
+      "description": "Short explanation",
+      "command": "terminal command to run",
+      "confidence": 0.9
+    }
+  ]
+}
+
+Respond ONLY with valid JSON.`;
+    }
+}

package/dist/ai/local/fixStore.d.ts

@@ -0,0 +1,19 @@
+import { LearnedError } from '../core/errorMemory.js';
+import { FixAction } from '../healer/fixer.js';
+export declare class FixStore {
+    private db;
+    constructor(rootDir: string);
+    private init;
+    saveError(error: LearnedError): void;
+    saveFix(errorId: string, fix: FixAction): string;
+    findFixes(errorId: string): FixAction[];
+    private calculateScore;
+    recordOutcome(fixId: string, success: boolean): void;
+    private generateFixId;
+    getStats(): {
+        errors: number;
+        fixes: number;
+        successfulFixes: number;
+    };
+    deleteError(errorId: string): void;
+}